All Downloads are FREE. Search and download functionalities are using the official Maven repository.

com.pulumi.awsnative.wafv2.kotlin.inputs.WebAclManagedRuleGroupStatementArgs.kt Maven / Gradle / Ivy

@file:Suppress("NAME_SHADOWING", "DEPRECATION")

package com.pulumi.awsnative.wafv2.kotlin.inputs

import com.pulumi.awsnative.wafv2.inputs.WebAclManagedRuleGroupStatementArgs.builder
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.String
import kotlin.Suppress
import kotlin.Unit
import kotlin.collections.List
import kotlin.jvm.JvmName

/**
 *
 * @property excludedRules Rules in the referenced rule group whose actions are set to `Count` .
 * > Instead of this option, use `RuleActionOverrides` . It accepts any valid action setting, including `Count` .
 * @property managedRuleGroupConfigs Collection of ManagedRuleGroupConfig.
 * @property name The name of the managed rule group. You use this, along with the vendor name, to identify the rule group.
 * @property ruleActionOverrides Action overrides for rules in the rule group.
 * @property scopeDownStatement An optional nested statement that narrows the scope of the web requests that are evaluated by the managed rule group. Requests are only evaluated by the rule group if they match the scope-down statement. You can use any nestable `Statement` in the scope-down statement, and you can nest statements at any level, the same as you can for a rule statement.
 * @property vendorName The name of the managed rule group vendor. You use this, along with the rule group name, to identify a rule group.
 * @property version The version of the managed rule group to use. If you specify this, the version setting is fixed until you change it. If you don't specify this, AWS WAF uses the vendor's default version, and then keeps the version at the vendor's default when the vendor updates the managed rule group settings.
 */
public data class WebAclManagedRuleGroupStatementArgs(
    public val excludedRules: Output>? = null,
    public val managedRuleGroupConfigs: Output>? = null,
    public val name: Output,
    public val ruleActionOverrides: Output>? = null,
    public val scopeDownStatement: Output? = null,
    public val vendorName: Output,
    public val version: Output? = null,
) : ConvertibleToJava {
    override fun toJava(): com.pulumi.awsnative.wafv2.inputs.WebAclManagedRuleGroupStatementArgs =
        com.pulumi.awsnative.wafv2.inputs.WebAclManagedRuleGroupStatementArgs.builder()
            .excludedRules(
                excludedRules?.applyValue({ args0 ->
                    args0.map({ args0 ->
                        args0.let({ args0 ->
                            args0.toJava()
                        })
                    })
                }),
            )
            .managedRuleGroupConfigs(
                managedRuleGroupConfigs?.applyValue({ args0 ->
                    args0.map({ args0 ->
                        args0.let({ args0 -> args0.toJava() })
                    })
                }),
            )
            .name(name.applyValue({ args0 -> args0 }))
            .ruleActionOverrides(
                ruleActionOverrides?.applyValue({ args0 ->
                    args0.map({ args0 ->
                        args0.let({ args0 -> args0.toJava() })
                    })
                }),
            )
            .scopeDownStatement(
                scopeDownStatement?.applyValue({ args0 ->
                    args0.let({ args0 ->
                        args0.toJava()
                    })
                }),
            )
            .vendorName(vendorName.applyValue({ args0 -> args0 }))
            .version(version?.applyValue({ args0 -> args0 })).build()
}

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

    private var managedRuleGroupConfigs: Output>? = null

    private var name: Output? = null

    private var ruleActionOverrides: Output>? = null

    private var scopeDownStatement: Output? = null

    private var vendorName: Output? = null

    private var version: Output? = null

    /**
     * @param value Rules in the referenced rule group whose actions are set to `Count` .
     * > Instead of this option, use `RuleActionOverrides` . It accepts any valid action setting, including `Count` .
     */
    @JvmName("mutnwmgnjbtupmfp")
    public suspend fun excludedRules(`value`: Output>) {
        this.excludedRules = value
    }

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

    /**
     * @param values Rules in the referenced rule group whose actions are set to `Count` .
     * > Instead of this option, use `RuleActionOverrides` . It accepts any valid action setting, including `Count` .
     */
    @JvmName("ypomogqjbmgtxdbt")
    public suspend fun excludedRules(values: List>) {
        this.excludedRules = Output.all(values)
    }

    /**
     * @param value Collection of ManagedRuleGroupConfig.
     */
    @JvmName("ymchaaynkfsbrxib")
    public suspend fun managedRuleGroupConfigs(`value`: Output>) {
        this.managedRuleGroupConfigs = value
    }

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

    /**
     * @param values Collection of ManagedRuleGroupConfig.
     */
    @JvmName("exsdqvjttddbswui")
    public suspend fun managedRuleGroupConfigs(values: List>) {
        this.managedRuleGroupConfigs = Output.all(values)
    }

    /**
     * @param value The name of the managed rule group. You use this, along with the vendor name, to identify the rule group.
     */
    @JvmName("raoiqvvcfwgiplhm")
    public suspend fun name(`value`: Output) {
        this.name = value
    }

    /**
     * @param value Action overrides for rules in the rule group.
     */
    @JvmName("icgmwuicgeiflrau")
    public suspend fun ruleActionOverrides(`value`: Output>) {
        this.ruleActionOverrides = value
    }

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

    /**
     * @param values Action overrides for rules in the rule group.
     */
    @JvmName("emhypohcngytugej")
    public suspend fun ruleActionOverrides(values: List>) {
        this.ruleActionOverrides = Output.all(values)
    }

    /**
     * @param value An optional nested statement that narrows the scope of the web requests that are evaluated by the managed rule group. Requests are only evaluated by the rule group if they match the scope-down statement. You can use any nestable `Statement` in the scope-down statement, and you can nest statements at any level, the same as you can for a rule statement.
     */
    @JvmName("smnoyodcovtgbcwm")
    public suspend fun scopeDownStatement(`value`: Output) {
        this.scopeDownStatement = value
    }

    /**
     * @param value The name of the managed rule group vendor. You use this, along with the rule group name, to identify a rule group.
     */
    @JvmName("ipdqksvoofmsqeba")
    public suspend fun vendorName(`value`: Output) {
        this.vendorName = value
    }

    /**
     * @param value The version of the managed rule group to use. If you specify this, the version setting is fixed until you change it. If you don't specify this, AWS WAF uses the vendor's default version, and then keeps the version at the vendor's default when the vendor updates the managed rule group settings.
     */
    @JvmName("mfmwunlqapfamlsw")
    public suspend fun version(`value`: Output) {
        this.version = value
    }

    /**
     * @param value Rules in the referenced rule group whose actions are set to `Count` .
     * > Instead of this option, use `RuleActionOverrides` . It accepts any valid action setting, including `Count` .
     */
    @JvmName("ulwuhnylpcbkxilj")
    public suspend fun excludedRules(`value`: List?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.excludedRules = mapped
    }

    /**
     * @param argument Rules in the referenced rule group whose actions are set to `Count` .
     * > Instead of this option, use `RuleActionOverrides` . It accepts any valid action setting, including `Count` .
     */
    @JvmName("knexejfkxtysecag")
    public suspend fun excludedRules(argument: List Unit>) {
        val toBeMapped = argument.toList().map {
            WebAclExcludedRuleArgsBuilder().applySuspend {
                it()
            }.build()
        }
        val mapped = of(toBeMapped)
        this.excludedRules = mapped
    }

    /**
     * @param argument Rules in the referenced rule group whose actions are set to `Count` .
     * > Instead of this option, use `RuleActionOverrides` . It accepts any valid action setting, including `Count` .
     */
    @JvmName("aqrpcullipxnhmlg")
    public suspend fun excludedRules(vararg argument: suspend WebAclExcludedRuleArgsBuilder.() -> Unit) {
        val toBeMapped = argument.toList().map {
            WebAclExcludedRuleArgsBuilder().applySuspend {
                it()
            }.build()
        }
        val mapped = of(toBeMapped)
        this.excludedRules = mapped
    }

    /**
     * @param argument Rules in the referenced rule group whose actions are set to `Count` .
     * > Instead of this option, use `RuleActionOverrides` . It accepts any valid action setting, including `Count` .
     */
    @JvmName("apkupxrbfjwwnpsp")
    public suspend fun excludedRules(argument: suspend WebAclExcludedRuleArgsBuilder.() -> Unit) {
        val toBeMapped = listOf(WebAclExcludedRuleArgsBuilder().applySuspend { argument() }.build())
        val mapped = of(toBeMapped)
        this.excludedRules = mapped
    }

    /**
     * @param values Rules in the referenced rule group whose actions are set to `Count` .
     * > Instead of this option, use `RuleActionOverrides` . It accepts any valid action setting, including `Count` .
     */
    @JvmName("bxwtpvdpxhapkshc")
    public suspend fun excludedRules(vararg values: WebAclExcludedRuleArgs) {
        val toBeMapped = values.toList()
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.excludedRules = mapped
    }

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

    /**
     * @param argument Collection of ManagedRuleGroupConfig.
     */
    @JvmName("vtlrhetlabhbkkex")
    public suspend fun managedRuleGroupConfigs(argument: List Unit>) {
        val toBeMapped = argument.toList().map {
            WebAclManagedRuleGroupConfigArgsBuilder().applySuspend {
                it()
            }.build()
        }
        val mapped = of(toBeMapped)
        this.managedRuleGroupConfigs = mapped
    }

    /**
     * @param argument Collection of ManagedRuleGroupConfig.
     */
    @JvmName("kifavmtqirqdmbrx")
    public suspend fun managedRuleGroupConfigs(vararg argument: suspend WebAclManagedRuleGroupConfigArgsBuilder.() -> Unit) {
        val toBeMapped = argument.toList().map {
            WebAclManagedRuleGroupConfigArgsBuilder().applySuspend {
                it()
            }.build()
        }
        val mapped = of(toBeMapped)
        this.managedRuleGroupConfigs = mapped
    }

    /**
     * @param argument Collection of ManagedRuleGroupConfig.
     */
    @JvmName("nhmxkmokdpvrouoy")
    public suspend fun managedRuleGroupConfigs(argument: suspend WebAclManagedRuleGroupConfigArgsBuilder.() -> Unit) {
        val toBeMapped = listOf(
            WebAclManagedRuleGroupConfigArgsBuilder().applySuspend {
                argument()
            }.build(),
        )
        val mapped = of(toBeMapped)
        this.managedRuleGroupConfigs = mapped
    }

    /**
     * @param values Collection of ManagedRuleGroupConfig.
     */
    @JvmName("amviqtdukstkgvbi")
    public suspend fun managedRuleGroupConfigs(vararg values: WebAclManagedRuleGroupConfigArgs) {
        val toBeMapped = values.toList()
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.managedRuleGroupConfigs = mapped
    }

    /**
     * @param value The name of the managed rule group. You use this, along with the vendor name, to identify the rule group.
     */
    @JvmName("pilrlrxunsaqfwla")
    public suspend fun name(`value`: String) {
        val toBeMapped = value
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.name = mapped
    }

    /**
     * @param value Action overrides for rules in the rule group.
     */
    @JvmName("ikbnufykxdeswrre")
    public suspend fun ruleActionOverrides(`value`: List?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.ruleActionOverrides = mapped
    }

    /**
     * @param argument Action overrides for rules in the rule group.
     */
    @JvmName("cpeakpkicuxnhneb")
    public suspend fun ruleActionOverrides(argument: List Unit>) {
        val toBeMapped = argument.toList().map {
            WebAclRuleActionOverrideArgsBuilder().applySuspend {
                it()
            }.build()
        }
        val mapped = of(toBeMapped)
        this.ruleActionOverrides = mapped
    }

    /**
     * @param argument Action overrides for rules in the rule group.
     */
    @JvmName("eykimdicqddgsupy")
    public suspend fun ruleActionOverrides(vararg argument: suspend WebAclRuleActionOverrideArgsBuilder.() -> Unit) {
        val toBeMapped = argument.toList().map {
            WebAclRuleActionOverrideArgsBuilder().applySuspend {
                it()
            }.build()
        }
        val mapped = of(toBeMapped)
        this.ruleActionOverrides = mapped
    }

    /**
     * @param argument Action overrides for rules in the rule group.
     */
    @JvmName("tsmylmbsrvpbhbfk")
    public suspend fun ruleActionOverrides(argument: suspend WebAclRuleActionOverrideArgsBuilder.() -> Unit) {
        val toBeMapped = listOf(
            WebAclRuleActionOverrideArgsBuilder().applySuspend {
                argument()
            }.build(),
        )
        val mapped = of(toBeMapped)
        this.ruleActionOverrides = mapped
    }

    /**
     * @param values Action overrides for rules in the rule group.
     */
    @JvmName("xfcowgsimcspxvgt")
    public suspend fun ruleActionOverrides(vararg values: WebAclRuleActionOverrideArgs) {
        val toBeMapped = values.toList()
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.ruleActionOverrides = mapped
    }

    /**
     * @param value An optional nested statement that narrows the scope of the web requests that are evaluated by the managed rule group. Requests are only evaluated by the rule group if they match the scope-down statement. You can use any nestable `Statement` in the scope-down statement, and you can nest statements at any level, the same as you can for a rule statement.
     */
    @JvmName("sjncaopbouomcwgb")
    public suspend fun scopeDownStatement(`value`: WebAclStatementArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.scopeDownStatement = mapped
    }

    /**
     * @param argument An optional nested statement that narrows the scope of the web requests that are evaluated by the managed rule group. Requests are only evaluated by the rule group if they match the scope-down statement. You can use any nestable `Statement` in the scope-down statement, and you can nest statements at any level, the same as you can for a rule statement.
     */
    @JvmName("xaifnoubfqfpphjs")
    public suspend fun scopeDownStatement(argument: suspend WebAclStatementArgsBuilder.() -> Unit) {
        val toBeMapped = WebAclStatementArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.scopeDownStatement = mapped
    }

    /**
     * @param value The name of the managed rule group vendor. You use this, along with the rule group name, to identify a rule group.
     */
    @JvmName("ndbwhcqgjehhhgbg")
    public suspend fun vendorName(`value`: String) {
        val toBeMapped = value
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.vendorName = mapped
    }

    /**
     * @param value The version of the managed rule group to use. If you specify this, the version setting is fixed until you change it. If you don't specify this, AWS WAF uses the vendor's default version, and then keeps the version at the vendor's default when the vendor updates the managed rule group settings.
     */
    @JvmName("ueccaemwydfnulor")
    public suspend fun version(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.version = mapped
    }

    internal fun build(): WebAclManagedRuleGroupStatementArgs = WebAclManagedRuleGroupStatementArgs(
        excludedRules = excludedRules,
        managedRuleGroupConfigs = managedRuleGroupConfigs,
        name = name ?: throw PulumiNullFieldException("name"),
        ruleActionOverrides = ruleActionOverrides,
        scopeDownStatement = scopeDownStatement,
        vendorName = vendorName ?: throw PulumiNullFieldException("vendorName"),
        version = version,
    )
}




© 2015 - 2025 Weber Informatics LLC | Privacy Policy