com.pulumi.cloudflare.kotlin.inputs.CustomHostnameSslArgs.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.47.0.0
Show newest version
@file:Suppress("NAME_SHADOWING", "DEPRECATION")

package com.pulumi.cloudflare.kotlin.inputs

import com.pulumi.cloudflare.inputs.CustomHostnameSslArgs.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

/**
 *
 * @property bundleMethod 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 certificateAuthority
 * @property customCertificate If a custom uploaded certificate is used.
 * @property customKey The key for a custom uploaded certificate.
 * @property method Domain control validation (DCV) method used for this hostname. Available values: `http`, `txt`, `email`.
 * @property settings SSL/TLS settings for the certificate.
 * @property status
 * @property type Level of validation to be used for this hostname. Available values: `dv`. Defaults to `dv`.
 * @property validationErrors
 * @property validationRecords
 * @property wildcard Indicates whether the certificate covers a wildcard.
 */
public data class CustomHostnameSslArgs(
    public val bundleMethod: Output? = null,
    public val certificateAuthority: Output? = null,
    public val customCertificate: Output? = null,
    public val customKey: Output? = null,
    public val method: Output? = null,
    public val settings: Output>? = null,
    public val status: Output? = null,
    public val type: Output? = null,
    public val validationErrors: Output>? = null,
    public val validationRecords: Output>? = null,
    public val wildcard: Output? = null,
) : ConvertibleToJava {
    override fun toJava(): com.pulumi.cloudflare.inputs.CustomHostnameSslArgs =
        com.pulumi.cloudflare.inputs.CustomHostnameSslArgs.builder()
            .bundleMethod(bundleMethod?.applyValue({ args0 -> args0 }))
            .certificateAuthority(certificateAuthority?.applyValue({ args0 -> args0 }))
            .customCertificate(customCertificate?.applyValue({ args0 -> args0 }))
            .customKey(customKey?.applyValue({ args0 -> args0 }))
            .method(method?.applyValue({ args0 -> args0 }))
            .settings(
                settings?.applyValue({ args0 ->
                    args0.map({ args0 ->
                        args0.let({ args0 ->
                            args0.toJava()
                        })
                    })
                }),
            )
            .status(status?.applyValue({ args0 -> args0 }))
            .type(type?.applyValue({ args0 -> args0 }))
            .validationErrors(
                validationErrors?.applyValue({ args0 ->
                    args0.map({ args0 ->
                        args0.let({ args0 ->
                            args0.toJava()
                        })
                    })
                }),
            )
            .validationRecords(
                validationRecords?.applyValue({ args0 ->
                    args0.map({ args0 ->
                        args0.let({ args0 ->
                            args0.toJava()
                        })
                    })
                }),
            )
            .wildcard(wildcard?.applyValue({ args0 -> args0 })).build()
}

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

    private var certificateAuthority: Output? = null

    private var customCertificate: Output? = null

    private var customKey: Output? = null

    private var method: Output? = null

    private var settings: Output>? = null

    private var status: Output? = null

    private var type: Output? = null

    private var validationErrors: Output>? = null

    private var validationRecords: Output>? = null

    private var wildcard: Output? = null

    /**
     * @param value 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("cijjrxbbvklnhrrg")
    public suspend fun bundleMethod(`value`: Output) {
        this.bundleMethod = value
    }

    /**
     * @param value
     */
    @JvmName("wxmfhkrnmpnysfud")
    public suspend fun certificateAuthority(`value`: Output) {
        this.certificateAuthority = value
    }

    /**
     * @param value If a custom uploaded certificate is used.
     */
    @JvmName("iubqeyorbunivxvx")
    public suspend fun customCertificate(`value`: Output) {
        this.customCertificate = value
    }

    /**
     * @param value The key for a custom uploaded certificate.
     */
    @JvmName("dbuktwtekgwcumcd")
    public suspend fun customKey(`value`: Output) {
        this.customKey = value
    }

    /**
     * @param value Domain control validation (DCV) method used for this hostname. Available values: `http`, `txt`, `email`.
     */
    @JvmName("didbmojimalpoewu")
    public suspend fun method(`value`: Output) {
        this.method = value
    }

    /**
     * @param value SSL/TLS settings for the certificate.
     */
    @JvmName("iiwshxyxcjxultoa")
    public suspend fun settings(`value`: Output>) {
        this.settings = value
    }

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

    /**
     * @param values SSL/TLS settings for the certificate.
     */
    @JvmName("vejpmfcpcabfkcnr")
    public suspend fun settings(values: List>) {
        this.settings = Output.all(values)
    }

    /**
     * @param value
     */
    @JvmName("nppqohwdwqgyamrg")
    public suspend fun status(`value`: Output) {
        this.status = value
    }

    /**
     * @param value Level of validation to be used for this hostname. Available values: `dv`. Defaults to `dv`.
     */
    @JvmName("hjcyjykcagcmxqyl")
    public suspend fun type(`value`: Output) {
        this.type = value
    }

    /**
     * @param value
     */
    @JvmName("yhxutdsujpkofcsx")
    public suspend fun validationErrors(`value`: Output>) {
        this.validationErrors = value
    }

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

    /**
     * @param values
     */
    @JvmName("igvjhqakrcyivqpv")
    public suspend fun validationErrors(values: List>) {
        this.validationErrors = Output.all(values)
    }

    /**
     * @param value
     */
    @JvmName("nldtybgdrsivffgw")
    public suspend fun validationRecords(`value`: Output>) {
        this.validationRecords = value
    }

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

    /**
     * @param values
     */
    @JvmName("otqrpsmgjguxfiht")
    public suspend fun validationRecords(values: List>) {
        this.validationRecords = Output.all(values)
    }

    /**
     * @param value Indicates whether the certificate covers a wildcard.
     */
    @JvmName("dxtvjkgqjaqovvsy")
    public suspend fun wildcard(`value`: Output) {
        this.wildcard = value
    }

    /**
     * @param value 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("wwspgkxsdxnqajbt")
    public suspend fun bundleMethod(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.bundleMethod = mapped
    }

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

    /**
     * @param value If a custom uploaded certificate is used.
     */
    @JvmName("uivbdrnckapaheqy")
    public suspend fun customCertificate(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.customCertificate = mapped
    }

    /**
     * @param value The key for a custom uploaded certificate.
     */
    @JvmName("odjprsfmtrpmoaah")
    public suspend fun customKey(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.customKey = mapped
    }

    /**
     * @param value Domain control validation (DCV) method used for this hostname. Available values: `http`, `txt`, `email`.
     */
    @JvmName("odafyxxxkbombada")
    public suspend fun method(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.method = mapped
    }

    /**
     * @param value SSL/TLS settings for the certificate.
     */
    @JvmName("lbgytvlshavyiciw")
    public suspend fun settings(`value`: List?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.settings = mapped
    }

    /**
     * @param argument SSL/TLS settings for the certificate.
     */
    @JvmName("nydagvxqltamnndh")
    public suspend fun settings(argument: List Unit>) {
        val toBeMapped = argument.toList().map {
            CustomHostnameSslSettingArgsBuilder().applySuspend {
                it()
            }.build()
        }
        val mapped = of(toBeMapped)
        this.settings = mapped
    }

    /**
     * @param argument SSL/TLS settings for the certificate.
     */
    @JvmName("cbnkpaopeupelejf")
    public suspend fun settings(vararg argument: suspend CustomHostnameSslSettingArgsBuilder.() -> Unit) {
        val toBeMapped = argument.toList().map {
            CustomHostnameSslSettingArgsBuilder().applySuspend {
                it()
            }.build()
        }
        val mapped = of(toBeMapped)
        this.settings = mapped
    }

    /**
     * @param argument SSL/TLS settings for the certificate.
     */
    @JvmName("dsatvbrxfxjnvaxi")
    public suspend fun settings(argument: suspend CustomHostnameSslSettingArgsBuilder.() -> Unit) {
        val toBeMapped = listOf(
            CustomHostnameSslSettingArgsBuilder().applySuspend {
                argument()
            }.build(),
        )
        val mapped = of(toBeMapped)
        this.settings = mapped
    }

    /**
     * @param values SSL/TLS settings for the certificate.
     */
    @JvmName("nxausrpnlcpxwbnq")
    public suspend fun settings(vararg values: CustomHostnameSslSettingArgs) {
        val toBeMapped = values.toList()
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.settings = mapped
    }

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

    /**
     * @param value Level of validation to be used for this hostname. Available values: `dv`. Defaults to `dv`.
     */
    @JvmName("hytaoucxvpnmtiye")
    public suspend fun type(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.type = mapped
    }

    /**
     * @param value
     */
    @JvmName("aerdjkktfhahxiuo")
    public suspend fun validationErrors(`value`: List?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.validationErrors = mapped
    }

    /**
     * @param argument
     */
    @JvmName("xieuqffwyipomahd")
    public suspend fun validationErrors(argument: List Unit>) {
        val toBeMapped = argument.toList().map {
            CustomHostnameSslValidationErrorArgsBuilder().applySuspend { it() }.build()
        }
        val mapped = of(toBeMapped)
        this.validationErrors = mapped
    }

    /**
     * @param argument
     */
    @JvmName("cqenqafqihgwijsf")
    public suspend fun validationErrors(vararg argument: suspend CustomHostnameSslValidationErrorArgsBuilder.() -> Unit) {
        val toBeMapped = argument.toList().map {
            CustomHostnameSslValidationErrorArgsBuilder().applySuspend { it() }.build()
        }
        val mapped = of(toBeMapped)
        this.validationErrors = mapped
    }

    /**
     * @param argument
     */
    @JvmName("mdetfobrviixrxco")
    public suspend fun validationErrors(argument: suspend CustomHostnameSslValidationErrorArgsBuilder.() -> Unit) {
        val toBeMapped = listOf(
            CustomHostnameSslValidationErrorArgsBuilder().applySuspend {
                argument()
            }.build(),
        )
        val mapped = of(toBeMapped)
        this.validationErrors = mapped
    }

    /**
     * @param values
     */
    @JvmName("vrrevqmltaoboahv")
    public suspend fun validationErrors(vararg values: CustomHostnameSslValidationErrorArgs) {
        val toBeMapped = values.toList()
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.validationErrors = mapped
    }

    /**
     * @param value
     */
    @JvmName("henphxbybnavspwt")
    public suspend fun validationRecords(`value`: List?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.validationRecords = mapped
    }

    /**
     * @param argument
     */
    @JvmName("gbdcvgaaniesumaj")
    public suspend fun validationRecords(argument: List Unit>) {
        val toBeMapped = argument.toList().map {
            CustomHostnameSslValidationRecordArgsBuilder().applySuspend { it() }.build()
        }
        val mapped = of(toBeMapped)
        this.validationRecords = mapped
    }

    /**
     * @param argument
     */
    @JvmName("hlioskjlhoktlasx")
    public suspend fun validationRecords(vararg argument: suspend CustomHostnameSslValidationRecordArgsBuilder.() -> Unit) {
        val toBeMapped = argument.toList().map {
            CustomHostnameSslValidationRecordArgsBuilder().applySuspend { it() }.build()
        }
        val mapped = of(toBeMapped)
        this.validationRecords = mapped
    }

    /**
     * @param argument
     */
    @JvmName("qfstipxcmyoduglb")
    public suspend fun validationRecords(argument: suspend CustomHostnameSslValidationRecordArgsBuilder.() -> Unit) {
        val toBeMapped = listOf(
            CustomHostnameSslValidationRecordArgsBuilder().applySuspend {
                argument()
            }.build(),
        )
        val mapped = of(toBeMapped)
        this.validationRecords = mapped
    }

    /**
     * @param values
     */
    @JvmName("wbjbgfluiwednhxg")
    public suspend fun validationRecords(vararg values: CustomHostnameSslValidationRecordArgs) {
        val toBeMapped = values.toList()
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.validationRecords = mapped
    }

    /**
     * @param value Indicates whether the certificate covers a wildcard.
     */
    @JvmName("ovqplyougpchyolw")
    public suspend fun wildcard(`value`: Boolean?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.wildcard = mapped
    }

    internal fun build(): CustomHostnameSslArgs = CustomHostnameSslArgs(
        bundleMethod = bundleMethod,
        certificateAuthority = certificateAuthority,
        customCertificate = customCertificate,
        customKey = customKey,
        method = method,
        settings = settings,
        status = status,
        type = type,
        validationErrors = validationErrors,
        validationRecords = validationRecords,
        wildcard = wildcard,
    )
}