com.pulumi.cloudflare.kotlin.inputs.CustomSslCustomSslOptionsArgs.kt Maven / Gradle / Ivy

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

package com.pulumi.cloudflare.kotlin.inputs

import com.pulumi.cloudflare.inputs.CustomSslCustomSslOptionsArgs.builder
import com.pulumi.core.Output
import com.pulumi.core.Output.of
import com.pulumi.kotlin.ConvertibleToJava
import com.pulumi.kotlin.PulumiTagMarker
import kotlin.String
import kotlin.Suppress
import kotlin.jvm.JvmName

/**
 *
 * @property bundleMethod Method of building intermediate certificate chain. A ubiquitous bundle has the highest probability of being verified everywhere, even by clients using outdated or unusual trust stores. An optimal bundle uses the shortest chain and newest intermediates. And the force bundle verifies the chain, but does not otherwise modify it. Available values: `ubiquitous`, `optimal`, `force`.
 * @property certificate Certificate certificate and the intermediate(s).
 * @property geoRestrictions Specifies the region where your private key can be held locally. Available values: `us`, `eu`, `highest_security`.
 * @property privateKey Certificate's private key.
 * @property type Whether to enable support for legacy clients which do not include SNI in the TLS handshake. Available values: `legacy_custom`, `sni_custom`.
 */
public data class CustomSslCustomSslOptionsArgs(
    public val bundleMethod: Output? = null,
    public val certificate: Output? = null,
    public val geoRestrictions: Output? = null,
    public val privateKey: Output? = null,
    public val type: Output? = null,
) : ConvertibleToJava {
    override fun toJava(): com.pulumi.cloudflare.inputs.CustomSslCustomSslOptionsArgs =
        com.pulumi.cloudflare.inputs.CustomSslCustomSslOptionsArgs.builder()
            .bundleMethod(bundleMethod?.applyValue({ args0 -> args0 }))
            .certificate(certificate?.applyValue({ args0 -> args0 }))
            .geoRestrictions(geoRestrictions?.applyValue({ args0 -> args0 }))
            .privateKey(privateKey?.applyValue({ args0 -> args0 }))
            .type(type?.applyValue({ args0 -> args0 })).build()
}

/**
 * Builder for [CustomSslCustomSslOptionsArgs].
 */
@PulumiTagMarker
public class CustomSslCustomSslOptionsArgsBuilder internal constructor() {
    private var bundleMethod: Output? = null

    private var certificate: Output? = null

    private var geoRestrictions: Output? = null

    private var privateKey: Output? = null

    private var type: Output? = null

    /**
     * @param value Method of building intermediate certificate chain. A ubiquitous bundle has the highest probability of being verified everywhere, even by clients using outdated or unusual trust stores. An optimal bundle uses the shortest chain and newest intermediates. And the force bundle verifies the chain, but does not otherwise modify it. Available values: `ubiquitous`, `optimal`, `force`.
     */
    @JvmName("exrqmylhopwrlsrv")
    public suspend fun bundleMethod(`value`: Output) {
        this.bundleMethod = value
    }

    /**
     * @param value Certificate certificate and the intermediate(s).
     */
    @JvmName("wdvjscqfuppkuhcp")
    public suspend fun certificate(`value`: Output) {
        this.certificate = value
    }

    /**
     * @param value Specifies the region where your private key can be held locally. Available values: `us`, `eu`, `highest_security`.
     */
    @JvmName("rugqblghmfyubvtb")
    public suspend fun geoRestrictions(`value`: Output) {
        this.geoRestrictions = value
    }

    /**
     * @param value Certificate's private key.
     */
    @JvmName("vqtrifxocrahficw")
    public suspend fun privateKey(`value`: Output) {
        this.privateKey = value
    }

    /**
     * @param value Whether to enable support for legacy clients which do not include SNI in the TLS handshake. Available values: `legacy_custom`, `sni_custom`.
     */
    @JvmName("iknhqllrorbaanok")
    public suspend fun type(`value`: Output) {
        this.type = value
    }

    /**
     * @param value Method of building intermediate certificate chain. A ubiquitous bundle has the highest probability of being verified everywhere, even by clients using outdated or unusual trust stores. An optimal bundle uses the shortest chain and newest intermediates. And the force bundle verifies the chain, but does not otherwise modify it. Available values: `ubiquitous`, `optimal`, `force`.
     */
    @JvmName("jadjifjtbgwfyipe")
    public suspend fun bundleMethod(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.bundleMethod = mapped
    }

    /**
     * @param value Certificate certificate and the intermediate(s).
     */
    @JvmName("hrhyndaisgmkltlf")
    public suspend fun certificate(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.certificate = mapped
    }

    /**
     * @param value Specifies the region where your private key can be held locally. Available values: `us`, `eu`, `highest_security`.
     */
    @JvmName("gwocmujignhrvkyp")
    public suspend fun geoRestrictions(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.geoRestrictions = mapped
    }

    /**
     * @param value Certificate's private key.
     */
    @JvmName("weavbqiuwbqhbmut")
    public suspend fun privateKey(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.privateKey = mapped
    }

    /**
     * @param value Whether to enable support for legacy clients which do not include SNI in the TLS handshake. Available values: `legacy_custom`, `sni_custom`.
     */
    @JvmName("ognmunpyshkifmwu")
    public suspend fun type(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.type = mapped
    }

    internal fun build(): CustomSslCustomSslOptionsArgs = CustomSslCustomSslOptionsArgs(
        bundleMethod = bundleMethod,
        certificate = certificate,
        geoRestrictions = geoRestrictions,
        privateKey = privateKey,
        type = type,
    )
}