com.pulumi.awsnative.accessanalyzer.kotlin.AnalyzerArgs.kt Maven / Gradle / Ivy

Go to download
@file:Suppress("NAME_SHADOWING", "DEPRECATION")

package com.pulumi.awsnative.accessanalyzer.kotlin

import com.pulumi.awsnative.accessanalyzer.AnalyzerArgs.builder
import com.pulumi.awsnative.accessanalyzer.kotlin.inputs.AnalyzerArchiveRuleArgs
import com.pulumi.awsnative.accessanalyzer.kotlin.inputs.AnalyzerArchiveRuleArgsBuilder
import com.pulumi.awsnative.accessanalyzer.kotlin.inputs.AnalyzerConfigurationPropertiesArgs
import com.pulumi.awsnative.accessanalyzer.kotlin.inputs.AnalyzerConfigurationPropertiesArgsBuilder
import com.pulumi.awsnative.kotlin.inputs.TagArgs
import com.pulumi.awsnative.kotlin.inputs.TagArgsBuilder
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.String
import kotlin.Suppress
import kotlin.Unit
import kotlin.collections.List
import kotlin.jvm.JvmName

/**
 * The AWS::AccessAnalyzer::Analyzer type specifies an analyzer of the user's account
 * ## Example Usage
 * ### Example
 * No Java example available.
 * @property analyzerConfiguration The configuration for the analyzer
 * @property analyzerName Analyzer name
 * @property archiveRules Specifies the archive rules to add for the analyzer. Archive rules automatically archive findings that meet the criteria you define for the rule.
 * @property tags An array of key-value pairs to apply to this resource.
 * @property type The type of the analyzer, must be one of ACCOUNT, ORGANIZATION, ACCOUNT_UNUSED_ACCESS or ORGANIZATION_UNUSED_ACCESS
 */
public data class AnalyzerArgs(
    public val analyzerConfiguration: Output? = null,
    public val analyzerName: Output? = null,
    public val archiveRules: Output>? = null,
    public val tags: Output>? = null,
    public val type: Output? = null,
) : ConvertibleToJava {
    override fun toJava(): com.pulumi.awsnative.accessanalyzer.AnalyzerArgs =
        com.pulumi.awsnative.accessanalyzer.AnalyzerArgs.builder()
            .analyzerConfiguration(
                analyzerConfiguration?.applyValue({ args0 ->
                    args0.let({ args0 ->
                        args0.toJava()
                    })
                }),
            )
            .analyzerName(analyzerName?.applyValue({ args0 -> args0 }))
            .archiveRules(
                archiveRules?.applyValue({ args0 ->
                    args0.map({ args0 ->
                        args0.let({ args0 ->
                            args0.toJava()
                        })
                    })
                }),
            )
            .tags(tags?.applyValue({ args0 -> args0.map({ args0 -> args0.let({ args0 -> args0.toJava() }) }) }))
            .type(type?.applyValue({ args0 -> args0 })).build()
}

/**
 * Builder for [AnalyzerArgs].
 */
@PulumiTagMarker
public class AnalyzerArgsBuilder internal constructor() {
    private var analyzerConfiguration: Output? = null

    private var analyzerName: Output? = null

    private var archiveRules: Output>? = null

    private var tags: Output>? = null

    private var type: Output? = null

    /**
     * @param value The configuration for the analyzer
     */
    @JvmName("vgoipxghgrjsygjs")
    public suspend fun analyzerConfiguration(`value`: Output) {
        this.analyzerConfiguration = value
    }

    /**
     * @param value Analyzer name
     */
    @JvmName("hyqbtdadasjvucry")
    public suspend fun analyzerName(`value`: Output) {
        this.analyzerName = value
    }

    /**
     * @param value Specifies the archive rules to add for the analyzer. Archive rules automatically archive findings that meet the criteria you define for the rule.
     */
    @JvmName("rhkctpplwtapqkon")
    public suspend fun archiveRules(`value`: Output>) {
        this.archiveRules = value
    }

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

    /**
     * @param values Specifies the archive rules to add for the analyzer. Archive rules automatically archive findings that meet the criteria you define for the rule.
     */
    @JvmName("airuexpdpbwwevyh")
    public suspend fun archiveRules(values: List>) {
        this.archiveRules = Output.all(values)
    }

    /**
     * @param value An array of key-value pairs to apply to this resource.
     */
    @JvmName("fvjkqxrnictnqire")
    public suspend fun tags(`value`: Output>) {
        this.tags = value
    }

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

    /**
     * @param values An array of key-value pairs to apply to this resource.
     */
    @JvmName("gmlqrxiuoaiwfiml")
    public suspend fun tags(values: List>) {
        this.tags = Output.all(values)
    }

    /**
     * @param value The type of the analyzer, must be one of ACCOUNT, ORGANIZATION, ACCOUNT_UNUSED_ACCESS or ORGANIZATION_UNUSED_ACCESS
     */
    @JvmName("nkftqfglyycbplrj")
    public suspend fun type(`value`: Output) {
        this.type = value
    }

    /**
     * @param value The configuration for the analyzer
     */
    @JvmName("unfklbqvwmslxllx")
    public suspend fun analyzerConfiguration(`value`: AnalyzerConfigurationPropertiesArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.analyzerConfiguration = mapped
    }

    /**
     * @param argument The configuration for the analyzer
     */
    @JvmName("owfmjlmgxgdwilgx")
    public suspend fun analyzerConfiguration(argument: suspend AnalyzerConfigurationPropertiesArgsBuilder.() -> Unit) {
        val toBeMapped = AnalyzerConfigurationPropertiesArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.analyzerConfiguration = mapped
    }

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

    /**
     * @param value Specifies the archive rules to add for the analyzer. Archive rules automatically archive findings that meet the criteria you define for the rule.
     */
    @JvmName("kejagcvqlnfswwdu")
    public suspend fun archiveRules(`value`: List?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.archiveRules = mapped
    }

    /**
     * @param argument Specifies the archive rules to add for the analyzer. Archive rules automatically archive findings that meet the criteria you define for the rule.
     */
    @JvmName("qglrqmbfoftshscg")
    public suspend fun archiveRules(argument: List Unit>) {
        val toBeMapped = argument.toList().map {
            AnalyzerArchiveRuleArgsBuilder().applySuspend {
                it()
            }.build()
        }
        val mapped = of(toBeMapped)
        this.archiveRules = mapped
    }

    /**
     * @param argument Specifies the archive rules to add for the analyzer. Archive rules automatically archive findings that meet the criteria you define for the rule.
     */
    @JvmName("hokbvdxermtlaicf")
    public suspend fun archiveRules(vararg argument: suspend AnalyzerArchiveRuleArgsBuilder.() -> Unit) {
        val toBeMapped = argument.toList().map {
            AnalyzerArchiveRuleArgsBuilder().applySuspend {
                it()
            }.build()
        }
        val mapped = of(toBeMapped)
        this.archiveRules = mapped
    }

    /**
     * @param argument Specifies the archive rules to add for the analyzer. Archive rules automatically archive findings that meet the criteria you define for the rule.
     */
    @JvmName("jpipepaewabhyisn")
    public suspend fun archiveRules(argument: suspend AnalyzerArchiveRuleArgsBuilder.() -> Unit) {
        val toBeMapped = listOf(AnalyzerArchiveRuleArgsBuilder().applySuspend { argument() }.build())
        val mapped = of(toBeMapped)
        this.archiveRules = mapped
    }

    /**
     * @param values Specifies the archive rules to add for the analyzer. Archive rules automatically archive findings that meet the criteria you define for the rule.
     */
    @JvmName("jvibhvmpokqfelvw")
    public suspend fun archiveRules(vararg values: AnalyzerArchiveRuleArgs) {
        val toBeMapped = values.toList()
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.archiveRules = mapped
    }

    /**
     * @param value An array of key-value pairs to apply to this resource.
     */
    @JvmName("koprrdluxxyvisty")
    public suspend fun tags(`value`: List?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.tags = mapped
    }

    /**
     * @param argument An array of key-value pairs to apply to this resource.
     */
    @JvmName("fbtvynxqyhxsldsf")
    public suspend fun tags(argument: List Unit>) {
        val toBeMapped = argument.toList().map { TagArgsBuilder().applySuspend { it() }.build() }
        val mapped = of(toBeMapped)
        this.tags = mapped
    }

    /**
     * @param argument An array of key-value pairs to apply to this resource.
     */
    @JvmName("motleqwahcrpupps")
    public suspend fun tags(vararg argument: suspend TagArgsBuilder.() -> Unit) {
        val toBeMapped = argument.toList().map { TagArgsBuilder().applySuspend { it() }.build() }
        val mapped = of(toBeMapped)
        this.tags = mapped
    }

    /**
     * @param argument An array of key-value pairs to apply to this resource.
     */
    @JvmName("mclqinyccnygyoei")
    public suspend fun tags(argument: suspend TagArgsBuilder.() -> Unit) {
        val toBeMapped = listOf(TagArgsBuilder().applySuspend { argument() }.build())
        val mapped = of(toBeMapped)
        this.tags = mapped
    }

    /**
     * @param values An array of key-value pairs to apply to this resource.
     */
    @JvmName("thnlqjcukewbqwpc")
    public suspend fun tags(vararg values: TagArgs) {
        val toBeMapped = values.toList()
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.tags = mapped
    }

    /**
     * @param value The type of the analyzer, must be one of ACCOUNT, ORGANIZATION, ACCOUNT_UNUSED_ACCESS or ORGANIZATION_UNUSED_ACCESS
     */
    @JvmName("obflekptsbkqkdqy")
    public suspend fun type(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.type = mapped
    }

    internal fun build(): AnalyzerArgs = AnalyzerArgs(
        analyzerConfiguration = analyzerConfiguration,
        analyzerName = analyzerName,
        archiveRules = archiveRules,
        tags = tags,
        type = type,
    )
}