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

com.pulumi.awsnative.lex.kotlin.inputs.BotIntentArgs.kt Maven / Gradle / Ivy

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

package com.pulumi.awsnative.lex.kotlin.inputs

import com.pulumi.awsnative.lex.inputs.BotIntentArgs.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

/**
 * Represents an action that the user wants to perform.
 * @property description Description of thr intent.
 * @property dialogCodeHook Specifies that Amazon Lex invokes the alias Lambda function for each user input. You can invoke this Lambda function to personalize user interaction.
 * @property fulfillmentCodeHook Specifies that Amazon Lex invokes the alias Lambda function when the intent is ready for fulfillment. You can invoke this function to complete the bot's transaction with the user.
 * @property initialResponseSetting Configuration setting for a response sent to the user before Amazon Lex starts eliciting slots.
 * @property inputContexts A list of contexts that must be active for this intent to be considered by Amazon Lex .
 * @property intentClosingSetting Sets the response that Amazon Lex sends to the user when the intent is closed.
 * @property intentConfirmationSetting Provides prompts that Amazon Lex sends to the user to confirm the completion of an intent. If the user answers "no," the settings contain a statement that is sent to the user to end the intent.
 * @property kendraConfiguration Provides configuration information for the `AMAZON.KendraSearchIntent` intent. When you use this intent, Amazon Lex searches the specified Amazon Kendra index and returns documents from the index that match the user's utterance.
 * @property name The name of the intent.
 * @property outputContexts A list of contexts that the intent activates when it is fulfilled.
 * @property parentIntentSignature A unique identifier for the built-in intent to base this intent on.
 * @property sampleUtterances A sample utterance that invokes an intent or respond to a slot elicitation prompt.
 * @property slotPriorities Indicates the priority for slots. Amazon Lex prompts the user for slot values in priority order.
 * @property slots List of slots
 */
public data class BotIntentArgs(
    public val description: Output? = null,
    public val dialogCodeHook: Output? = null,
    public val fulfillmentCodeHook: Output? = null,
    public val initialResponseSetting: Output? = null,
    public val inputContexts: Output>? = null,
    public val intentClosingSetting: Output? = null,
    public val intentConfirmationSetting: Output? = null,
    public val kendraConfiguration: Output? = null,
    public val name: Output,
    public val outputContexts: Output>? = null,
    public val parentIntentSignature: Output? = null,
    public val sampleUtterances: Output>? = null,
    public val slotPriorities: Output>? = null,
    public val slots: Output>? = null,
) : ConvertibleToJava {
    override fun toJava(): com.pulumi.awsnative.lex.inputs.BotIntentArgs =
        com.pulumi.awsnative.lex.inputs.BotIntentArgs.builder()
            .description(description?.applyValue({ args0 -> args0 }))
            .dialogCodeHook(dialogCodeHook?.applyValue({ args0 -> args0.let({ args0 -> args0.toJava() }) }))
            .fulfillmentCodeHook(
                fulfillmentCodeHook?.applyValue({ args0 ->
                    args0.let({ args0 ->
                        args0.toJava()
                    })
                }),
            )
            .initialResponseSetting(
                initialResponseSetting?.applyValue({ args0 ->
                    args0.let({ args0 ->
                        args0.toJava()
                    })
                }),
            )
            .inputContexts(
                inputContexts?.applyValue({ args0 ->
                    args0.map({ args0 ->
                        args0.let({ args0 ->
                            args0.toJava()
                        })
                    })
                }),
            )
            .intentClosingSetting(
                intentClosingSetting?.applyValue({ args0 ->
                    args0.let({ args0 ->
                        args0.toJava()
                    })
                }),
            )
            .intentConfirmationSetting(
                intentConfirmationSetting?.applyValue({ args0 ->
                    args0.let({ args0 ->
                        args0.toJava()
                    })
                }),
            )
            .kendraConfiguration(
                kendraConfiguration?.applyValue({ args0 ->
                    args0.let({ args0 ->
                        args0.toJava()
                    })
                }),
            )
            .name(name.applyValue({ args0 -> args0 }))
            .outputContexts(
                outputContexts?.applyValue({ args0 ->
                    args0.map({ args0 ->
                        args0.let({ args0 ->
                            args0.toJava()
                        })
                    })
                }),
            )
            .parentIntentSignature(parentIntentSignature?.applyValue({ args0 -> args0 }))
            .sampleUtterances(
                sampleUtterances?.applyValue({ args0 ->
                    args0.map({ args0 ->
                        args0.let({ args0 ->
                            args0.toJava()
                        })
                    })
                }),
            )
            .slotPriorities(
                slotPriorities?.applyValue({ args0 ->
                    args0.map({ args0 ->
                        args0.let({ args0 ->
                            args0.toJava()
                        })
                    })
                }),
            )
            .slots(
                slots?.applyValue({ args0 ->
                    args0.map({ args0 ->
                        args0.let({ args0 ->
                            args0.toJava()
                        })
                    })
                }),
            ).build()
}

/**
 * Builder for [BotIntentArgs].
 */
@PulumiTagMarker
public class BotIntentArgsBuilder internal constructor() {
    private var description: Output? = null

    private var dialogCodeHook: Output? = null

    private var fulfillmentCodeHook: Output? = null

    private var initialResponseSetting: Output? = null

    private var inputContexts: Output>? = null

    private var intentClosingSetting: Output? = null

    private var intentConfirmationSetting: Output? = null

    private var kendraConfiguration: Output? = null

    private var name: Output? = null

    private var outputContexts: Output>? = null

    private var parentIntentSignature: Output? = null

    private var sampleUtterances: Output>? = null

    private var slotPriorities: Output>? = null

    private var slots: Output>? = null

    /**
     * @param value Description of thr intent.
     */
    @JvmName("cetnfhynptlinntw")
    public suspend fun description(`value`: Output) {
        this.description = value
    }

    /**
     * @param value Specifies that Amazon Lex invokes the alias Lambda function for each user input. You can invoke this Lambda function to personalize user interaction.
     */
    @JvmName("uxvloqguniwqkylm")
    public suspend fun dialogCodeHook(`value`: Output) {
        this.dialogCodeHook = value
    }

    /**
     * @param value Specifies that Amazon Lex invokes the alias Lambda function when the intent is ready for fulfillment. You can invoke this function to complete the bot's transaction with the user.
     */
    @JvmName("tibdfmidnakkpsgp")
    public suspend fun fulfillmentCodeHook(`value`: Output) {
        this.fulfillmentCodeHook = value
    }

    /**
     * @param value Configuration setting for a response sent to the user before Amazon Lex starts eliciting slots.
     */
    @JvmName("nyyxjykfastxeltg")
    public suspend fun initialResponseSetting(`value`: Output) {
        this.initialResponseSetting = value
    }

    /**
     * @param value A list of contexts that must be active for this intent to be considered by Amazon Lex .
     */
    @JvmName("goruobaaqthpwgxt")
    public suspend fun inputContexts(`value`: Output>) {
        this.inputContexts = value
    }

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

    /**
     * @param values A list of contexts that must be active for this intent to be considered by Amazon Lex .
     */
    @JvmName("cdjrvhwkfphbqgax")
    public suspend fun inputContexts(values: List>) {
        this.inputContexts = Output.all(values)
    }

    /**
     * @param value Sets the response that Amazon Lex sends to the user when the intent is closed.
     */
    @JvmName("kbpelwbobovjwxtx")
    public suspend fun intentClosingSetting(`value`: Output) {
        this.intentClosingSetting = value
    }

    /**
     * @param value Provides prompts that Amazon Lex sends to the user to confirm the completion of an intent. If the user answers "no," the settings contain a statement that is sent to the user to end the intent.
     */
    @JvmName("vkwrlcejojiurggr")
    public suspend fun intentConfirmationSetting(`value`: Output) {
        this.intentConfirmationSetting = value
    }

    /**
     * @param value Provides configuration information for the `AMAZON.KendraSearchIntent` intent. When you use this intent, Amazon Lex searches the specified Amazon Kendra index and returns documents from the index that match the user's utterance.
     */
    @JvmName("jspmiwtffkmudjua")
    public suspend fun kendraConfiguration(`value`: Output) {
        this.kendraConfiguration = value
    }

    /**
     * @param value The name of the intent.
     */
    @JvmName("gwobovvoffljochk")
    public suspend fun name(`value`: Output) {
        this.name = value
    }

    /**
     * @param value A list of contexts that the intent activates when it is fulfilled.
     */
    @JvmName("iwvmpsyfbyaosuvv")
    public suspend fun outputContexts(`value`: Output>) {
        this.outputContexts = value
    }

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

    /**
     * @param values A list of contexts that the intent activates when it is fulfilled.
     */
    @JvmName("oertxftafdebhcjr")
    public suspend fun outputContexts(values: List>) {
        this.outputContexts = Output.all(values)
    }

    /**
     * @param value A unique identifier for the built-in intent to base this intent on.
     */
    @JvmName("glnrqimmviwskfkc")
    public suspend fun parentIntentSignature(`value`: Output) {
        this.parentIntentSignature = value
    }

    /**
     * @param value A sample utterance that invokes an intent or respond to a slot elicitation prompt.
     */
    @JvmName("yoikbyqjraopvnxn")
    public suspend fun sampleUtterances(`value`: Output>) {
        this.sampleUtterances = value
    }

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

    /**
     * @param values A sample utterance that invokes an intent or respond to a slot elicitation prompt.
     */
    @JvmName("ryvxnbttgyrphsuo")
    public suspend fun sampleUtterances(values: List>) {
        this.sampleUtterances = Output.all(values)
    }

    /**
     * @param value Indicates the priority for slots. Amazon Lex prompts the user for slot values in priority order.
     */
    @JvmName("fjjpjmgavfqkbmia")
    public suspend fun slotPriorities(`value`: Output>) {
        this.slotPriorities = value
    }

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

    /**
     * @param values Indicates the priority for slots. Amazon Lex prompts the user for slot values in priority order.
     */
    @JvmName("ldgktxcakbheulhv")
    public suspend fun slotPriorities(values: List>) {
        this.slotPriorities = Output.all(values)
    }

    /**
     * @param value List of slots
     */
    @JvmName("xcgflavquheegmct")
    public suspend fun slots(`value`: Output>) {
        this.slots = value
    }

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

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

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

    /**
     * @param value Specifies that Amazon Lex invokes the alias Lambda function for each user input. You can invoke this Lambda function to personalize user interaction.
     */
    @JvmName("judqidacdfrhpnld")
    public suspend fun dialogCodeHook(`value`: BotDialogCodeHookSettingArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.dialogCodeHook = mapped
    }

    /**
     * @param argument Specifies that Amazon Lex invokes the alias Lambda function for each user input. You can invoke this Lambda function to personalize user interaction.
     */
    @JvmName("debrdwurvnqywfhc")
    public suspend fun dialogCodeHook(argument: suspend BotDialogCodeHookSettingArgsBuilder.() -> Unit) {
        val toBeMapped = BotDialogCodeHookSettingArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.dialogCodeHook = mapped
    }

    /**
     * @param value Specifies that Amazon Lex invokes the alias Lambda function when the intent is ready for fulfillment. You can invoke this function to complete the bot's transaction with the user.
     */
    @JvmName("dasvcrlryakrkohp")
    public suspend fun fulfillmentCodeHook(`value`: BotFulfillmentCodeHookSettingArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.fulfillmentCodeHook = mapped
    }

    /**
     * @param argument Specifies that Amazon Lex invokes the alias Lambda function when the intent is ready for fulfillment. You can invoke this function to complete the bot's transaction with the user.
     */
    @JvmName("yksvbyuxdgpevmah")
    public suspend fun fulfillmentCodeHook(argument: suspend BotFulfillmentCodeHookSettingArgsBuilder.() -> Unit) {
        val toBeMapped = BotFulfillmentCodeHookSettingArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.fulfillmentCodeHook = mapped
    }

    /**
     * @param value Configuration setting for a response sent to the user before Amazon Lex starts eliciting slots.
     */
    @JvmName("uyygugwggjolyssq")
    public suspend fun initialResponseSetting(`value`: BotInitialResponseSettingArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.initialResponseSetting = mapped
    }

    /**
     * @param argument Configuration setting for a response sent to the user before Amazon Lex starts eliciting slots.
     */
    @JvmName("miudmhbawcioprjs")
    public suspend fun initialResponseSetting(argument: suspend BotInitialResponseSettingArgsBuilder.() -> Unit) {
        val toBeMapped = BotInitialResponseSettingArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.initialResponseSetting = mapped
    }

    /**
     * @param value A list of contexts that must be active for this intent to be considered by Amazon Lex .
     */
    @JvmName("thkebofpdndwewid")
    public suspend fun inputContexts(`value`: List?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.inputContexts = mapped
    }

    /**
     * @param argument A list of contexts that must be active for this intent to be considered by Amazon Lex .
     */
    @JvmName("lgswnekignqwghdf")
    public suspend fun inputContexts(argument: List Unit>) {
        val toBeMapped = argument.toList().map {
            BotInputContextArgsBuilder().applySuspend {
                it()
            }.build()
        }
        val mapped = of(toBeMapped)
        this.inputContexts = mapped
    }

    /**
     * @param argument A list of contexts that must be active for this intent to be considered by Amazon Lex .
     */
    @JvmName("sisabvxcdvnryehe")
    public suspend fun inputContexts(vararg argument: suspend BotInputContextArgsBuilder.() -> Unit) {
        val toBeMapped = argument.toList().map {
            BotInputContextArgsBuilder().applySuspend {
                it()
            }.build()
        }
        val mapped = of(toBeMapped)
        this.inputContexts = mapped
    }

    /**
     * @param argument A list of contexts that must be active for this intent to be considered by Amazon Lex .
     */
    @JvmName("avftylrcryhhclll")
    public suspend fun inputContexts(argument: suspend BotInputContextArgsBuilder.() -> Unit) {
        val toBeMapped = listOf(BotInputContextArgsBuilder().applySuspend { argument() }.build())
        val mapped = of(toBeMapped)
        this.inputContexts = mapped
    }

    /**
     * @param values A list of contexts that must be active for this intent to be considered by Amazon Lex .
     */
    @JvmName("holymdkiablvpick")
    public suspend fun inputContexts(vararg values: BotInputContextArgs) {
        val toBeMapped = values.toList()
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.inputContexts = mapped
    }

    /**
     * @param value Sets the response that Amazon Lex sends to the user when the intent is closed.
     */
    @JvmName("siuturqosydwlpgj")
    public suspend fun intentClosingSetting(`value`: BotIntentClosingSettingArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.intentClosingSetting = mapped
    }

    /**
     * @param argument Sets the response that Amazon Lex sends to the user when the intent is closed.
     */
    @JvmName("dmypjayodtaoacnp")
    public suspend fun intentClosingSetting(argument: suspend BotIntentClosingSettingArgsBuilder.() -> Unit) {
        val toBeMapped = BotIntentClosingSettingArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.intentClosingSetting = mapped
    }

    /**
     * @param value Provides prompts that Amazon Lex sends to the user to confirm the completion of an intent. If the user answers "no," the settings contain a statement that is sent to the user to end the intent.
     */
    @JvmName("lkodgpkpkedykhun")
    public suspend fun intentConfirmationSetting(`value`: BotIntentConfirmationSettingArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.intentConfirmationSetting = mapped
    }

    /**
     * @param argument Provides prompts that Amazon Lex sends to the user to confirm the completion of an intent. If the user answers "no," the settings contain a statement that is sent to the user to end the intent.
     */
    @JvmName("mhtrsfxmgjmkqbli")
    public suspend fun intentConfirmationSetting(argument: suspend BotIntentConfirmationSettingArgsBuilder.() -> Unit) {
        val toBeMapped = BotIntentConfirmationSettingArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.intentConfirmationSetting = mapped
    }

    /**
     * @param value Provides configuration information for the `AMAZON.KendraSearchIntent` intent. When you use this intent, Amazon Lex searches the specified Amazon Kendra index and returns documents from the index that match the user's utterance.
     */
    @JvmName("jwefjpvmkdhigysw")
    public suspend fun kendraConfiguration(`value`: BotKendraConfigurationArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.kendraConfiguration = mapped
    }

    /**
     * @param argument Provides configuration information for the `AMAZON.KendraSearchIntent` intent. When you use this intent, Amazon Lex searches the specified Amazon Kendra index and returns documents from the index that match the user's utterance.
     */
    @JvmName("rthaviuvdvilcjdm")
    public suspend fun kendraConfiguration(argument: suspend BotKendraConfigurationArgsBuilder.() -> Unit) {
        val toBeMapped = BotKendraConfigurationArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.kendraConfiguration = mapped
    }

    /**
     * @param value The name of the intent.
     */
    @JvmName("qenrwbpndhqkirud")
    public suspend fun name(`value`: String) {
        val toBeMapped = value
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.name = mapped
    }

    /**
     * @param value A list of contexts that the intent activates when it is fulfilled.
     */
    @JvmName("famotpacfjkqqmai")
    public suspend fun outputContexts(`value`: List?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.outputContexts = mapped
    }

    /**
     * @param argument A list of contexts that the intent activates when it is fulfilled.
     */
    @JvmName("xsqwcnbrilxqhfsc")
    public suspend fun outputContexts(argument: List Unit>) {
        val toBeMapped = argument.toList().map {
            BotOutputContextArgsBuilder().applySuspend {
                it()
            }.build()
        }
        val mapped = of(toBeMapped)
        this.outputContexts = mapped
    }

    /**
     * @param argument A list of contexts that the intent activates when it is fulfilled.
     */
    @JvmName("wibhwnxctecdfojn")
    public suspend fun outputContexts(vararg argument: suspend BotOutputContextArgsBuilder.() -> Unit) {
        val toBeMapped = argument.toList().map {
            BotOutputContextArgsBuilder().applySuspend {
                it()
            }.build()
        }
        val mapped = of(toBeMapped)
        this.outputContexts = mapped
    }

    /**
     * @param argument A list of contexts that the intent activates when it is fulfilled.
     */
    @JvmName("ogyagpgndmuwxxpw")
    public suspend fun outputContexts(argument: suspend BotOutputContextArgsBuilder.() -> Unit) {
        val toBeMapped = listOf(BotOutputContextArgsBuilder().applySuspend { argument() }.build())
        val mapped = of(toBeMapped)
        this.outputContexts = mapped
    }

    /**
     * @param values A list of contexts that the intent activates when it is fulfilled.
     */
    @JvmName("uhhmtnducknohmww")
    public suspend fun outputContexts(vararg values: BotOutputContextArgs) {
        val toBeMapped = values.toList()
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.outputContexts = mapped
    }

    /**
     * @param value A unique identifier for the built-in intent to base this intent on.
     */
    @JvmName("copysbksunrmghih")
    public suspend fun parentIntentSignature(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.parentIntentSignature = mapped
    }

    /**
     * @param value A sample utterance that invokes an intent or respond to a slot elicitation prompt.
     */
    @JvmName("gijulaephjgebctd")
    public suspend fun sampleUtterances(`value`: List?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.sampleUtterances = mapped
    }

    /**
     * @param argument A sample utterance that invokes an intent or respond to a slot elicitation prompt.
     */
    @JvmName("jkmgsfdupnvhloxr")
    public suspend fun sampleUtterances(argument: List Unit>) {
        val toBeMapped = argument.toList().map {
            BotSampleUtteranceArgsBuilder().applySuspend {
                it()
            }.build()
        }
        val mapped = of(toBeMapped)
        this.sampleUtterances = mapped
    }

    /**
     * @param argument A sample utterance that invokes an intent or respond to a slot elicitation prompt.
     */
    @JvmName("sslottufjudnrjgc")
    public suspend fun sampleUtterances(vararg argument: suspend BotSampleUtteranceArgsBuilder.() -> Unit) {
        val toBeMapped = argument.toList().map {
            BotSampleUtteranceArgsBuilder().applySuspend {
                it()
            }.build()
        }
        val mapped = of(toBeMapped)
        this.sampleUtterances = mapped
    }

    /**
     * @param argument A sample utterance that invokes an intent or respond to a slot elicitation prompt.
     */
    @JvmName("yapjqytfnnskfwlk")
    public suspend fun sampleUtterances(argument: suspend BotSampleUtteranceArgsBuilder.() -> Unit) {
        val toBeMapped = listOf(BotSampleUtteranceArgsBuilder().applySuspend { argument() }.build())
        val mapped = of(toBeMapped)
        this.sampleUtterances = mapped
    }

    /**
     * @param values A sample utterance that invokes an intent or respond to a slot elicitation prompt.
     */
    @JvmName("dvryadhmuevkmpff")
    public suspend fun sampleUtterances(vararg values: BotSampleUtteranceArgs) {
        val toBeMapped = values.toList()
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.sampleUtterances = mapped
    }

    /**
     * @param value Indicates the priority for slots. Amazon Lex prompts the user for slot values in priority order.
     */
    @JvmName("fqeatkoqfwxwxfvx")
    public suspend fun slotPriorities(`value`: List?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.slotPriorities = mapped
    }

    /**
     * @param argument Indicates the priority for slots. Amazon Lex prompts the user for slot values in priority order.
     */
    @JvmName("lmgsqkxrrwbbwccu")
    public suspend fun slotPriorities(argument: List Unit>) {
        val toBeMapped = argument.toList().map {
            BotSlotPriorityArgsBuilder().applySuspend {
                it()
            }.build()
        }
        val mapped = of(toBeMapped)
        this.slotPriorities = mapped
    }

    /**
     * @param argument Indicates the priority for slots. Amazon Lex prompts the user for slot values in priority order.
     */
    @JvmName("pyomtfxcbqfgduul")
    public suspend fun slotPriorities(vararg argument: suspend BotSlotPriorityArgsBuilder.() -> Unit) {
        val toBeMapped = argument.toList().map {
            BotSlotPriorityArgsBuilder().applySuspend {
                it()
            }.build()
        }
        val mapped = of(toBeMapped)
        this.slotPriorities = mapped
    }

    /**
     * @param argument Indicates the priority for slots. Amazon Lex prompts the user for slot values in priority order.
     */
    @JvmName("holcteffpfvmxoul")
    public suspend fun slotPriorities(argument: suspend BotSlotPriorityArgsBuilder.() -> Unit) {
        val toBeMapped = listOf(BotSlotPriorityArgsBuilder().applySuspend { argument() }.build())
        val mapped = of(toBeMapped)
        this.slotPriorities = mapped
    }

    /**
     * @param values Indicates the priority for slots. Amazon Lex prompts the user for slot values in priority order.
     */
    @JvmName("nvenrgoprwlqmgoo")
    public suspend fun slotPriorities(vararg values: BotSlotPriorityArgs) {
        val toBeMapped = values.toList()
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.slotPriorities = mapped
    }

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

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

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

    /**
     * @param argument List of slots
     */
    @JvmName("skejiahkcdxgidjy")
    public suspend fun slots(argument: suspend BotSlotArgsBuilder.() -> Unit) {
        val toBeMapped = listOf(BotSlotArgsBuilder().applySuspend { argument() }.build())
        val mapped = of(toBeMapped)
        this.slots = mapped
    }

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

    internal fun build(): BotIntentArgs = BotIntentArgs(
        description = description,
        dialogCodeHook = dialogCodeHook,
        fulfillmentCodeHook = fulfillmentCodeHook,
        initialResponseSetting = initialResponseSetting,
        inputContexts = inputContexts,
        intentClosingSetting = intentClosingSetting,
        intentConfirmationSetting = intentConfirmationSetting,
        kendraConfiguration = kendraConfiguration,
        name = name ?: throw PulumiNullFieldException("name"),
        outputContexts = outputContexts,
        parentIntentSignature = parentIntentSignature,
        sampleUtterances = sampleUtterances,
        slotPriorities = slotPriorities,
        slots = slots,
    )
}




© 2015 - 2025 Weber Informatics LLC | Privacy Policy