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

com.pulumi.awsnative.kendra.kotlin.inputs.DataSourceOneDriveConfigurationArgs.kt Maven / Gradle / Ivy

Go to download

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: 1.11.0.0
Show newest version
@file:Suppress("NAME_SHADOWING", "DEPRECATION")

package com.pulumi.awsnative.kendra.kotlin.inputs

import com.pulumi.awsnative.kendra.inputs.DataSourceOneDriveConfigurationArgs.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.String
import kotlin.Suppress
import kotlin.Unit
import kotlin.collections.List
import kotlin.jvm.JvmName

/**
 *
 * @property disableLocalGroups `TRUE` to disable local groups information.
 * @property exclusionPatterns A list of regular expression patterns to exclude certain documents in your OneDrive. Documents that match the patterns are excluded from the index. Documents that don't match the patterns are included in the index. If a document matches both an inclusion and exclusion pattern, the exclusion pattern takes precedence and the document isn't included in the index.
 * The pattern is applied to the file name.
 * @property fieldMappings A list of `DataSourceToIndexFieldMapping` objects that map OneDrive data source attributes or field names to Amazon Kendra index field names. To create custom fields, use the `UpdateIndex` API before you map to OneDrive fields. For more information, see [Mapping data source fields](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html) . The OneDrive data source field names must exist in your OneDrive custom metadata.
 * @property inclusionPatterns A list of regular expression patterns to include certain documents in your OneDrive. Documents that match the patterns are included in the index. Documents that don't match the patterns are excluded from the index. If a document matches both an inclusion and exclusion pattern, the exclusion pattern takes precedence and the document isn't included in the index.
 * The pattern is applied to the file name.
 * @property oneDriveUsers A list of user accounts whose documents should be indexed.
 * @property secretArn The Amazon Resource Name (ARN) of an AWS Secrets Manager secret that contains the user name and password to connect to OneDrive. The user name should be the application ID for the OneDrive application, and the password is the application key for the OneDrive application.
 * @property tenantDomain The Azure Active Directory domain of the organization.
 */
public data class DataSourceOneDriveConfigurationArgs(
    public val disableLocalGroups: Output? = null,
    public val exclusionPatterns: Output>? = null,
    public val fieldMappings: Output>? = null,
    public val inclusionPatterns: Output>? = null,
    public val oneDriveUsers: Output,
    public val secretArn: Output,
    public val tenantDomain: Output,
) : ConvertibleToJava {
    override fun toJava(): com.pulumi.awsnative.kendra.inputs.DataSourceOneDriveConfigurationArgs =
        com.pulumi.awsnative.kendra.inputs.DataSourceOneDriveConfigurationArgs.builder()
            .disableLocalGroups(disableLocalGroups?.applyValue({ args0 -> args0 }))
            .exclusionPatterns(exclusionPatterns?.applyValue({ args0 -> args0.map({ args0 -> args0 }) }))
            .fieldMappings(
                fieldMappings?.applyValue({ args0 ->
                    args0.map({ args0 ->
                        args0.let({ args0 ->
                            args0.toJava()
                        })
                    })
                }),
            )
            .inclusionPatterns(inclusionPatterns?.applyValue({ args0 -> args0.map({ args0 -> args0 }) }))
            .oneDriveUsers(oneDriveUsers.applyValue({ args0 -> args0.let({ args0 -> args0.toJava() }) }))
            .secretArn(secretArn.applyValue({ args0 -> args0 }))
            .tenantDomain(tenantDomain.applyValue({ args0 -> args0 })).build()
}

/**
 * Builder for [DataSourceOneDriveConfigurationArgs].
 */
@PulumiTagMarker
public class DataSourceOneDriveConfigurationArgsBuilder internal constructor() {
    private var disableLocalGroups: Output? = null

    private var exclusionPatterns: Output>? = null

    private var fieldMappings: Output>? = null

    private var inclusionPatterns: Output>? = null

    private var oneDriveUsers: Output? = null

    private var secretArn: Output? = null

    private var tenantDomain: Output? = null

    /**
     * @param value `TRUE` to disable local groups information.
     */
    @JvmName("fnbuodlennlswfjp")
    public suspend fun disableLocalGroups(`value`: Output) {
        this.disableLocalGroups = value
    }

    /**
     * @param value A list of regular expression patterns to exclude certain documents in your OneDrive. Documents that match the patterns are excluded from the index. Documents that don't match the patterns are included in the index. If a document matches both an inclusion and exclusion pattern, the exclusion pattern takes precedence and the document isn't included in the index.
     * The pattern is applied to the file name.
     */
    @JvmName("vrleihbvjrtehher")
    public suspend fun exclusionPatterns(`value`: Output>) {
        this.exclusionPatterns = value
    }

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

    /**
     * @param values A list of regular expression patterns to exclude certain documents in your OneDrive. Documents that match the patterns are excluded from the index. Documents that don't match the patterns are included in the index. If a document matches both an inclusion and exclusion pattern, the exclusion pattern takes precedence and the document isn't included in the index.
     * The pattern is applied to the file name.
     */
    @JvmName("upgyfalcqwjtsipt")
    public suspend fun exclusionPatterns(values: List>) {
        this.exclusionPatterns = Output.all(values)
    }

    /**
     * @param value A list of `DataSourceToIndexFieldMapping` objects that map OneDrive data source attributes or field names to Amazon Kendra index field names. To create custom fields, use the `UpdateIndex` API before you map to OneDrive fields. For more information, see [Mapping data source fields](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html) . The OneDrive data source field names must exist in your OneDrive custom metadata.
     */
    @JvmName("jawfpbaqcxpcmrbi")
    public suspend fun fieldMappings(`value`: Output>) {
        this.fieldMappings = value
    }

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

    /**
     * @param values A list of `DataSourceToIndexFieldMapping` objects that map OneDrive data source attributes or field names to Amazon Kendra index field names. To create custom fields, use the `UpdateIndex` API before you map to OneDrive fields. For more information, see [Mapping data source fields](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html) . The OneDrive data source field names must exist in your OneDrive custom metadata.
     */
    @JvmName("ianrggfsnyeplpux")
    public suspend fun fieldMappings(values: List>) {
        this.fieldMappings = Output.all(values)
    }

    /**
     * @param value A list of regular expression patterns to include certain documents in your OneDrive. Documents that match the patterns are included in the index. Documents that don't match the patterns are excluded from the index. If a document matches both an inclusion and exclusion pattern, the exclusion pattern takes precedence and the document isn't included in the index.
     * The pattern is applied to the file name.
     */
    @JvmName("bsuwswpkeqeraocg")
    public suspend fun inclusionPatterns(`value`: Output>) {
        this.inclusionPatterns = value
    }

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

    /**
     * @param values A list of regular expression patterns to include certain documents in your OneDrive. Documents that match the patterns are included in the index. Documents that don't match the patterns are excluded from the index. If a document matches both an inclusion and exclusion pattern, the exclusion pattern takes precedence and the document isn't included in the index.
     * The pattern is applied to the file name.
     */
    @JvmName("wuetgchchhjxuamd")
    public suspend fun inclusionPatterns(values: List>) {
        this.inclusionPatterns = Output.all(values)
    }

    /**
     * @param value A list of user accounts whose documents should be indexed.
     */
    @JvmName("pghudkebwfuqullb")
    public suspend fun oneDriveUsers(`value`: Output) {
        this.oneDriveUsers = value
    }

    /**
     * @param value The Amazon Resource Name (ARN) of an AWS Secrets Manager secret that contains the user name and password to connect to OneDrive. The user name should be the application ID for the OneDrive application, and the password is the application key for the OneDrive application.
     */
    @JvmName("gvxnkujedixaifib")
    public suspend fun secretArn(`value`: Output) {
        this.secretArn = value
    }

    /**
     * @param value The Azure Active Directory domain of the organization.
     */
    @JvmName("qgorklqqrekohqvh")
    public suspend fun tenantDomain(`value`: Output) {
        this.tenantDomain = value
    }

    /**
     * @param value `TRUE` to disable local groups information.
     */
    @JvmName("vgtdvfgxbibbwhba")
    public suspend fun disableLocalGroups(`value`: Boolean?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.disableLocalGroups = mapped
    }

    /**
     * @param value A list of regular expression patterns to exclude certain documents in your OneDrive. Documents that match the patterns are excluded from the index. Documents that don't match the patterns are included in the index. If a document matches both an inclusion and exclusion pattern, the exclusion pattern takes precedence and the document isn't included in the index.
     * The pattern is applied to the file name.
     */
    @JvmName("dyscmuvgusaxjevi")
    public suspend fun exclusionPatterns(`value`: List?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.exclusionPatterns = mapped
    }

    /**
     * @param values A list of regular expression patterns to exclude certain documents in your OneDrive. Documents that match the patterns are excluded from the index. Documents that don't match the patterns are included in the index. If a document matches both an inclusion and exclusion pattern, the exclusion pattern takes precedence and the document isn't included in the index.
     * The pattern is applied to the file name.
     */
    @JvmName("rgxqpibnokohvahj")
    public suspend fun exclusionPatterns(vararg values: String) {
        val toBeMapped = values.toList()
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.exclusionPatterns = mapped
    }

    /**
     * @param value A list of `DataSourceToIndexFieldMapping` objects that map OneDrive data source attributes or field names to Amazon Kendra index field names. To create custom fields, use the `UpdateIndex` API before you map to OneDrive fields. For more information, see [Mapping data source fields](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html) . The OneDrive data source field names must exist in your OneDrive custom metadata.
     */
    @JvmName("wynjhmlnyermvfli")
    public suspend fun fieldMappings(`value`: List?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.fieldMappings = mapped
    }

    /**
     * @param argument A list of `DataSourceToIndexFieldMapping` objects that map OneDrive data source attributes or field names to Amazon Kendra index field names. To create custom fields, use the `UpdateIndex` API before you map to OneDrive fields. For more information, see [Mapping data source fields](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html) . The OneDrive data source field names must exist in your OneDrive custom metadata.
     */
    @JvmName("glgcpdbouuxowydc")
    public suspend fun fieldMappings(argument: List Unit>) {
        val toBeMapped = argument.toList().map {
            DataSourceToIndexFieldMappingArgsBuilder().applySuspend { it() }.build()
        }
        val mapped = of(toBeMapped)
        this.fieldMappings = mapped
    }

    /**
     * @param argument A list of `DataSourceToIndexFieldMapping` objects that map OneDrive data source attributes or field names to Amazon Kendra index field names. To create custom fields, use the `UpdateIndex` API before you map to OneDrive fields. For more information, see [Mapping data source fields](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html) . The OneDrive data source field names must exist in your OneDrive custom metadata.
     */
    @JvmName("pwrtmqpepfkdlnfu")
    public suspend fun fieldMappings(vararg argument: suspend DataSourceToIndexFieldMappingArgsBuilder.() -> Unit) {
        val toBeMapped = argument.toList().map {
            DataSourceToIndexFieldMappingArgsBuilder().applySuspend { it() }.build()
        }
        val mapped = of(toBeMapped)
        this.fieldMappings = mapped
    }

    /**
     * @param argument A list of `DataSourceToIndexFieldMapping` objects that map OneDrive data source attributes or field names to Amazon Kendra index field names. To create custom fields, use the `UpdateIndex` API before you map to OneDrive fields. For more information, see [Mapping data source fields](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html) . The OneDrive data source field names must exist in your OneDrive custom metadata.
     */
    @JvmName("tygyulqfwtmmhlfd")
    public suspend fun fieldMappings(argument: suspend DataSourceToIndexFieldMappingArgsBuilder.() -> Unit) {
        val toBeMapped = listOf(
            DataSourceToIndexFieldMappingArgsBuilder().applySuspend {
                argument()
            }.build(),
        )
        val mapped = of(toBeMapped)
        this.fieldMappings = mapped
    }

    /**
     * @param values A list of `DataSourceToIndexFieldMapping` objects that map OneDrive data source attributes or field names to Amazon Kendra index field names. To create custom fields, use the `UpdateIndex` API before you map to OneDrive fields. For more information, see [Mapping data source fields](https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html) . The OneDrive data source field names must exist in your OneDrive custom metadata.
     */
    @JvmName("boedotfdhgybirbu")
    public suspend fun fieldMappings(vararg values: DataSourceToIndexFieldMappingArgs) {
        val toBeMapped = values.toList()
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.fieldMappings = mapped
    }

    /**
     * @param value A list of regular expression patterns to include certain documents in your OneDrive. Documents that match the patterns are included in the index. Documents that don't match the patterns are excluded from the index. If a document matches both an inclusion and exclusion pattern, the exclusion pattern takes precedence and the document isn't included in the index.
     * The pattern is applied to the file name.
     */
    @JvmName("sntnhnusqmbivtcc")
    public suspend fun inclusionPatterns(`value`: List?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.inclusionPatterns = mapped
    }

    /**
     * @param values A list of regular expression patterns to include certain documents in your OneDrive. Documents that match the patterns are included in the index. Documents that don't match the patterns are excluded from the index. If a document matches both an inclusion and exclusion pattern, the exclusion pattern takes precedence and the document isn't included in the index.
     * The pattern is applied to the file name.
     */
    @JvmName("pfquhbiqliqxlpih")
    public suspend fun inclusionPatterns(vararg values: String) {
        val toBeMapped = values.toList()
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.inclusionPatterns = mapped
    }

    /**
     * @param value A list of user accounts whose documents should be indexed.
     */
    @JvmName("iniuhqxrqdhyyunq")
    public suspend fun oneDriveUsers(`value`: DataSourceOneDriveUsersArgs) {
        val toBeMapped = value
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.oneDriveUsers = mapped
    }

    /**
     * @param argument A list of user accounts whose documents should be indexed.
     */
    @JvmName("vpyquxrtdinbuumo")
    public suspend fun oneDriveUsers(argument: suspend DataSourceOneDriveUsersArgsBuilder.() -> Unit) {
        val toBeMapped = DataSourceOneDriveUsersArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.oneDriveUsers = mapped
    }

    /**
     * @param value The Amazon Resource Name (ARN) of an AWS Secrets Manager secret that contains the user name and password to connect to OneDrive. The user name should be the application ID for the OneDrive application, and the password is the application key for the OneDrive application.
     */
    @JvmName("usnvdekipfjqqhcc")
    public suspend fun secretArn(`value`: String) {
        val toBeMapped = value
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.secretArn = mapped
    }

    /**
     * @param value The Azure Active Directory domain of the organization.
     */
    @JvmName("pgujqjhpsscuavew")
    public suspend fun tenantDomain(`value`: String) {
        val toBeMapped = value
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.tenantDomain = mapped
    }

    internal fun build(): DataSourceOneDriveConfigurationArgs = DataSourceOneDriveConfigurationArgs(
        disableLocalGroups = disableLocalGroups,
        exclusionPatterns = exclusionPatterns,
        fieldMappings = fieldMappings,
        inclusionPatterns = inclusionPatterns,
        oneDriveUsers = oneDriveUsers ?: throw PulumiNullFieldException("oneDriveUsers"),
        secretArn = secretArn ?: throw PulumiNullFieldException("secretArn"),
        tenantDomain = tenantDomain ?: throw PulumiNullFieldException("tenantDomain"),
    )
}




© 2015 - 2024 Weber Informatics LLC | Privacy Policy