com.pulumi.awsnative.appflow.kotlin.inputs.FlowTaskArgs.kt Maven / Gradle / Ivy

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

package com.pulumi.awsnative.appflow.kotlin.inputs

import com.pulumi.awsnative.appflow.inputs.FlowTaskArgs.builder
import com.pulumi.awsnative.appflow.kotlin.enums.FlowTaskType
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 connectorOperator Operation to be performed on provided source fields
 * @property destinationField A field value on which source field should be validated
 * @property sourceFields Source fields on which particular task will be applied
 * @property taskProperties A Map used to store task related info
 * @property taskType Type of task
 */
public data class FlowTaskArgs(
    public val connectorOperator: Output? = null,
    public val destinationField: Output? = null,
    public val sourceFields: Output>,
    public val taskProperties: Output>? = null,
    public val taskType: Output,
) : ConvertibleToJava {
    override fun toJava(): com.pulumi.awsnative.appflow.inputs.FlowTaskArgs =
        com.pulumi.awsnative.appflow.inputs.FlowTaskArgs.builder()
            .connectorOperator(connectorOperator?.applyValue({ args0 -> args0.let({ args0 -> args0.toJava() }) }))
            .destinationField(destinationField?.applyValue({ args0 -> args0 }))
            .sourceFields(sourceFields.applyValue({ args0 -> args0.map({ args0 -> args0 }) }))
            .taskProperties(
                taskProperties?.applyValue({ args0 ->
                    args0.map({ args0 ->
                        args0.let({ args0 ->
                            args0.toJava()
                        })
                    })
                }),
            )
            .taskType(taskType.applyValue({ args0 -> args0.let({ args0 -> args0.toJava() }) })).build()
}

/**
 * Builder for [FlowTaskArgs].
 */
@PulumiTagMarker
public class FlowTaskArgsBuilder internal constructor() {
    private var connectorOperator: Output? = null

    private var destinationField: Output? = null

    private var sourceFields: Output>? = null

    private var taskProperties: Output>? = null

    private var taskType: Output? = null

    /**
     * @param value Operation to be performed on provided source fields
     */
    @JvmName("atclmwkloopqlmms")
    public suspend fun connectorOperator(`value`: Output) {
        this.connectorOperator = value
    }

    /**
     * @param value A field value on which source field should be validated
     */
    @JvmName("kgqodcchlvhgsokp")
    public suspend fun destinationField(`value`: Output) {
        this.destinationField = value
    }

    /**
     * @param value Source fields on which particular task will be applied
     */
    @JvmName("cxpbetieoxehbmgl")
    public suspend fun sourceFields(`value`: Output>) {
        this.sourceFields = value
    }

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

    /**
     * @param values Source fields on which particular task will be applied
     */
    @JvmName("jcrihyimqpdxmdhg")
    public suspend fun sourceFields(values: List>) {
        this.sourceFields = Output.all(values)
    }

    /**
     * @param value A Map used to store task related info
     */
    @JvmName("yhstpluxkgwksiwt")
    public suspend fun taskProperties(`value`: Output>) {
        this.taskProperties = value
    }

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

    /**
     * @param values A Map used to store task related info
     */
    @JvmName("nlgmthjlsrgqyyke")
    public suspend fun taskProperties(values: List>) {
        this.taskProperties = Output.all(values)
    }

    /**
     * @param value Type of task
     */
    @JvmName("yvbwnysdvqxakspq")
    public suspend fun taskType(`value`: Output) {
        this.taskType = value
    }

    /**
     * @param value Operation to be performed on provided source fields
     */
    @JvmName("foahukuoklycolco")
    public suspend fun connectorOperator(`value`: FlowConnectorOperatorArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.connectorOperator = mapped
    }

    /**
     * @param argument Operation to be performed on provided source fields
     */
    @JvmName("adftgsfqtvaelhod")
    public suspend fun connectorOperator(argument: suspend FlowConnectorOperatorArgsBuilder.() -> Unit) {
        val toBeMapped = FlowConnectorOperatorArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.connectorOperator = mapped
    }

    /**
     * @param value A field value on which source field should be validated
     */
    @JvmName("lkameadbdbaukalf")
    public suspend fun destinationField(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.destinationField = mapped
    }

    /**
     * @param value Source fields on which particular task will be applied
     */
    @JvmName("txjifeuyofkttdfh")
    public suspend fun sourceFields(`value`: List) {
        val toBeMapped = value
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.sourceFields = mapped
    }

    /**
     * @param values Source fields on which particular task will be applied
     */
    @JvmName("lwvlfecvekhnvdai")
    public suspend fun sourceFields(vararg values: String) {
        val toBeMapped = values.toList()
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.sourceFields = mapped
    }

    /**
     * @param value A Map used to store task related info
     */
    @JvmName("tnnmwbqflequgypu")
    public suspend fun taskProperties(`value`: List?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.taskProperties = mapped
    }

    /**
     * @param argument A Map used to store task related info
     */
    @JvmName("ssbgocfikaqsxfjl")
    public suspend fun taskProperties(argument: List Unit>) {
        val toBeMapped = argument.toList().map {
            FlowTaskPropertiesObjectArgsBuilder().applySuspend {
                it()
            }.build()
        }
        val mapped = of(toBeMapped)
        this.taskProperties = mapped
    }

    /**
     * @param argument A Map used to store task related info
     */
    @JvmName("teoaexleuexrmsyi")
    public suspend fun taskProperties(vararg argument: suspend FlowTaskPropertiesObjectArgsBuilder.() -> Unit) {
        val toBeMapped = argument.toList().map {
            FlowTaskPropertiesObjectArgsBuilder().applySuspend {
                it()
            }.build()
        }
        val mapped = of(toBeMapped)
        this.taskProperties = mapped
    }

    /**
     * @param argument A Map used to store task related info
     */
    @JvmName("abrinpskipnajnnp")
    public suspend fun taskProperties(argument: suspend FlowTaskPropertiesObjectArgsBuilder.() -> Unit) {
        val toBeMapped = listOf(
            FlowTaskPropertiesObjectArgsBuilder().applySuspend {
                argument()
            }.build(),
        )
        val mapped = of(toBeMapped)
        this.taskProperties = mapped
    }

    /**
     * @param values A Map used to store task related info
     */
    @JvmName("ixtnkylshkjxqrlv")
    public suspend fun taskProperties(vararg values: FlowTaskPropertiesObjectArgs) {
        val toBeMapped = values.toList()
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.taskProperties = mapped
    }

    /**
     * @param value Type of task
     */
    @JvmName("pbvlsrjsjojfwuxn")
    public suspend fun taskType(`value`: FlowTaskType) {
        val toBeMapped = value
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.taskType = mapped
    }

    internal fun build(): FlowTaskArgs = FlowTaskArgs(
        connectorOperator = connectorOperator,
        destinationField = destinationField,
        sourceFields = sourceFields ?: throw PulumiNullFieldException("sourceFields"),
        taskProperties = taskProperties,
        taskType = taskType ?: throw PulumiNullFieldException("taskType"),
    )
}