com.pulumi.gcp.dataloss.kotlin.inputs.PreventionInspectTemplateInspectConfigRuleSetRuleHotwordRuleArgs.kt Maven / Gradle / Ivy

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

package com.pulumi.gcp.dataloss.kotlin.inputs

import com.pulumi.core.Output
import com.pulumi.core.Output.of
import com.pulumi.gcp.dataloss.inputs.PreventionInspectTemplateInspectConfigRuleSetRuleHotwordRuleArgs.builder
import com.pulumi.kotlin.ConvertibleToJava
import com.pulumi.kotlin.PulumiNullFieldException
import com.pulumi.kotlin.PulumiTagMarker
import com.pulumi.kotlin.applySuspend
import kotlin.Suppress
import kotlin.Unit
import kotlin.jvm.JvmName

/**
 *
 * @property hotwordRegex Regular expression pattern defining what qualifies as a hotword.
 * Structure is documented below.
 * @property likelihoodAdjustment Likelihood adjustment to apply to all matching findings.
 * Structure is documented below.
 * @property proximity Proximity of the finding within which the entire hotword must reside. The total length of the window cannot
 * exceed 1000 characters. Note that the finding itself will be included in the window, so that hotwords may be
 * used to match substrings of the finding itself. For example, the certainty of a phone number regex
 * `(\d{3}) \d{3}-\d{4}` could be adjusted upwards if the area code is known to be the local area code of a company
 * office using the hotword regex `(xxx)`, where `xxx` is the area code in question.
 * Structure is documented below.
 */
public data class PreventionInspectTemplateInspectConfigRuleSetRuleHotwordRuleArgs(
    public val hotwordRegex: Output,
    public val likelihoodAdjustment: Output,
    public val proximity: Output,
) :
    ConvertibleToJava {
    override fun toJava(): com.pulumi.gcp.dataloss.inputs.PreventionInspectTemplateInspectConfigRuleSetRuleHotwordRuleArgs =
        com.pulumi.gcp.dataloss.inputs.PreventionInspectTemplateInspectConfigRuleSetRuleHotwordRuleArgs.builder()
            .hotwordRegex(hotwordRegex.applyValue({ args0 -> args0.let({ args0 -> args0.toJava() }) }))
            .likelihoodAdjustment(
                likelihoodAdjustment.applyValue({ args0 ->
                    args0.let({ args0 ->
                        args0.toJava()
                    })
                }),
            )
            .proximity(proximity.applyValue({ args0 -> args0.let({ args0 -> args0.toJava() }) })).build()
}

/**
 * Builder for [PreventionInspectTemplateInspectConfigRuleSetRuleHotwordRuleArgs].
 */
@PulumiTagMarker
public class PreventionInspectTemplateInspectConfigRuleSetRuleHotwordRuleArgsBuilder internal constructor() {
    private var hotwordRegex:
        Output? = null

    private var likelihoodAdjustment:
        Output? =
        null

    private var proximity:
        Output? = null

    /**
     * @param value Regular expression pattern defining what qualifies as a hotword.
     * Structure is documented below.
     */
    @JvmName("hdwstwhcfumlutop")
    public suspend fun hotwordRegex(`value`: Output) {
        this.hotwordRegex = value
    }

    /**
     * @param value Likelihood adjustment to apply to all matching findings.
     * Structure is documented below.
     */
    @JvmName("ephuwpgmfdgkusci")
    public suspend fun likelihoodAdjustment(`value`: Output) {
        this.likelihoodAdjustment = value
    }

    /**
     * @param value Proximity of the finding within which the entire hotword must reside. The total length of the window cannot
     * exceed 1000 characters. Note that the finding itself will be included in the window, so that hotwords may be
     * used to match substrings of the finding itself. For example, the certainty of a phone number regex
     * `(\d{3}) \d{3}-\d{4}` could be adjusted upwards if the area code is known to be the local area code of a company
     * office using the hotword regex `(xxx)`, where `xxx` is the area code in question.
     * Structure is documented below.
     */
    @JvmName("ifbdiqecnijoyguy")
    public suspend fun proximity(`value`: Output) {
        this.proximity = value
    }

    /**
     * @param value Regular expression pattern defining what qualifies as a hotword.
     * Structure is documented below.
     */
    @JvmName("kooxwtvklrhdxegt")
    public suspend fun hotwordRegex(`value`: PreventionInspectTemplateInspectConfigRuleSetRuleHotwordRuleHotwordRegexArgs) {
        val toBeMapped = value
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.hotwordRegex = mapped
    }

    /**
     * @param argument Regular expression pattern defining what qualifies as a hotword.
     * Structure is documented below.
     */
    @JvmName("vqmouymptkufhqmn")
    public suspend fun hotwordRegex(argument: suspend PreventionInspectTemplateInspectConfigRuleSetRuleHotwordRuleHotwordRegexArgsBuilder.() -> Unit) {
        val toBeMapped =
            PreventionInspectTemplateInspectConfigRuleSetRuleHotwordRuleHotwordRegexArgsBuilder().applySuspend {
                argument()
            }.build()
        val mapped = of(toBeMapped)
        this.hotwordRegex = mapped
    }

    /**
     * @param value Likelihood adjustment to apply to all matching findings.
     * Structure is documented below.
     */
    @JvmName("jogmbtncaobwpdgb")
    public suspend fun likelihoodAdjustment(`value`: PreventionInspectTemplateInspectConfigRuleSetRuleHotwordRuleLikelihoodAdjustmentArgs) {
        val toBeMapped = value
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.likelihoodAdjustment = mapped
    }

    /**
     * @param argument Likelihood adjustment to apply to all matching findings.
     * Structure is documented below.
     */
    @JvmName("febnuwnmdvmejhcl")
    public suspend fun likelihoodAdjustment(argument: suspend PreventionInspectTemplateInspectConfigRuleSetRuleHotwordRuleLikelihoodAdjustmentArgsBuilder.() -> Unit) {
        val toBeMapped =
            PreventionInspectTemplateInspectConfigRuleSetRuleHotwordRuleLikelihoodAdjustmentArgsBuilder().applySuspend {
                argument()
            }.build()
        val mapped = of(toBeMapped)
        this.likelihoodAdjustment = mapped
    }

    /**
     * @param value Proximity of the finding within which the entire hotword must reside. The total length of the window cannot
     * exceed 1000 characters. Note that the finding itself will be included in the window, so that hotwords may be
     * used to match substrings of the finding itself. For example, the certainty of a phone number regex
     * `(\d{3}) \d{3}-\d{4}` could be adjusted upwards if the area code is known to be the local area code of a company
     * office using the hotword regex `(xxx)`, where `xxx` is the area code in question.
     * Structure is documented below.
     */
    @JvmName("armniloluxhngnac")
    public suspend fun proximity(`value`: PreventionInspectTemplateInspectConfigRuleSetRuleHotwordRuleProximityArgs) {
        val toBeMapped = value
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.proximity = mapped
    }

    /**
     * @param argument Proximity of the finding within which the entire hotword must reside. The total length of the window cannot
     * exceed 1000 characters. Note that the finding itself will be included in the window, so that hotwords may be
     * used to match substrings of the finding itself. For example, the certainty of a phone number regex
     * `(\d{3}) \d{3}-\d{4}` could be adjusted upwards if the area code is known to be the local area code of a company
     * office using the hotword regex `(xxx)`, where `xxx` is the area code in question.
     * Structure is documented below.
     */
    @JvmName("letwiqwpciadotxd")
    public suspend fun proximity(argument: suspend PreventionInspectTemplateInspectConfigRuleSetRuleHotwordRuleProximityArgsBuilder.() -> Unit) {
        val toBeMapped =
            PreventionInspectTemplateInspectConfigRuleSetRuleHotwordRuleProximityArgsBuilder().applySuspend {
                argument()
            }.build()
        val mapped = of(toBeMapped)
        this.proximity = mapped
    }

    internal fun build(): PreventionInspectTemplateInspectConfigRuleSetRuleHotwordRuleArgs =
        PreventionInspectTemplateInspectConfigRuleSetRuleHotwordRuleArgs(
            hotwordRegex = hotwordRegex ?: throw PulumiNullFieldException("hotwordRegex"),
            likelihoodAdjustment = likelihoodAdjustment ?: throw
                PulumiNullFieldException("likelihoodAdjustment"),
            proximity = proximity ?: throw PulumiNullFieldException("proximity"),
        )
}