com.pulumi.azurenative.datamigration.kotlin.inputs.ConnectToTargetSqlMITaskInputArgs.kt Maven / Gradle / Ivy

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

package com.pulumi.azurenative.datamigration.kotlin.inputs

import com.pulumi.azurenative.datamigration.inputs.ConnectToTargetSqlMITaskInputArgs.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.Boolean
import kotlin.Suppress
import kotlin.Unit
import kotlin.jvm.JvmName

/**
 * Input for the task that validates connection to Azure SQL Database Managed Instance.
 * @property collectAgentJobs Flag for whether to collect agent jobs from target SQL MI server.
 * @property collectLogins Flag for whether to collect logins from target SQL MI server.
 * @property targetConnectionInfo Connection information for target SQL Server
 * @property validateSsisCatalogOnly Flag for whether to validate SSIS catalog is reachable on the target SQL MI server.
 */
public data class ConnectToTargetSqlMITaskInputArgs(
    public val collectAgentJobs: Output? = null,
    public val collectLogins: Output? = null,
    public val targetConnectionInfo: Output,
    public val validateSsisCatalogOnly: Output? = null,
) : ConvertibleToJava {
    override fun toJava(): com.pulumi.azurenative.datamigration.inputs.ConnectToTargetSqlMITaskInputArgs =
        com.pulumi.azurenative.datamigration.inputs.ConnectToTargetSqlMITaskInputArgs.builder()
            .collectAgentJobs(collectAgentJobs?.applyValue({ args0 -> args0 }))
            .collectLogins(collectLogins?.applyValue({ args0 -> args0 }))
            .targetConnectionInfo(
                targetConnectionInfo.applyValue({ args0 ->
                    args0.let({ args0 ->
                        args0.toJava()
                    })
                }),
            )
            .validateSsisCatalogOnly(validateSsisCatalogOnly?.applyValue({ args0 -> args0 })).build()
}

/**
 * Builder for [ConnectToTargetSqlMITaskInputArgs].
 */
@PulumiTagMarker
public class ConnectToTargetSqlMITaskInputArgsBuilder internal constructor() {
    private var collectAgentJobs: Output? = null

    private var collectLogins: Output? = null

    private var targetConnectionInfo: Output? = null

    private var validateSsisCatalogOnly: Output? = null

    /**
     * @param value Flag for whether to collect agent jobs from target SQL MI server.
     */
    @JvmName("rogppylvnnkfsqry")
    public suspend fun collectAgentJobs(`value`: Output) {
        this.collectAgentJobs = value
    }

    /**
     * @param value Flag for whether to collect logins from target SQL MI server.
     */
    @JvmName("oejidmkgtpqvbgbt")
    public suspend fun collectLogins(`value`: Output) {
        this.collectLogins = value
    }

    /**
     * @param value Connection information for target SQL Server
     */
    @JvmName("dnylultytdnojlue")
    public suspend fun targetConnectionInfo(`value`: Output) {
        this.targetConnectionInfo = value
    }

    /**
     * @param value Flag for whether to validate SSIS catalog is reachable on the target SQL MI server.
     */
    @JvmName("kauvktydajcetkwc")
    public suspend fun validateSsisCatalogOnly(`value`: Output) {
        this.validateSsisCatalogOnly = value
    }

    /**
     * @param value Flag for whether to collect agent jobs from target SQL MI server.
     */
    @JvmName("tuappwqwbrfpbtpt")
    public suspend fun collectAgentJobs(`value`: Boolean?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.collectAgentJobs = mapped
    }

    /**
     * @param value Flag for whether to collect logins from target SQL MI server.
     */
    @JvmName("auervsicfdnmpiqp")
    public suspend fun collectLogins(`value`: Boolean?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.collectLogins = mapped
    }

    /**
     * @param value Connection information for target SQL Server
     */
    @JvmName("oyrnuixbsjkufgsw")
    public suspend fun targetConnectionInfo(`value`: SqlConnectionInfoArgs) {
        val toBeMapped = value
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.targetConnectionInfo = mapped
    }

    /**
     * @param argument Connection information for target SQL Server
     */
    @JvmName("bowgonhehocwuavc")
    public suspend fun targetConnectionInfo(argument: suspend SqlConnectionInfoArgsBuilder.() -> Unit) {
        val toBeMapped = SqlConnectionInfoArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.targetConnectionInfo = mapped
    }

    /**
     * @param value Flag for whether to validate SSIS catalog is reachable on the target SQL MI server.
     */
    @JvmName("mwglhfpucuebvlau")
    public suspend fun validateSsisCatalogOnly(`value`: Boolean?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.validateSsisCatalogOnly = mapped
    }

    internal fun build(): ConnectToTargetSqlMITaskInputArgs = ConnectToTargetSqlMITaskInputArgs(
        collectAgentJobs = collectAgentJobs,
        collectLogins = collectLogins,
        targetConnectionInfo = targetConnectionInfo ?: throw
            PulumiNullFieldException("targetConnectionInfo"),
        validateSsisCatalogOnly = validateSsisCatalogOnly,
    )
}