com.pulumi.aws.wafv2.kotlin.inputs.RuleGroupRuleStatementRateBasedStatementScopeDownStatementArgs.kt Maven / Gradle / Ivy

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

package com.pulumi.aws.wafv2.kotlin.inputs

import com.pulumi.aws.wafv2.inputs.RuleGroupRuleStatementRateBasedStatementScopeDownStatementArgs.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.Suppress
import kotlin.Unit
import kotlin.jvm.JvmName

/**
 *
 * @property andStatement A logical rule statement used to combine other rule statements with AND logic. See AND Statement below for details.
 * @property byteMatchStatement A rule statement that defines a string match search for AWS WAF to apply to web requests. See Byte Match Statement below for details.
 * @property geoMatchStatement A rule statement used to identify web requests based on country of origin. See GEO Match Statement below for details.
 * @property ipSetReferenceStatement A rule statement used to detect web requests coming from particular IP addresses or address ranges. See IP Set Reference Statement below for details.
 * @property labelMatchStatement A rule statement that defines a string match search against labels that have been added to the web request by rules that have already run in the web ACL. See Label Match Statement below for details.
 * @property notStatement A logical rule statement used to negate the results of another rule statement. See NOT Statement below for details.
 * @property orStatement A logical rule statement used to combine other rule statements with OR logic. See OR Statement below for details.
 * @property regexMatchStatement A rule statement used to search web request components for a match against a single regular expression. See Regex Match Statement below for details.
 * @property regexPatternSetReferenceStatement A rule statement used to search web request components for matches with regular expressions. See Regex Pattern Set Reference Statement below for details.
 * @property sizeConstraintStatement A rule statement that compares a number of bytes against the size of a request component, using a comparison operator, such as greater than (>) or less than (<). See Size Constraint Statement below for more details.
 * @property sqliMatchStatement An SQL injection match condition identifies the part of web requests, such as the URI or the query string, that you want AWS WAF to inspect. See SQL Injection Match Statement below for details.
 * @property xssMatchStatement A rule statement that defines a cross-site scripting (XSS) match search for AWS WAF to apply to web requests. See XSS Match Statement below for details.
 */
public data class RuleGroupRuleStatementRateBasedStatementScopeDownStatementArgs(
    public val andStatement: Output? = null,
    public val byteMatchStatement: Output? =
        null,
    public val geoMatchStatement: Output? =
        null,
    public val ipSetReferenceStatement: Output? =
        null,
    public val labelMatchStatement: Output? =
        null,
    public val notStatement: Output? = null,
    public val orStatement: Output? = null,
    public val regexMatchStatement: Output? =
        null,
    public val regexPatternSetReferenceStatement: Output? =
        null,
    public val sizeConstraintStatement: Output? =
        null,
    public val sqliMatchStatement: Output? =
        null,
    public val xssMatchStatement: Output? =
        null,
) :
    ConvertibleToJava {
    override fun toJava(): com.pulumi.aws.wafv2.inputs.RuleGroupRuleStatementRateBasedStatementScopeDownStatementArgs =
        com.pulumi.aws.wafv2.inputs.RuleGroupRuleStatementRateBasedStatementScopeDownStatementArgs.builder()
            .andStatement(andStatement?.applyValue({ args0 -> args0.let({ args0 -> args0.toJava() }) }))
            .byteMatchStatement(
                byteMatchStatement?.applyValue({ args0 ->
                    args0.let({ args0 ->
                        args0.toJava()
                    })
                }),
            )
            .geoMatchStatement(geoMatchStatement?.applyValue({ args0 -> args0.let({ args0 -> args0.toJava() }) }))
            .ipSetReferenceStatement(
                ipSetReferenceStatement?.applyValue({ args0 ->
                    args0.let({ args0 ->
                        args0.toJava()
                    })
                }),
            )
            .labelMatchStatement(
                labelMatchStatement?.applyValue({ args0 ->
                    args0.let({ args0 ->
                        args0.toJava()
                    })
                }),
            )
            .notStatement(notStatement?.applyValue({ args0 -> args0.let({ args0 -> args0.toJava() }) }))
            .orStatement(orStatement?.applyValue({ args0 -> args0.let({ args0 -> args0.toJava() }) }))
            .regexMatchStatement(
                regexMatchStatement?.applyValue({ args0 ->
                    args0.let({ args0 ->
                        args0.toJava()
                    })
                }),
            )
            .regexPatternSetReferenceStatement(
                regexPatternSetReferenceStatement?.applyValue({ args0 ->
                    args0.let({ args0 -> args0.toJava() })
                }),
            )
            .sizeConstraintStatement(
                sizeConstraintStatement?.applyValue({ args0 ->
                    args0.let({ args0 ->
                        args0.toJava()
                    })
                }),
            )
            .sqliMatchStatement(
                sqliMatchStatement?.applyValue({ args0 ->
                    args0.let({ args0 ->
                        args0.toJava()
                    })
                }),
            )
            .xssMatchStatement(
                xssMatchStatement?.applyValue({ args0 ->
                    args0.let({ args0 ->
                        args0.toJava()
                    })
                }),
            ).build()
}

/**
 * Builder for [RuleGroupRuleStatementRateBasedStatementScopeDownStatementArgs].
 */
@PulumiTagMarker
public class RuleGroupRuleStatementRateBasedStatementScopeDownStatementArgsBuilder internal constructor() {
    private var andStatement:
        Output? = null

    private var byteMatchStatement:
        Output? =
        null

    private var geoMatchStatement:
        Output? =
        null

    private var ipSetReferenceStatement:
        Output? =
        null

    private var labelMatchStatement:
        Output? =
        null

    private var notStatement:
        Output? = null

    private var orStatement:
        Output? = null

    private var regexMatchStatement:
        Output? =
        null

    private var regexPatternSetReferenceStatement:
        Output? =
        null

    private var sizeConstraintStatement:
        Output? =
        null

    private var sqliMatchStatement:
        Output? =
        null

    private var xssMatchStatement:
        Output? =
        null

    /**
     * @param value A logical rule statement used to combine other rule statements with AND logic. See AND Statement below for details.
     */
    @JvmName("ejcopolvarkohrwh")
    public suspend fun andStatement(`value`: Output) {
        this.andStatement = value
    }

    /**
     * @param value A rule statement that defines a string match search for AWS WAF to apply to web requests. See Byte Match Statement below for details.
     */
    @JvmName("gxcubjxcdiecnege")
    public suspend fun byteMatchStatement(`value`: Output) {
        this.byteMatchStatement = value
    }

    /**
     * @param value A rule statement used to identify web requests based on country of origin. See GEO Match Statement below for details.
     */
    @JvmName("fyjvhroeesgotavj")
    public suspend fun geoMatchStatement(`value`: Output) {
        this.geoMatchStatement = value
    }

    /**
     * @param value A rule statement used to detect web requests coming from particular IP addresses or address ranges. See IP Set Reference Statement below for details.
     */
    @JvmName("goeklhvtjmynpjcj")
    public suspend fun ipSetReferenceStatement(`value`: Output) {
        this.ipSetReferenceStatement = value
    }

    /**
     * @param value A rule statement that defines a string match search against labels that have been added to the web request by rules that have already run in the web ACL. See Label Match Statement below for details.
     */
    @JvmName("cvaxoxbioktysokd")
    public suspend fun labelMatchStatement(`value`: Output) {
        this.labelMatchStatement = value
    }

    /**
     * @param value A logical rule statement used to negate the results of another rule statement. See NOT Statement below for details.
     */
    @JvmName("yfhnofnigicpoovp")
    public suspend fun notStatement(`value`: Output) {
        this.notStatement = value
    }

    /**
     * @param value A logical rule statement used to combine other rule statements with OR logic. See OR Statement below for details.
     */
    @JvmName("nppsaxyyvmhcquke")
    public suspend fun orStatement(`value`: Output) {
        this.orStatement = value
    }

    /**
     * @param value A rule statement used to search web request components for a match against a single regular expression. See Regex Match Statement below for details.
     */
    @JvmName("qhfimdcidemmllei")
    public suspend fun regexMatchStatement(`value`: Output) {
        this.regexMatchStatement = value
    }

    /**
     * @param value A rule statement used to search web request components for matches with regular expressions. See Regex Pattern Set Reference Statement below for details.
     */
    @JvmName("vwpssjpstuyyancg")
    public suspend fun regexPatternSetReferenceStatement(`value`: Output) {
        this.regexPatternSetReferenceStatement = value
    }

    /**
     * @param value A rule statement that compares a number of bytes against the size of a request component, using a comparison operator, such as greater than (>) or less than (<). See Size Constraint Statement below for more details.
     */
    @JvmName("rtmcwxqmsnucoacp")
    public suspend fun sizeConstraintStatement(`value`: Output) {
        this.sizeConstraintStatement = value
    }

    /**
     * @param value An SQL injection match condition identifies the part of web requests, such as the URI or the query string, that you want AWS WAF to inspect. See SQL Injection Match Statement below for details.
     */
    @JvmName("skgiqnysuybgdrkr")
    public suspend fun sqliMatchStatement(`value`: Output) {
        this.sqliMatchStatement = value
    }

    /**
     * @param value A rule statement that defines a cross-site scripting (XSS) match search for AWS WAF to apply to web requests. See XSS Match Statement below for details.
     */
    @JvmName("xjpldlrpsttmcgpy")
    public suspend fun xssMatchStatement(`value`: Output) {
        this.xssMatchStatement = value
    }

    /**
     * @param value A logical rule statement used to combine other rule statements with AND logic. See AND Statement below for details.
     */
    @JvmName("aseymuwyvinjruoq")
    public suspend fun andStatement(`value`: RuleGroupRuleStatementRateBasedStatementScopeDownStatementAndStatementArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.andStatement = mapped
    }

    /**
     * @param argument A logical rule statement used to combine other rule statements with AND logic. See AND Statement below for details.
     */
    @JvmName("rwknntbipyppdesd")
    public suspend fun andStatement(argument: suspend RuleGroupRuleStatementRateBasedStatementScopeDownStatementAndStatementArgsBuilder.() -> Unit) {
        val toBeMapped =
            RuleGroupRuleStatementRateBasedStatementScopeDownStatementAndStatementArgsBuilder().applySuspend {
                argument()
            }.build()
        val mapped = of(toBeMapped)
        this.andStatement = mapped
    }

    /**
     * @param value A rule statement that defines a string match search for AWS WAF to apply to web requests. See Byte Match Statement below for details.
     */
    @JvmName("saelynhttaqwycoe")
    public suspend fun byteMatchStatement(`value`: RuleGroupRuleStatementRateBasedStatementScopeDownStatementByteMatchStatementArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.byteMatchStatement = mapped
    }

    /**
     * @param argument A rule statement that defines a string match search for AWS WAF to apply to web requests. See Byte Match Statement below for details.
     */
    @JvmName("ycycfcixwodrweco")
    public suspend fun byteMatchStatement(argument: suspend RuleGroupRuleStatementRateBasedStatementScopeDownStatementByteMatchStatementArgsBuilder.() -> Unit) {
        val toBeMapped =
            RuleGroupRuleStatementRateBasedStatementScopeDownStatementByteMatchStatementArgsBuilder().applySuspend {
                argument()
            }.build()
        val mapped = of(toBeMapped)
        this.byteMatchStatement = mapped
    }

    /**
     * @param value A rule statement used to identify web requests based on country of origin. See GEO Match Statement below for details.
     */
    @JvmName("dpcoygqfmjpyknxl")
    public suspend fun geoMatchStatement(`value`: RuleGroupRuleStatementRateBasedStatementScopeDownStatementGeoMatchStatementArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.geoMatchStatement = mapped
    }

    /**
     * @param argument A rule statement used to identify web requests based on country of origin. See GEO Match Statement below for details.
     */
    @JvmName("qaltskqfbsmupeph")
    public suspend fun geoMatchStatement(argument: suspend RuleGroupRuleStatementRateBasedStatementScopeDownStatementGeoMatchStatementArgsBuilder.() -> Unit) {
        val toBeMapped =
            RuleGroupRuleStatementRateBasedStatementScopeDownStatementGeoMatchStatementArgsBuilder().applySuspend {
                argument()
            }.build()
        val mapped = of(toBeMapped)
        this.geoMatchStatement = mapped
    }

    /**
     * @param value A rule statement used to detect web requests coming from particular IP addresses or address ranges. See IP Set Reference Statement below for details.
     */
    @JvmName("swtxxjhaivotyohu")
    public suspend fun ipSetReferenceStatement(`value`: RuleGroupRuleStatementRateBasedStatementScopeDownStatementIpSetReferenceStatementArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.ipSetReferenceStatement = mapped
    }

    /**
     * @param argument A rule statement used to detect web requests coming from particular IP addresses or address ranges. See IP Set Reference Statement below for details.
     */
    @JvmName("hellvuyqriddqwgp")
    public suspend fun ipSetReferenceStatement(argument: suspend RuleGroupRuleStatementRateBasedStatementScopeDownStatementIpSetReferenceStatementArgsBuilder.() -> Unit) {
        val toBeMapped =
            RuleGroupRuleStatementRateBasedStatementScopeDownStatementIpSetReferenceStatementArgsBuilder().applySuspend {
                argument()
            }.build()
        val mapped = of(toBeMapped)
        this.ipSetReferenceStatement = mapped
    }

    /**
     * @param value A rule statement that defines a string match search against labels that have been added to the web request by rules that have already run in the web ACL. See Label Match Statement below for details.
     */
    @JvmName("weeeiumkohxxearx")
    public suspend fun labelMatchStatement(`value`: RuleGroupRuleStatementRateBasedStatementScopeDownStatementLabelMatchStatementArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.labelMatchStatement = mapped
    }

    /**
     * @param argument A rule statement that defines a string match search against labels that have been added to the web request by rules that have already run in the web ACL. See Label Match Statement below for details.
     */
    @JvmName("xeqcbjpqqpiqxiqd")
    public suspend fun labelMatchStatement(argument: suspend RuleGroupRuleStatementRateBasedStatementScopeDownStatementLabelMatchStatementArgsBuilder.() -> Unit) {
        val toBeMapped =
            RuleGroupRuleStatementRateBasedStatementScopeDownStatementLabelMatchStatementArgsBuilder().applySuspend {
                argument()
            }.build()
        val mapped = of(toBeMapped)
        this.labelMatchStatement = mapped
    }

    /**
     * @param value A logical rule statement used to negate the results of another rule statement. See NOT Statement below for details.
     */
    @JvmName("ykconesaafdbixib")
    public suspend fun notStatement(`value`: RuleGroupRuleStatementRateBasedStatementScopeDownStatementNotStatementArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.notStatement = mapped
    }

    /**
     * @param argument A logical rule statement used to negate the results of another rule statement. See NOT Statement below for details.
     */
    @JvmName("uuitgjiiufsevltd")
    public suspend fun notStatement(argument: suspend RuleGroupRuleStatementRateBasedStatementScopeDownStatementNotStatementArgsBuilder.() -> Unit) {
        val toBeMapped =
            RuleGroupRuleStatementRateBasedStatementScopeDownStatementNotStatementArgsBuilder().applySuspend {
                argument()
            }.build()
        val mapped = of(toBeMapped)
        this.notStatement = mapped
    }

    /**
     * @param value A logical rule statement used to combine other rule statements with OR logic. See OR Statement below for details.
     */
    @JvmName("vryvhhfkvunqtiru")
    public suspend fun orStatement(`value`: RuleGroupRuleStatementRateBasedStatementScopeDownStatementOrStatementArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.orStatement = mapped
    }

    /**
     * @param argument A logical rule statement used to combine other rule statements with OR logic. See OR Statement below for details.
     */
    @JvmName("rbmigtdlmhmjpyko")
    public suspend fun orStatement(argument: suspend RuleGroupRuleStatementRateBasedStatementScopeDownStatementOrStatementArgsBuilder.() -> Unit) {
        val toBeMapped =
            RuleGroupRuleStatementRateBasedStatementScopeDownStatementOrStatementArgsBuilder().applySuspend {
                argument()
            }.build()
        val mapped = of(toBeMapped)
        this.orStatement = mapped
    }

    /**
     * @param value A rule statement used to search web request components for a match against a single regular expression. See Regex Match Statement below for details.
     */
    @JvmName("frhxycgywfaepjus")
    public suspend fun regexMatchStatement(`value`: RuleGroupRuleStatementRateBasedStatementScopeDownStatementRegexMatchStatementArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.regexMatchStatement = mapped
    }

    /**
     * @param argument A rule statement used to search web request components for a match against a single regular expression. See Regex Match Statement below for details.
     */
    @JvmName("pdlpsiybgmgovpby")
    public suspend fun regexMatchStatement(argument: suspend RuleGroupRuleStatementRateBasedStatementScopeDownStatementRegexMatchStatementArgsBuilder.() -> Unit) {
        val toBeMapped =
            RuleGroupRuleStatementRateBasedStatementScopeDownStatementRegexMatchStatementArgsBuilder().applySuspend {
                argument()
            }.build()
        val mapped = of(toBeMapped)
        this.regexMatchStatement = mapped
    }

    /**
     * @param value A rule statement used to search web request components for matches with regular expressions. See Regex Pattern Set Reference Statement below for details.
     */
    @JvmName("ckljvkdihfcgnwae")
    public suspend fun regexPatternSetReferenceStatement(`value`: RuleGroupRuleStatementRateBasedStatementScopeDownStatementRegexPatternSetReferenceStatementArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.regexPatternSetReferenceStatement = mapped
    }

    /**
     * @param argument A rule statement used to search web request components for matches with regular expressions. See Regex Pattern Set Reference Statement below for details.
     */
    @JvmName("pvpoxfmxxyrmelbt")
    public suspend fun regexPatternSetReferenceStatement(argument: suspend RuleGroupRuleStatementRateBasedStatementScopeDownStatementRegexPatternSetReferenceStatementArgsBuilder.() -> Unit) {
        val toBeMapped =
            RuleGroupRuleStatementRateBasedStatementScopeDownStatementRegexPatternSetReferenceStatementArgsBuilder().applySuspend {
                argument()
            }.build()
        val mapped = of(toBeMapped)
        this.regexPatternSetReferenceStatement = mapped
    }

    /**
     * @param value A rule statement that compares a number of bytes against the size of a request component, using a comparison operator, such as greater than (>) or less than (<). See Size Constraint Statement below for more details.
     */
    @JvmName("hlpxcsckofmbwwep")
    public suspend fun sizeConstraintStatement(`value`: RuleGroupRuleStatementRateBasedStatementScopeDownStatementSizeConstraintStatementArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.sizeConstraintStatement = mapped
    }

    /**
     * @param argument A rule statement that compares a number of bytes against the size of a request component, using a comparison operator, such as greater than (>) or less than (<). See Size Constraint Statement below for more details.
     */
    @JvmName("pwkepluylnywxjmo")
    public suspend fun sizeConstraintStatement(argument: suspend RuleGroupRuleStatementRateBasedStatementScopeDownStatementSizeConstraintStatementArgsBuilder.() -> Unit) {
        val toBeMapped =
            RuleGroupRuleStatementRateBasedStatementScopeDownStatementSizeConstraintStatementArgsBuilder().applySuspend {
                argument()
            }.build()
        val mapped = of(toBeMapped)
        this.sizeConstraintStatement = mapped
    }

    /**
     * @param value An SQL injection match condition identifies the part of web requests, such as the URI or the query string, that you want AWS WAF to inspect. See SQL Injection Match Statement below for details.
     */
    @JvmName("epprywdlysgbdsvg")
    public suspend fun sqliMatchStatement(`value`: RuleGroupRuleStatementRateBasedStatementScopeDownStatementSqliMatchStatementArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.sqliMatchStatement = mapped
    }

    /**
     * @param argument An SQL injection match condition identifies the part of web requests, such as the URI or the query string, that you want AWS WAF to inspect. See SQL Injection Match Statement below for details.
     */
    @JvmName("cygxtallbjuopidl")
    public suspend fun sqliMatchStatement(argument: suspend RuleGroupRuleStatementRateBasedStatementScopeDownStatementSqliMatchStatementArgsBuilder.() -> Unit) {
        val toBeMapped =
            RuleGroupRuleStatementRateBasedStatementScopeDownStatementSqliMatchStatementArgsBuilder().applySuspend {
                argument()
            }.build()
        val mapped = of(toBeMapped)
        this.sqliMatchStatement = mapped
    }

    /**
     * @param value A rule statement that defines a cross-site scripting (XSS) match search for AWS WAF to apply to web requests. See XSS Match Statement below for details.
     */
    @JvmName("ycweqqbgfovblrem")
    public suspend fun xssMatchStatement(`value`: RuleGroupRuleStatementRateBasedStatementScopeDownStatementXssMatchStatementArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.xssMatchStatement = mapped
    }

    /**
     * @param argument A rule statement that defines a cross-site scripting (XSS) match search for AWS WAF to apply to web requests. See XSS Match Statement below for details.
     */
    @JvmName("auusrruyjyspchmf")
    public suspend fun xssMatchStatement(argument: suspend RuleGroupRuleStatementRateBasedStatementScopeDownStatementXssMatchStatementArgsBuilder.() -> Unit) {
        val toBeMapped =
            RuleGroupRuleStatementRateBasedStatementScopeDownStatementXssMatchStatementArgsBuilder().applySuspend {
                argument()
            }.build()
        val mapped = of(toBeMapped)
        this.xssMatchStatement = mapped
    }

    internal fun build(): RuleGroupRuleStatementRateBasedStatementScopeDownStatementArgs =
        RuleGroupRuleStatementRateBasedStatementScopeDownStatementArgs(
            andStatement = andStatement,
            byteMatchStatement = byteMatchStatement,
            geoMatchStatement = geoMatchStatement,
            ipSetReferenceStatement = ipSetReferenceStatement,
            labelMatchStatement = labelMatchStatement,
            notStatement = notStatement,
            orStatement = orStatement,
            regexMatchStatement = regexMatchStatement,
            regexPatternSetReferenceStatement = regexPatternSetReferenceStatement,
            sizeConstraintStatement = sizeConstraintStatement,
            sqliMatchStatement = sqliMatchStatement,
            xssMatchStatement = xssMatchStatement,
        )
}