# coding=utf-8
# *** WARNING: this file was generated by the Pulumi SDK Generator. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***

import warnings
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
from ._enums import *

__all__ = [
    'DataSourceAccessControlListConfigurationArgs',
    'DataSourceAclConfigurationArgs',
    'DataSourceColumnConfigurationArgs',
    'DataSourceConfluenceAttachmentConfigurationArgs',
    'DataSourceConfluenceAttachmentToIndexFieldMappingArgs',
    'DataSourceConfluenceBlogConfigurationArgs',
    'DataSourceConfluenceBlogToIndexFieldMappingArgs',
    'DataSourceConfluenceConfigurationArgs',
    'DataSourceConfluencePageConfigurationArgs',
    'DataSourceConfluencePageToIndexFieldMappingArgs',
    'DataSourceConfluenceSpaceConfigurationArgs',
    'DataSourceConfluenceSpaceToIndexFieldMappingArgs',
    'DataSourceConnectionConfigurationArgs',
    'DataSourceDataSourceConfigurationArgs',
    'DataSourceDataSourceToIndexFieldMappingArgs',
    'DataSourceDataSourceVpcConfigurationArgs',
    'DataSourceDatabaseConfigurationArgs',
    'DataSourceDocumentsMetadataConfigurationArgs',
    'DataSourceGoogleDriveConfigurationArgs',
    'DataSourceOneDriveConfigurationArgs',
    'DataSourceOneDriveUsersArgs',
    'DataSourceS3DataSourceConfigurationArgs',
    'DataSourceS3PathArgs',
    'DataSourceSalesforceChatterFeedConfigurationArgs',
    'DataSourceSalesforceConfigurationArgs',
    'DataSourceSalesforceCustomKnowledgeArticleTypeConfigurationArgs',
    'DataSourceSalesforceKnowledgeArticleConfigurationArgs',
    'DataSourceSalesforceStandardKnowledgeArticleTypeConfigurationArgs',
    'DataSourceSalesforceStandardObjectAttachmentConfigurationArgs',
    'DataSourceSalesforceStandardObjectConfigurationArgs',
    'DataSourceServiceNowConfigurationArgs',
    'DataSourceServiceNowKnowledgeArticleConfigurationArgs',
    'DataSourceServiceNowServiceCatalogConfigurationArgs',
    'DataSourceSharePointConfigurationArgs',
    'DataSourceSqlConfigurationArgs',
    'DataSourceTagArgs',
    'FaqS3PathArgs',
    'FaqTagArgs',
    'IndexCapacityUnitsConfigurationArgs',
    'IndexDocumentMetadataConfigurationArgs',
    'IndexJsonTokenTypeConfigurationArgs',
    'IndexJwtTokenTypeConfigurationArgs',
    'IndexRelevanceArgs',
    'IndexSearchArgs',
    'IndexServerSideEncryptionConfigurationArgs',
    'IndexTagArgs',
    'IndexUserTokenConfigurationArgs',
    'IndexValueImportanceItemArgs',
]

@pulumi.input_type
class DataSourceAccessControlListConfigurationArgs:
    def __init__(__self__, *,
                 key_path: Optional[pulumi.Input[str]] = None):
        if key_path is not None:
            pulumi.set(__self__, "key_path", key_path)

    @property
    @pulumi.getter(name="keyPath")
    def key_path(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "key_path")

    @key_path.setter
    def key_path(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "key_path", value)


@pulumi.input_type
class DataSourceAclConfigurationArgs:
    def __init__(__self__, *,
                 allowed_groups_column_name: pulumi.Input[str]):
        pulumi.set(__self__, "allowed_groups_column_name", allowed_groups_column_name)

    @property
    @pulumi.getter(name="allowedGroupsColumnName")
    def allowed_groups_column_name(self) -> pulumi.Input[str]:
        return pulumi.get(self, "allowed_groups_column_name")

    @allowed_groups_column_name.setter
    def allowed_groups_column_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "allowed_groups_column_name", value)


@pulumi.input_type
class DataSourceColumnConfigurationArgs:
    def __init__(__self__, *,
                 change_detecting_columns: pulumi.Input[Sequence[pulumi.Input[str]]],
                 document_data_column_name: pulumi.Input[str],
                 document_id_column_name: pulumi.Input[str],
                 document_title_column_name: Optional[pulumi.Input[str]] = None,
                 field_mappings: Optional[pulumi.Input[Sequence[pulumi.Input['DataSourceDataSourceToIndexFieldMappingArgs']]]] = None):
        pulumi.set(__self__, "change_detecting_columns", change_detecting_columns)
        pulumi.set(__self__, "document_data_column_name", document_data_column_name)
        pulumi.set(__self__, "document_id_column_name", document_id_column_name)
        if document_title_column_name is not None:
            pulumi.set(__self__, "document_title_column_name", document_title_column_name)
        if field_mappings is not None:
            pulumi.set(__self__, "field_mappings", field_mappings)

    @property
    @pulumi.getter(name="changeDetectingColumns")
    def change_detecting_columns(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        return pulumi.get(self, "change_detecting_columns")

    @change_detecting_columns.setter
    def change_detecting_columns(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(self, "change_detecting_columns", value)

    @property
    @pulumi.getter(name="documentDataColumnName")
    def document_data_column_name(self) -> pulumi.Input[str]:
        return pulumi.get(self, "document_data_column_name")

    @document_data_column_name.setter
    def document_data_column_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "document_data_column_name", value)

    @property
    @pulumi.getter(name="documentIdColumnName")
    def document_id_column_name(self) -> pulumi.Input[str]:
        return pulumi.get(self, "document_id_column_name")

    @document_id_column_name.setter
    def document_id_column_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "document_id_column_name", value)

    @property
    @pulumi.getter(name="documentTitleColumnName")
    def document_title_column_name(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "document_title_column_name")

    @document_title_column_name.setter
    def document_title_column_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "document_title_column_name", value)

    @property
    @pulumi.getter(name="fieldMappings")
    def field_mappings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DataSourceDataSourceToIndexFieldMappingArgs']]]]:
        return pulumi.get(self, "field_mappings")

    @field_mappings.setter
    def field_mappings(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DataSourceDataSourceToIndexFieldMappingArgs']]]]):
        pulumi.set(self, "field_mappings", value)


@pulumi.input_type
class DataSourceConfluenceAttachmentConfigurationArgs:
    def __init__(__self__, *,
                 attachment_field_mappings: Optional[pulumi.Input[Sequence[pulumi.Input['DataSourceConfluenceAttachmentToIndexFieldMappingArgs']]]] = None,
                 crawl_attachments: Optional[pulumi.Input[bool]] = None):
        if attachment_field_mappings is not None:
            pulumi.set(__self__, "attachment_field_mappings", attachment_field_mappings)
        if crawl_attachments is not None:
            pulumi.set(__self__, "crawl_attachments", crawl_attachments)

    @property
    @pulumi.getter(name="attachmentFieldMappings")
    def attachment_field_mappings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DataSourceConfluenceAttachmentToIndexFieldMappingArgs']]]]:
        return pulumi.get(self, "attachment_field_mappings")

    @attachment_field_mappings.setter
    def attachment_field_mappings(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DataSourceConfluenceAttachmentToIndexFieldMappingArgs']]]]):
        pulumi.set(self, "attachment_field_mappings", value)

    @property
    @pulumi.getter(name="crawlAttachments")
    def crawl_attachments(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "crawl_attachments")

    @crawl_attachments.setter
    def crawl_attachments(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "crawl_attachments", value)


@pulumi.input_type
class DataSourceConfluenceAttachmentToIndexFieldMappingArgs:
    def __init__(__self__, *,
                 data_source_field_name: pulumi.Input['DataSourceConfluenceAttachmentFieldName'],
                 index_field_name: pulumi.Input[str],
                 date_field_format: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "data_source_field_name", data_source_field_name)
        pulumi.set(__self__, "index_field_name", index_field_name)
        if date_field_format is not None:
            pulumi.set(__self__, "date_field_format", date_field_format)

    @property
    @pulumi.getter(name="dataSourceFieldName")
    def data_source_field_name(self) -> pulumi.Input['DataSourceConfluenceAttachmentFieldName']:
        return pulumi.get(self, "data_source_field_name")

    @data_source_field_name.setter
    def data_source_field_name(self, value: pulumi.Input['DataSourceConfluenceAttachmentFieldName']):
        pulumi.set(self, "data_source_field_name", value)

    @property
    @pulumi.getter(name="indexFieldName")
    def index_field_name(self) -> pulumi.Input[str]:
        return pulumi.get(self, "index_field_name")

    @index_field_name.setter
    def index_field_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "index_field_name", value)

    @property
    @pulumi.getter(name="dateFieldFormat")
    def date_field_format(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "date_field_format")

    @date_field_format.setter
    def date_field_format(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "date_field_format", value)


@pulumi.input_type
class DataSourceConfluenceBlogConfigurationArgs:
    def __init__(__self__, *,
                 blog_field_mappings: Optional[pulumi.Input[Sequence[pulumi.Input['DataSourceConfluenceBlogToIndexFieldMappingArgs']]]] = None):
        if blog_field_mappings is not None:
            pulumi.set(__self__, "blog_field_mappings", blog_field_mappings)

    @property
    @pulumi.getter(name="blogFieldMappings")
    def blog_field_mappings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DataSourceConfluenceBlogToIndexFieldMappingArgs']]]]:
        return pulumi.get(self, "blog_field_mappings")

    @blog_field_mappings.setter
    def blog_field_mappings(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DataSourceConfluenceBlogToIndexFieldMappingArgs']]]]):
        pulumi.set(self, "blog_field_mappings", value)


@pulumi.input_type
class DataSourceConfluenceBlogToIndexFieldMappingArgs:
    def __init__(__self__, *,
                 data_source_field_name: pulumi.Input['DataSourceConfluenceBlogFieldName'],
                 index_field_name: pulumi.Input[str],
                 date_field_format: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "data_source_field_name", data_source_field_name)
        pulumi.set(__self__, "index_field_name", index_field_name)
        if date_field_format is not None:
            pulumi.set(__self__, "date_field_format", date_field_format)

    @property
    @pulumi.getter(name="dataSourceFieldName")
    def data_source_field_name(self) -> pulumi.Input['DataSourceConfluenceBlogFieldName']:
        return pulumi.get(self, "data_source_field_name")

    @data_source_field_name.setter
    def data_source_field_name(self, value: pulumi.Input['DataSourceConfluenceBlogFieldName']):
        pulumi.set(self, "data_source_field_name", value)

    @property
    @pulumi.getter(name="indexFieldName")
    def index_field_name(self) -> pulumi.Input[str]:
        return pulumi.get(self, "index_field_name")

    @index_field_name.setter
    def index_field_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "index_field_name", value)

    @property
    @pulumi.getter(name="dateFieldFormat")
    def date_field_format(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "date_field_format")

    @date_field_format.setter
    def date_field_format(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "date_field_format", value)


@pulumi.input_type
class DataSourceConfluenceConfigurationArgs:
    def __init__(__self__, *,
                 secret_arn: pulumi.Input[str],
                 server_url: pulumi.Input[str],
                 version: pulumi.Input['DataSourceConfluenceVersion'],
                 attachment_configuration: Optional[pulumi.Input['DataSourceConfluenceAttachmentConfigurationArgs']] = None,
                 blog_configuration: Optional[pulumi.Input['DataSourceConfluenceBlogConfigurationArgs']] = None,
                 exclusion_patterns: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 inclusion_patterns: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 page_configuration: Optional[pulumi.Input['DataSourceConfluencePageConfigurationArgs']] = None,
                 space_configuration: Optional[pulumi.Input['DataSourceConfluenceSpaceConfigurationArgs']] = None,
                 vpc_configuration: Optional[pulumi.Input['DataSourceDataSourceVpcConfigurationArgs']] = None):
        pulumi.set(__self__, "secret_arn", secret_arn)
        pulumi.set(__self__, "server_url", server_url)
        pulumi.set(__self__, "version", version)
        if attachment_configuration is not None:
            pulumi.set(__self__, "attachment_configuration", attachment_configuration)
        if blog_configuration is not None:
            pulumi.set(__self__, "blog_configuration", blog_configuration)
        if exclusion_patterns is not None:
            pulumi.set(__self__, "exclusion_patterns", exclusion_patterns)
        if inclusion_patterns is not None:
            pulumi.set(__self__, "inclusion_patterns", inclusion_patterns)
        if page_configuration is not None:
            pulumi.set(__self__, "page_configuration", page_configuration)
        if space_configuration is not None:
            pulumi.set(__self__, "space_configuration", space_configuration)
        if vpc_configuration is not None:
            pulumi.set(__self__, "vpc_configuration", vpc_configuration)

    @property
    @pulumi.getter(name="secretArn")
    def secret_arn(self) -> pulumi.Input[str]:
        return pulumi.get(self, "secret_arn")

    @secret_arn.setter
    def secret_arn(self, value: pulumi.Input[str]):
        pulumi.set(self, "secret_arn", value)

    @property
    @pulumi.getter(name="serverUrl")
    def server_url(self) -> pulumi.Input[str]:
        return pulumi.get(self, "server_url")

    @server_url.setter
    def server_url(self, value: pulumi.Input[str]):
        pulumi.set(self, "server_url", value)

    @property
    @pulumi.getter
    def version(self) -> pulumi.Input['DataSourceConfluenceVersion']:
        return pulumi.get(self, "version")

    @version.setter
    def version(self, value: pulumi.Input['DataSourceConfluenceVersion']):
        pulumi.set(self, "version", value)

    @property
    @pulumi.getter(name="attachmentConfiguration")
    def attachment_configuration(self) -> Optional[pulumi.Input['DataSourceConfluenceAttachmentConfigurationArgs']]:
        return pulumi.get(self, "attachment_configuration")

    @attachment_configuration.setter
    def attachment_configuration(self, value: Optional[pulumi.Input['DataSourceConfluenceAttachmentConfigurationArgs']]):
        pulumi.set(self, "attachment_configuration", value)

    @property
    @pulumi.getter(name="blogConfiguration")
    def blog_configuration(self) -> Optional[pulumi.Input['DataSourceConfluenceBlogConfigurationArgs']]:
        return pulumi.get(self, "blog_configuration")

    @blog_configuration.setter
    def blog_configuration(self, value: Optional[pulumi.Input['DataSourceConfluenceBlogConfigurationArgs']]):
        pulumi.set(self, "blog_configuration", value)

    @property
    @pulumi.getter(name="exclusionPatterns")
    def exclusion_patterns(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "exclusion_patterns")

    @exclusion_patterns.setter
    def exclusion_patterns(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "exclusion_patterns", value)

    @property
    @pulumi.getter(name="inclusionPatterns")
    def inclusion_patterns(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "inclusion_patterns")

    @inclusion_patterns.setter
    def inclusion_patterns(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "inclusion_patterns", value)

    @property
    @pulumi.getter(name="pageConfiguration")
    def page_configuration(self) -> Optional[pulumi.Input['DataSourceConfluencePageConfigurationArgs']]:
        return pulumi.get(self, "page_configuration")

    @page_configuration.setter
    def page_configuration(self, value: Optional[pulumi.Input['DataSourceConfluencePageConfigurationArgs']]):
        pulumi.set(self, "page_configuration", value)

    @property
    @pulumi.getter(name="spaceConfiguration")
    def space_configuration(self) -> Optional[pulumi.Input['DataSourceConfluenceSpaceConfigurationArgs']]:
        return pulumi.get(self, "space_configuration")

    @space_configuration.setter
    def space_configuration(self, value: Optional[pulumi.Input['DataSourceConfluenceSpaceConfigurationArgs']]):
        pulumi.set(self, "space_configuration", value)

    @property
    @pulumi.getter(name="vpcConfiguration")
    def vpc_configuration(self) -> Optional[pulumi.Input['DataSourceDataSourceVpcConfigurationArgs']]:
        return pulumi.get(self, "vpc_configuration")

    @vpc_configuration.setter
    def vpc_configuration(self, value: Optional[pulumi.Input['DataSourceDataSourceVpcConfigurationArgs']]):
        pulumi.set(self, "vpc_configuration", value)


@pulumi.input_type
class DataSourceConfluencePageConfigurationArgs:
    def __init__(__self__, *,
                 page_field_mappings: Optional[pulumi.Input[Sequence[pulumi.Input['DataSourceConfluencePageToIndexFieldMappingArgs']]]] = None):
        if page_field_mappings is not None:
            pulumi.set(__self__, "page_field_mappings", page_field_mappings)

    @property
    @pulumi.getter(name="pageFieldMappings")
    def page_field_mappings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DataSourceConfluencePageToIndexFieldMappingArgs']]]]:
        return pulumi.get(self, "page_field_mappings")

    @page_field_mappings.setter
    def page_field_mappings(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DataSourceConfluencePageToIndexFieldMappingArgs']]]]):
        pulumi.set(self, "page_field_mappings", value)


@pulumi.input_type
class DataSourceConfluencePageToIndexFieldMappingArgs:
    def __init__(__self__, *,
                 data_source_field_name: pulumi.Input['DataSourceConfluencePageFieldName'],
                 index_field_name: pulumi.Input[str],
                 date_field_format: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "data_source_field_name", data_source_field_name)
        pulumi.set(__self__, "index_field_name", index_field_name)
        if date_field_format is not None:
            pulumi.set(__self__, "date_field_format", date_field_format)

    @property
    @pulumi.getter(name="dataSourceFieldName")
    def data_source_field_name(self) -> pulumi.Input['DataSourceConfluencePageFieldName']:
        return pulumi.get(self, "data_source_field_name")

    @data_source_field_name.setter
    def data_source_field_name(self, value: pulumi.Input['DataSourceConfluencePageFieldName']):
        pulumi.set(self, "data_source_field_name", value)

    @property
    @pulumi.getter(name="indexFieldName")
    def index_field_name(self) -> pulumi.Input[str]:
        return pulumi.get(self, "index_field_name")

    @index_field_name.setter
    def index_field_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "index_field_name", value)

    @property
    @pulumi.getter(name="dateFieldFormat")
    def date_field_format(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "date_field_format")

    @date_field_format.setter
    def date_field_format(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "date_field_format", value)


@pulumi.input_type
class DataSourceConfluenceSpaceConfigurationArgs:
    def __init__(__self__, *,
                 crawl_archived_spaces: Optional[pulumi.Input[bool]] = None,
                 crawl_personal_spaces: Optional[pulumi.Input[bool]] = None,
                 exclude_spaces: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 include_spaces: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 space_field_mappings: Optional[pulumi.Input[Sequence[pulumi.Input['DataSourceConfluenceSpaceToIndexFieldMappingArgs']]]] = None):
        if crawl_archived_spaces is not None:
            pulumi.set(__self__, "crawl_archived_spaces", crawl_archived_spaces)
        if crawl_personal_spaces is not None:
            pulumi.set(__self__, "crawl_personal_spaces", crawl_personal_spaces)
        if exclude_spaces is not None:
            pulumi.set(__self__, "exclude_spaces", exclude_spaces)
        if include_spaces is not None:
            pulumi.set(__self__, "include_spaces", include_spaces)
        if space_field_mappings is not None:
            pulumi.set(__self__, "space_field_mappings", space_field_mappings)

    @property
    @pulumi.getter(name="crawlArchivedSpaces")
    def crawl_archived_spaces(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "crawl_archived_spaces")

    @crawl_archived_spaces.setter
    def crawl_archived_spaces(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "crawl_archived_spaces", value)

    @property
    @pulumi.getter(name="crawlPersonalSpaces")
    def crawl_personal_spaces(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "crawl_personal_spaces")

    @crawl_personal_spaces.setter
    def crawl_personal_spaces(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "crawl_personal_spaces", value)

    @property
    @pulumi.getter(name="excludeSpaces")
    def exclude_spaces(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "exclude_spaces")

    @exclude_spaces.setter
    def exclude_spaces(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "exclude_spaces", value)

    @property
    @pulumi.getter(name="includeSpaces")
    def include_spaces(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "include_spaces")

    @include_spaces.setter
    def include_spaces(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "include_spaces", value)

    @property
    @pulumi.getter(name="spaceFieldMappings")
    def space_field_mappings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DataSourceConfluenceSpaceToIndexFieldMappingArgs']]]]:
        return pulumi.get(self, "space_field_mappings")

    @space_field_mappings.setter
    def space_field_mappings(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DataSourceConfluenceSpaceToIndexFieldMappingArgs']]]]):
        pulumi.set(self, "space_field_mappings", value)


@pulumi.input_type
class DataSourceConfluenceSpaceToIndexFieldMappingArgs:
    def __init__(__self__, *,
                 data_source_field_name: pulumi.Input['DataSourceConfluenceSpaceFieldName'],
                 index_field_name: pulumi.Input[str],
                 date_field_format: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "data_source_field_name", data_source_field_name)
        pulumi.set(__self__, "index_field_name", index_field_name)
        if date_field_format is not None:
            pulumi.set(__self__, "date_field_format", date_field_format)

    @property
    @pulumi.getter(name="dataSourceFieldName")
    def data_source_field_name(self) -> pulumi.Input['DataSourceConfluenceSpaceFieldName']:
        return pulumi.get(self, "data_source_field_name")

    @data_source_field_name.setter
    def data_source_field_name(self, value: pulumi.Input['DataSourceConfluenceSpaceFieldName']):
        pulumi.set(self, "data_source_field_name", value)

    @property
    @pulumi.getter(name="indexFieldName")
    def index_field_name(self) -> pulumi.Input[str]:
        return pulumi.get(self, "index_field_name")

    @index_field_name.setter
    def index_field_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "index_field_name", value)

    @property
    @pulumi.getter(name="dateFieldFormat")
    def date_field_format(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "date_field_format")

    @date_field_format.setter
    def date_field_format(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "date_field_format", value)


@pulumi.input_type
class DataSourceConnectionConfigurationArgs:
    def __init__(__self__, *,
                 database_host: pulumi.Input[str],
                 database_name: pulumi.Input[str],
                 database_port: pulumi.Input[int],
                 secret_arn: pulumi.Input[str],
                 table_name: pulumi.Input[str]):
        pulumi.set(__self__, "database_host", database_host)
        pulumi.set(__self__, "database_name", database_name)
        pulumi.set(__self__, "database_port", database_port)
        pulumi.set(__self__, "secret_arn", secret_arn)
        pulumi.set(__self__, "table_name", table_name)

    @property
    @pulumi.getter(name="databaseHost")
    def database_host(self) -> pulumi.Input[str]:
        return pulumi.get(self, "database_host")

    @database_host.setter
    def database_host(self, value: pulumi.Input[str]):
        pulumi.set(self, "database_host", value)

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> pulumi.Input[str]:
        return pulumi.get(self, "database_name")

    @database_name.setter
    def database_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "database_name", value)

    @property
    @pulumi.getter(name="databasePort")
    def database_port(self) -> pulumi.Input[int]:
        return pulumi.get(self, "database_port")

    @database_port.setter
    def database_port(self, value: pulumi.Input[int]):
        pulumi.set(self, "database_port", value)

    @property
    @pulumi.getter(name="secretArn")
    def secret_arn(self) -> pulumi.Input[str]:
        return pulumi.get(self, "secret_arn")

    @secret_arn.setter
    def secret_arn(self, value: pulumi.Input[str]):
        pulumi.set(self, "secret_arn", value)

    @property
    @pulumi.getter(name="tableName")
    def table_name(self) -> pulumi.Input[str]:
        return pulumi.get(self, "table_name")

    @table_name.setter
    def table_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "table_name", value)


@pulumi.input_type
class DataSourceDataSourceConfigurationArgs:
    def __init__(__self__, *,
                 confluence_configuration: Optional[pulumi.Input['DataSourceConfluenceConfigurationArgs']] = None,
                 database_configuration: Optional[pulumi.Input['DataSourceDatabaseConfigurationArgs']] = None,
                 google_drive_configuration: Optional[pulumi.Input['DataSourceGoogleDriveConfigurationArgs']] = None,
                 one_drive_configuration: Optional[pulumi.Input['DataSourceOneDriveConfigurationArgs']] = None,
                 s3_configuration: Optional[pulumi.Input['DataSourceS3DataSourceConfigurationArgs']] = None,
                 salesforce_configuration: Optional[pulumi.Input['DataSourceSalesforceConfigurationArgs']] = None,
                 service_now_configuration: Optional[pulumi.Input['DataSourceServiceNowConfigurationArgs']] = None,
                 share_point_configuration: Optional[pulumi.Input['DataSourceSharePointConfigurationArgs']] = None):
        if confluence_configuration is not None:
            pulumi.set(__self__, "confluence_configuration", confluence_configuration)
        if database_configuration is not None:
            pulumi.set(__self__, "database_configuration", database_configuration)
        if google_drive_configuration is not None:
            pulumi.set(__self__, "google_drive_configuration", google_drive_configuration)
        if one_drive_configuration is not None:
            pulumi.set(__self__, "one_drive_configuration", one_drive_configuration)
        if s3_configuration is not None:
            pulumi.set(__self__, "s3_configuration", s3_configuration)
        if salesforce_configuration is not None:
            pulumi.set(__self__, "salesforce_configuration", salesforce_configuration)
        if service_now_configuration is not None:
            pulumi.set(__self__, "service_now_configuration", service_now_configuration)
        if share_point_configuration is not None:
            pulumi.set(__self__, "share_point_configuration", share_point_configuration)

    @property
    @pulumi.getter(name="confluenceConfiguration")
    def confluence_configuration(self) -> Optional[pulumi.Input['DataSourceConfluenceConfigurationArgs']]:
        return pulumi.get(self, "confluence_configuration")

    @confluence_configuration.setter
    def confluence_configuration(self, value: Optional[pulumi.Input['DataSourceConfluenceConfigurationArgs']]):
        pulumi.set(self, "confluence_configuration", value)

    @property
    @pulumi.getter(name="databaseConfiguration")
    def database_configuration(self) -> Optional[pulumi.Input['DataSourceDatabaseConfigurationArgs']]:
        return pulumi.get(self, "database_configuration")

    @database_configuration.setter
    def database_configuration(self, value: Optional[pulumi.Input['DataSourceDatabaseConfigurationArgs']]):
        pulumi.set(self, "database_configuration", value)

    @property
    @pulumi.getter(name="googleDriveConfiguration")
    def google_drive_configuration(self) -> Optional[pulumi.Input['DataSourceGoogleDriveConfigurationArgs']]:
        return pulumi.get(self, "google_drive_configuration")

    @google_drive_configuration.setter
    def google_drive_configuration(self, value: Optional[pulumi.Input['DataSourceGoogleDriveConfigurationArgs']]):
        pulumi.set(self, "google_drive_configuration", value)

    @property
    @pulumi.getter(name="oneDriveConfiguration")
    def one_drive_configuration(self) -> Optional[pulumi.Input['DataSourceOneDriveConfigurationArgs']]:
        return pulumi.get(self, "one_drive_configuration")

    @one_drive_configuration.setter
    def one_drive_configuration(self, value: Optional[pulumi.Input['DataSourceOneDriveConfigurationArgs']]):
        pulumi.set(self, "one_drive_configuration", value)

    @property
    @pulumi.getter(name="s3Configuration")
    def s3_configuration(self) -> Optional[pulumi.Input['DataSourceS3DataSourceConfigurationArgs']]:
        return pulumi.get(self, "s3_configuration")

    @s3_configuration.setter
    def s3_configuration(self, value: Optional[pulumi.Input['DataSourceS3DataSourceConfigurationArgs']]):
        pulumi.set(self, "s3_configuration", value)

    @property
    @pulumi.getter(name="salesforceConfiguration")
    def salesforce_configuration(self) -> Optional[pulumi.Input['DataSourceSalesforceConfigurationArgs']]:
        return pulumi.get(self, "salesforce_configuration")

    @salesforce_configuration.setter
    def salesforce_configuration(self, value: Optional[pulumi.Input['DataSourceSalesforceConfigurationArgs']]):
        pulumi.set(self, "salesforce_configuration", value)

    @property
    @pulumi.getter(name="serviceNowConfiguration")
    def service_now_configuration(self) -> Optional[pulumi.Input['DataSourceServiceNowConfigurationArgs']]:
        return pulumi.get(self, "service_now_configuration")

    @service_now_configuration.setter
    def service_now_configuration(self, value: Optional[pulumi.Input['DataSourceServiceNowConfigurationArgs']]):
        pulumi.set(self, "service_now_configuration", value)

    @property
    @pulumi.getter(name="sharePointConfiguration")
    def share_point_configuration(self) -> Optional[pulumi.Input['DataSourceSharePointConfigurationArgs']]:
        return pulumi.get(self, "share_point_configuration")

    @share_point_configuration.setter
    def share_point_configuration(self, value: Optional[pulumi.Input['DataSourceSharePointConfigurationArgs']]):
        pulumi.set(self, "share_point_configuration", value)


@pulumi.input_type
class DataSourceDataSourceToIndexFieldMappingArgs:
    def __init__(__self__, *,
                 data_source_field_name: pulumi.Input[str],
                 index_field_name: pulumi.Input[str],
                 date_field_format: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "data_source_field_name", data_source_field_name)
        pulumi.set(__self__, "index_field_name", index_field_name)
        if date_field_format is not None:
            pulumi.set(__self__, "date_field_format", date_field_format)

    @property
    @pulumi.getter(name="dataSourceFieldName")
    def data_source_field_name(self) -> pulumi.Input[str]:
        return pulumi.get(self, "data_source_field_name")

    @data_source_field_name.setter
    def data_source_field_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "data_source_field_name", value)

    @property
    @pulumi.getter(name="indexFieldName")
    def index_field_name(self) -> pulumi.Input[str]:
        return pulumi.get(self, "index_field_name")

    @index_field_name.setter
    def index_field_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "index_field_name", value)

    @property
    @pulumi.getter(name="dateFieldFormat")
    def date_field_format(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "date_field_format")

    @date_field_format.setter
    def date_field_format(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "date_field_format", value)


@pulumi.input_type
class DataSourceDataSourceVpcConfigurationArgs:
    def __init__(__self__, *,
                 security_group_ids: pulumi.Input[Sequence[pulumi.Input[str]]],
                 subnet_ids: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(__self__, "security_group_ids", security_group_ids)
        pulumi.set(__self__, "subnet_ids", subnet_ids)

    @property
    @pulumi.getter(name="securityGroupIds")
    def security_group_ids(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        return pulumi.get(self, "security_group_ids")

    @security_group_ids.setter
    def security_group_ids(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(self, "security_group_ids", value)

    @property
    @pulumi.getter(name="subnetIds")
    def subnet_ids(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        return pulumi.get(self, "subnet_ids")

    @subnet_ids.setter
    def subnet_ids(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(self, "subnet_ids", value)


@pulumi.input_type
class DataSourceDatabaseConfigurationArgs:
    def __init__(__self__, *,
                 column_configuration: pulumi.Input['DataSourceColumnConfigurationArgs'],
                 connection_configuration: pulumi.Input['DataSourceConnectionConfigurationArgs'],
                 database_engine_type: pulumi.Input['DataSourceDatabaseEngineType'],
                 acl_configuration: Optional[pulumi.Input['DataSourceAclConfigurationArgs']] = None,
                 sql_configuration: Optional[pulumi.Input['DataSourceSqlConfigurationArgs']] = None,
                 vpc_configuration: Optional[pulumi.Input['DataSourceDataSourceVpcConfigurationArgs']] = None):
        pulumi.set(__self__, "column_configuration", column_configuration)
        pulumi.set(__self__, "connection_configuration", connection_configuration)
        pulumi.set(__self__, "database_engine_type", database_engine_type)
        if acl_configuration is not None:
            pulumi.set(__self__, "acl_configuration", acl_configuration)
        if sql_configuration is not None:
            pulumi.set(__self__, "sql_configuration", sql_configuration)
        if vpc_configuration is not None:
            pulumi.set(__self__, "vpc_configuration", vpc_configuration)

    @property
    @pulumi.getter(name="columnConfiguration")
    def column_configuration(self) -> pulumi.Input['DataSourceColumnConfigurationArgs']:
        return pulumi.get(self, "column_configuration")

    @column_configuration.setter
    def column_configuration(self, value: pulumi.Input['DataSourceColumnConfigurationArgs']):
        pulumi.set(self, "column_configuration", value)

    @property
    @pulumi.getter(name="connectionConfiguration")
    def connection_configuration(self) -> pulumi.Input['DataSourceConnectionConfigurationArgs']:
        return pulumi.get(self, "connection_configuration")

    @connection_configuration.setter
    def connection_configuration(self, value: pulumi.Input['DataSourceConnectionConfigurationArgs']):
        pulumi.set(self, "connection_configuration", value)

    @property
    @pulumi.getter(name="databaseEngineType")
    def database_engine_type(self) -> pulumi.Input['DataSourceDatabaseEngineType']:
        return pulumi.get(self, "database_engine_type")

    @database_engine_type.setter
    def database_engine_type(self, value: pulumi.Input['DataSourceDatabaseEngineType']):
        pulumi.set(self, "database_engine_type", value)

    @property
    @pulumi.getter(name="aclConfiguration")
    def acl_configuration(self) -> Optional[pulumi.Input['DataSourceAclConfigurationArgs']]:
        return pulumi.get(self, "acl_configuration")

    @acl_configuration.setter
    def acl_configuration(self, value: Optional[pulumi.Input['DataSourceAclConfigurationArgs']]):
        pulumi.set(self, "acl_configuration", value)

    @property
    @pulumi.getter(name="sqlConfiguration")
    def sql_configuration(self) -> Optional[pulumi.Input['DataSourceSqlConfigurationArgs']]:
        return pulumi.get(self, "sql_configuration")

    @sql_configuration.setter
    def sql_configuration(self, value: Optional[pulumi.Input['DataSourceSqlConfigurationArgs']]):
        pulumi.set(self, "sql_configuration", value)

    @property
    @pulumi.getter(name="vpcConfiguration")
    def vpc_configuration(self) -> Optional[pulumi.Input['DataSourceDataSourceVpcConfigurationArgs']]:
        return pulumi.get(self, "vpc_configuration")

    @vpc_configuration.setter
    def vpc_configuration(self, value: Optional[pulumi.Input['DataSourceDataSourceVpcConfigurationArgs']]):
        pulumi.set(self, "vpc_configuration", value)


@pulumi.input_type
class DataSourceDocumentsMetadataConfigurationArgs:
    def __init__(__self__, *,
                 s3_prefix: Optional[pulumi.Input[str]] = None):
        if s3_prefix is not None:
            pulumi.set(__self__, "s3_prefix", s3_prefix)

    @property
    @pulumi.getter(name="s3Prefix")
    def s3_prefix(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "s3_prefix")

    @s3_prefix.setter
    def s3_prefix(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "s3_prefix", value)


@pulumi.input_type
class DataSourceGoogleDriveConfigurationArgs:
    def __init__(__self__, *,
                 secret_arn: pulumi.Input[str],
                 exclude_mime_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 exclude_shared_drives: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 exclude_user_accounts: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 exclusion_patterns: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 field_mappings: Optional[pulumi.Input[Sequence[pulumi.Input['DataSourceDataSourceToIndexFieldMappingArgs']]]] = None,
                 inclusion_patterns: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        pulumi.set(__self__, "secret_arn", secret_arn)
        if exclude_mime_types is not None:
            pulumi.set(__self__, "exclude_mime_types", exclude_mime_types)
        if exclude_shared_drives is not None:
            pulumi.set(__self__, "exclude_shared_drives", exclude_shared_drives)
        if exclude_user_accounts is not None:
            pulumi.set(__self__, "exclude_user_accounts", exclude_user_accounts)
        if exclusion_patterns is not None:
            pulumi.set(__self__, "exclusion_patterns", exclusion_patterns)
        if field_mappings is not None:
            pulumi.set(__self__, "field_mappings", field_mappings)
        if inclusion_patterns is not None:
            pulumi.set(__self__, "inclusion_patterns", inclusion_patterns)

    @property
    @pulumi.getter(name="secretArn")
    def secret_arn(self) -> pulumi.Input[str]:
        return pulumi.get(self, "secret_arn")

    @secret_arn.setter
    def secret_arn(self, value: pulumi.Input[str]):
        pulumi.set(self, "secret_arn", value)

    @property
    @pulumi.getter(name="excludeMimeTypes")
    def exclude_mime_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "exclude_mime_types")

    @exclude_mime_types.setter
    def exclude_mime_types(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "exclude_mime_types", value)

    @property
    @pulumi.getter(name="excludeSharedDrives")
    def exclude_shared_drives(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "exclude_shared_drives")

    @exclude_shared_drives.setter
    def exclude_shared_drives(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "exclude_shared_drives", value)

    @property
    @pulumi.getter(name="excludeUserAccounts")
    def exclude_user_accounts(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "exclude_user_accounts")

    @exclude_user_accounts.setter
    def exclude_user_accounts(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "exclude_user_accounts", value)

    @property
    @pulumi.getter(name="exclusionPatterns")
    def exclusion_patterns(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "exclusion_patterns")

    @exclusion_patterns.setter
    def exclusion_patterns(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "exclusion_patterns", value)

    @property
    @pulumi.getter(name="fieldMappings")
    def field_mappings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DataSourceDataSourceToIndexFieldMappingArgs']]]]:
        return pulumi.get(self, "field_mappings")

    @field_mappings.setter
    def field_mappings(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DataSourceDataSourceToIndexFieldMappingArgs']]]]):
        pulumi.set(self, "field_mappings", value)

    @property
    @pulumi.getter(name="inclusionPatterns")
    def inclusion_patterns(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "inclusion_patterns")

    @inclusion_patterns.setter
    def inclusion_patterns(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "inclusion_patterns", value)


@pulumi.input_type
class DataSourceOneDriveConfigurationArgs:
    def __init__(__self__, *,
                 one_drive_users: pulumi.Input['DataSourceOneDriveUsersArgs'],
                 secret_arn: pulumi.Input[str],
                 tenant_domain: pulumi.Input[str],
                 disable_local_groups: Optional[pulumi.Input[bool]] = None,
                 exclusion_patterns: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 field_mappings: Optional[pulumi.Input[Sequence[pulumi.Input['DataSourceDataSourceToIndexFieldMappingArgs']]]] = None,
                 inclusion_patterns: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        pulumi.set(__self__, "one_drive_users", one_drive_users)
        pulumi.set(__self__, "secret_arn", secret_arn)
        pulumi.set(__self__, "tenant_domain", tenant_domain)
        if disable_local_groups is not None:
            pulumi.set(__self__, "disable_local_groups", disable_local_groups)
        if exclusion_patterns is not None:
            pulumi.set(__self__, "exclusion_patterns", exclusion_patterns)
        if field_mappings is not None:
            pulumi.set(__self__, "field_mappings", field_mappings)
        if inclusion_patterns is not None:
            pulumi.set(__self__, "inclusion_patterns", inclusion_patterns)

    @property
    @pulumi.getter(name="oneDriveUsers")
    def one_drive_users(self) -> pulumi.Input['DataSourceOneDriveUsersArgs']:
        return pulumi.get(self, "one_drive_users")

    @one_drive_users.setter
    def one_drive_users(self, value: pulumi.Input['DataSourceOneDriveUsersArgs']):
        pulumi.set(self, "one_drive_users", value)

    @property
    @pulumi.getter(name="secretArn")
    def secret_arn(self) -> pulumi.Input[str]:
        return pulumi.get(self, "secret_arn")

    @secret_arn.setter
    def secret_arn(self, value: pulumi.Input[str]):
        pulumi.set(self, "secret_arn", value)

    @property
    @pulumi.getter(name="tenantDomain")
    def tenant_domain(self) -> pulumi.Input[str]:
        return pulumi.get(self, "tenant_domain")

    @tenant_domain.setter
    def tenant_domain(self, value: pulumi.Input[str]):
        pulumi.set(self, "tenant_domain", value)

    @property
    @pulumi.getter(name="disableLocalGroups")
    def disable_local_groups(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "disable_local_groups")

    @disable_local_groups.setter
    def disable_local_groups(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "disable_local_groups", value)

    @property
    @pulumi.getter(name="exclusionPatterns")
    def exclusion_patterns(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "exclusion_patterns")

    @exclusion_patterns.setter
    def exclusion_patterns(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "exclusion_patterns", value)

    @property
    @pulumi.getter(name="fieldMappings")
    def field_mappings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DataSourceDataSourceToIndexFieldMappingArgs']]]]:
        return pulumi.get(self, "field_mappings")

    @field_mappings.setter
    def field_mappings(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DataSourceDataSourceToIndexFieldMappingArgs']]]]):
        pulumi.set(self, "field_mappings", value)

    @property
    @pulumi.getter(name="inclusionPatterns")
    def inclusion_patterns(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "inclusion_patterns")

    @inclusion_patterns.setter
    def inclusion_patterns(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "inclusion_patterns", value)


@pulumi.input_type
class DataSourceOneDriveUsersArgs:
    def __init__(__self__, *,
                 one_drive_user_list: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 one_drive_user_s3_path: Optional[pulumi.Input['DataSourceS3PathArgs']] = None):
        if one_drive_user_list is not None:
            pulumi.set(__self__, "one_drive_user_list", one_drive_user_list)
        if one_drive_user_s3_path is not None:
            pulumi.set(__self__, "one_drive_user_s3_path", one_drive_user_s3_path)

    @property
    @pulumi.getter(name="oneDriveUserList")
    def one_drive_user_list(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "one_drive_user_list")

    @one_drive_user_list.setter
    def one_drive_user_list(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "one_drive_user_list", value)

    @property
    @pulumi.getter(name="oneDriveUserS3Path")
    def one_drive_user_s3_path(self) -> Optional[pulumi.Input['DataSourceS3PathArgs']]:
        return pulumi.get(self, "one_drive_user_s3_path")

    @one_drive_user_s3_path.setter
    def one_drive_user_s3_path(self, value: Optional[pulumi.Input['DataSourceS3PathArgs']]):
        pulumi.set(self, "one_drive_user_s3_path", value)


@pulumi.input_type
class DataSourceS3DataSourceConfigurationArgs:
    def __init__(__self__, *,
                 bucket_name: pulumi.Input[str],
                 access_control_list_configuration: Optional[pulumi.Input['DataSourceAccessControlListConfigurationArgs']] = None,
                 documents_metadata_configuration: Optional[pulumi.Input['DataSourceDocumentsMetadataConfigurationArgs']] = None,
                 exclusion_patterns: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 inclusion_patterns: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 inclusion_prefixes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        S3 data source configuration
        """
        pulumi.set(__self__, "bucket_name", bucket_name)
        if access_control_list_configuration is not None:
            pulumi.set(__self__, "access_control_list_configuration", access_control_list_configuration)
        if documents_metadata_configuration is not None:
            pulumi.set(__self__, "documents_metadata_configuration", documents_metadata_configuration)
        if exclusion_patterns is not None:
            pulumi.set(__self__, "exclusion_patterns", exclusion_patterns)
        if inclusion_patterns is not None:
            pulumi.set(__self__, "inclusion_patterns", inclusion_patterns)
        if inclusion_prefixes is not None:
            pulumi.set(__self__, "inclusion_prefixes", inclusion_prefixes)

    @property
    @pulumi.getter(name="bucketName")
    def bucket_name(self) -> pulumi.Input[str]:
        return pulumi.get(self, "bucket_name")

    @bucket_name.setter
    def bucket_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "bucket_name", value)

    @property
    @pulumi.getter(name="accessControlListConfiguration")
    def access_control_list_configuration(self) -> Optional[pulumi.Input['DataSourceAccessControlListConfigurationArgs']]:
        return pulumi.get(self, "access_control_list_configuration")

    @access_control_list_configuration.setter
    def access_control_list_configuration(self, value: Optional[pulumi.Input['DataSourceAccessControlListConfigurationArgs']]):
        pulumi.set(self, "access_control_list_configuration", value)

    @property
    @pulumi.getter(name="documentsMetadataConfiguration")
    def documents_metadata_configuration(self) -> Optional[pulumi.Input['DataSourceDocumentsMetadataConfigurationArgs']]:
        return pulumi.get(self, "documents_metadata_configuration")

    @documents_metadata_configuration.setter
    def documents_metadata_configuration(self, value: Optional[pulumi.Input['DataSourceDocumentsMetadataConfigurationArgs']]):
        pulumi.set(self, "documents_metadata_configuration", value)

    @property
    @pulumi.getter(name="exclusionPatterns")
    def exclusion_patterns(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "exclusion_patterns")

    @exclusion_patterns.setter
    def exclusion_patterns(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "exclusion_patterns", value)

    @property
    @pulumi.getter(name="inclusionPatterns")
    def inclusion_patterns(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "inclusion_patterns")

    @inclusion_patterns.setter
    def inclusion_patterns(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "inclusion_patterns", value)

    @property
    @pulumi.getter(name="inclusionPrefixes")
    def inclusion_prefixes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "inclusion_prefixes")

    @inclusion_prefixes.setter
    def inclusion_prefixes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "inclusion_prefixes", value)


@pulumi.input_type
class DataSourceS3PathArgs:
    def __init__(__self__, *,
                 bucket: pulumi.Input[str],
                 key: pulumi.Input[str]):
        pulumi.set(__self__, "bucket", bucket)
        pulumi.set(__self__, "key", key)

    @property
    @pulumi.getter
    def bucket(self) -> pulumi.Input[str]:
        return pulumi.get(self, "bucket")

    @bucket.setter
    def bucket(self, value: pulumi.Input[str]):
        pulumi.set(self, "bucket", value)

    @property
    @pulumi.getter
    def key(self) -> pulumi.Input[str]:
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)


@pulumi.input_type
class DataSourceSalesforceChatterFeedConfigurationArgs:
    def __init__(__self__, *,
                 document_data_field_name: pulumi.Input[str],
                 document_title_field_name: Optional[pulumi.Input[str]] = None,
                 field_mappings: Optional[pulumi.Input[Sequence[pulumi.Input['DataSourceDataSourceToIndexFieldMappingArgs']]]] = None,
                 include_filter_types: Optional[pulumi.Input[Sequence[pulumi.Input['DataSourceSalesforceChatterFeedIncludeFilterType']]]] = None):
        pulumi.set(__self__, "document_data_field_name", document_data_field_name)
        if document_title_field_name is not None:
            pulumi.set(__self__, "document_title_field_name", document_title_field_name)
        if field_mappings is not None:
            pulumi.set(__self__, "field_mappings", field_mappings)
        if include_filter_types is not None:
            pulumi.set(__self__, "include_filter_types", include_filter_types)

    @property
    @pulumi.getter(name="documentDataFieldName")
    def document_data_field_name(self) -> pulumi.Input[str]:
        return pulumi.get(self, "document_data_field_name")

    @document_data_field_name.setter
    def document_data_field_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "document_data_field_name", value)

    @property
    @pulumi.getter(name="documentTitleFieldName")
    def document_title_field_name(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "document_title_field_name")

    @document_title_field_name.setter
    def document_title_field_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "document_title_field_name", value)

    @property
    @pulumi.getter(name="fieldMappings")
    def field_mappings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DataSourceDataSourceToIndexFieldMappingArgs']]]]:
        return pulumi.get(self, "field_mappings")

    @field_mappings.setter
    def field_mappings(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DataSourceDataSourceToIndexFieldMappingArgs']]]]):
        pulumi.set(self, "field_mappings", value)

    @property
    @pulumi.getter(name="includeFilterTypes")
    def include_filter_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DataSourceSalesforceChatterFeedIncludeFilterType']]]]:
        return pulumi.get(self, "include_filter_types")

    @include_filter_types.setter
    def include_filter_types(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DataSourceSalesforceChatterFeedIncludeFilterType']]]]):
        pulumi.set(self, "include_filter_types", value)


@pulumi.input_type
class DataSourceSalesforceConfigurationArgs:
    def __init__(__self__, *,
                 secret_arn: pulumi.Input[str],
                 server_url: pulumi.Input[str],
                 chatter_feed_configuration: Optional[pulumi.Input['DataSourceSalesforceChatterFeedConfigurationArgs']] = None,
                 crawl_attachments: Optional[pulumi.Input[bool]] = None,
                 exclude_attachment_file_patterns: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 include_attachment_file_patterns: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 knowledge_article_configuration: Optional[pulumi.Input['DataSourceSalesforceKnowledgeArticleConfigurationArgs']] = None,
                 standard_object_attachment_configuration: Optional[pulumi.Input['DataSourceSalesforceStandardObjectAttachmentConfigurationArgs']] = None,
                 standard_object_configurations: Optional[pulumi.Input[Sequence[pulumi.Input['DataSourceSalesforceStandardObjectConfigurationArgs']]]] = None):
        pulumi.set(__self__, "secret_arn", secret_arn)
        pulumi.set(__self__, "server_url", server_url)
        if chatter_feed_configuration is not None:
            pulumi.set(__self__, "chatter_feed_configuration", chatter_feed_configuration)
        if crawl_attachments is not None:
            pulumi.set(__self__, "crawl_attachments", crawl_attachments)
        if exclude_attachment_file_patterns is not None:
            pulumi.set(__self__, "exclude_attachment_file_patterns", exclude_attachment_file_patterns)
        if include_attachment_file_patterns is not None:
            pulumi.set(__self__, "include_attachment_file_patterns", include_attachment_file_patterns)
        if knowledge_article_configuration is not None:
            pulumi.set(__self__, "knowledge_article_configuration", knowledge_article_configuration)
        if standard_object_attachment_configuration is not None:
            pulumi.set(__self__, "standard_object_attachment_configuration", standard_object_attachment_configuration)
        if standard_object_configurations is not None:
            pulumi.set(__self__, "standard_object_configurations", standard_object_configurations)

    @property
    @pulumi.getter(name="secretArn")
    def secret_arn(self) -> pulumi.Input[str]:
        return pulumi.get(self, "secret_arn")

    @secret_arn.setter
    def secret_arn(self, value: pulumi.Input[str]):
        pulumi.set(self, "secret_arn", value)

    @property
    @pulumi.getter(name="serverUrl")
    def server_url(self) -> pulumi.Input[str]:
        return pulumi.get(self, "server_url")

    @server_url.setter
    def server_url(self, value: pulumi.Input[str]):
        pulumi.set(self, "server_url", value)

    @property
    @pulumi.getter(name="chatterFeedConfiguration")
    def chatter_feed_configuration(self) -> Optional[pulumi.Input['DataSourceSalesforceChatterFeedConfigurationArgs']]:
        return pulumi.get(self, "chatter_feed_configuration")

    @chatter_feed_configuration.setter
    def chatter_feed_configuration(self, value: Optional[pulumi.Input['DataSourceSalesforceChatterFeedConfigurationArgs']]):
        pulumi.set(self, "chatter_feed_configuration", value)

    @property
    @pulumi.getter(name="crawlAttachments")
    def crawl_attachments(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "crawl_attachments")

    @crawl_attachments.setter
    def crawl_attachments(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "crawl_attachments", value)

    @property
    @pulumi.getter(name="excludeAttachmentFilePatterns")
    def exclude_attachment_file_patterns(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "exclude_attachment_file_patterns")

    @exclude_attachment_file_patterns.setter
    def exclude_attachment_file_patterns(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "exclude_attachment_file_patterns", value)

    @property
    @pulumi.getter(name="includeAttachmentFilePatterns")
    def include_attachment_file_patterns(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "include_attachment_file_patterns")

    @include_attachment_file_patterns.setter
    def include_attachment_file_patterns(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "include_attachment_file_patterns", value)

    @property
    @pulumi.getter(name="knowledgeArticleConfiguration")
    def knowledge_article_configuration(self) -> Optional[pulumi.Input['DataSourceSalesforceKnowledgeArticleConfigurationArgs']]:
        return pulumi.get(self, "knowledge_article_configuration")

    @knowledge_article_configuration.setter
    def knowledge_article_configuration(self, value: Optional[pulumi.Input['DataSourceSalesforceKnowledgeArticleConfigurationArgs']]):
        pulumi.set(self, "knowledge_article_configuration", value)

    @property
    @pulumi.getter(name="standardObjectAttachmentConfiguration")
    def standard_object_attachment_configuration(self) -> Optional[pulumi.Input['DataSourceSalesforceStandardObjectAttachmentConfigurationArgs']]:
        return pulumi.get(self, "standard_object_attachment_configuration")

    @standard_object_attachment_configuration.setter
    def standard_object_attachment_configuration(self, value: Optional[pulumi.Input['DataSourceSalesforceStandardObjectAttachmentConfigurationArgs']]):
        pulumi.set(self, "standard_object_attachment_configuration", value)

    @property
    @pulumi.getter(name="standardObjectConfigurations")
    def standard_object_configurations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DataSourceSalesforceStandardObjectConfigurationArgs']]]]:
        return pulumi.get(self, "standard_object_configurations")

    @standard_object_configurations.setter
    def standard_object_configurations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DataSourceSalesforceStandardObjectConfigurationArgs']]]]):
        pulumi.set(self, "standard_object_configurations", value)


@pulumi.input_type
class DataSourceSalesforceCustomKnowledgeArticleTypeConfigurationArgs:
    def __init__(__self__, *,
                 document_data_field_name: pulumi.Input[str],
                 name: pulumi.Input[str],
                 document_title_field_name: Optional[pulumi.Input[str]] = None,
                 field_mappings: Optional[pulumi.Input[Sequence[pulumi.Input['DataSourceDataSourceToIndexFieldMappingArgs']]]] = None):
        pulumi.set(__self__, "document_data_field_name", document_data_field_name)
        pulumi.set(__self__, "name", name)
        if document_title_field_name is not None:
            pulumi.set(__self__, "document_title_field_name", document_title_field_name)
        if field_mappings is not None:
            pulumi.set(__self__, "field_mappings", field_mappings)

    @property
    @pulumi.getter(name="documentDataFieldName")
    def document_data_field_name(self) -> pulumi.Input[str]:
        return pulumi.get(self, "document_data_field_name")

    @document_data_field_name.setter
    def document_data_field_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "document_data_field_name", value)

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: pulumi.Input[str]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter(name="documentTitleFieldName")
    def document_title_field_name(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "document_title_field_name")

    @document_title_field_name.setter
    def document_title_field_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "document_title_field_name", value)

    @property
    @pulumi.getter(name="fieldMappings")
    def field_mappings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DataSourceDataSourceToIndexFieldMappingArgs']]]]:
        return pulumi.get(self, "field_mappings")

    @field_mappings.setter
    def field_mappings(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DataSourceDataSourceToIndexFieldMappingArgs']]]]):
        pulumi.set(self, "field_mappings", value)


@pulumi.input_type
class DataSourceSalesforceKnowledgeArticleConfigurationArgs:
    def __init__(__self__, *,
                 included_states: pulumi.Input[Sequence[pulumi.Input['DataSourceSalesforceKnowledgeArticleState']]],
                 custom_knowledge_article_type_configurations: Optional[pulumi.Input[Sequence[pulumi.Input['DataSourceSalesforceCustomKnowledgeArticleTypeConfigurationArgs']]]] = None,
                 standard_knowledge_article_type_configuration: Optional[pulumi.Input['DataSourceSalesforceStandardKnowledgeArticleTypeConfigurationArgs']] = None):
        pulumi.set(__self__, "included_states", included_states)
        if custom_knowledge_article_type_configurations is not None:
            pulumi.set(__self__, "custom_knowledge_article_type_configurations", custom_knowledge_article_type_configurations)
        if standard_knowledge_article_type_configuration is not None:
            pulumi.set(__self__, "standard_knowledge_article_type_configuration", standard_knowledge_article_type_configuration)

    @property
    @pulumi.getter(name="includedStates")
    def included_states(self) -> pulumi.Input[Sequence[pulumi.Input['DataSourceSalesforceKnowledgeArticleState']]]:
        return pulumi.get(self, "included_states")

    @included_states.setter
    def included_states(self, value: pulumi.Input[Sequence[pulumi.Input['DataSourceSalesforceKnowledgeArticleState']]]):
        pulumi.set(self, "included_states", value)

    @property
    @pulumi.getter(name="customKnowledgeArticleTypeConfigurations")
    def custom_knowledge_article_type_configurations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DataSourceSalesforceCustomKnowledgeArticleTypeConfigurationArgs']]]]:
        return pulumi.get(self, "custom_knowledge_article_type_configurations")

    @custom_knowledge_article_type_configurations.setter
    def custom_knowledge_article_type_configurations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DataSourceSalesforceCustomKnowledgeArticleTypeConfigurationArgs']]]]):
        pulumi.set(self, "custom_knowledge_article_type_configurations", value)

    @property
    @pulumi.getter(name="standardKnowledgeArticleTypeConfiguration")
    def standard_knowledge_article_type_configuration(self) -> Optional[pulumi.Input['DataSourceSalesforceStandardKnowledgeArticleTypeConfigurationArgs']]:
        return pulumi.get(self, "standard_knowledge_article_type_configuration")

    @standard_knowledge_article_type_configuration.setter
    def standard_knowledge_article_type_configuration(self, value: Optional[pulumi.Input['DataSourceSalesforceStandardKnowledgeArticleTypeConfigurationArgs']]):
        pulumi.set(self, "standard_knowledge_article_type_configuration", value)


@pulumi.input_type
class DataSourceSalesforceStandardKnowledgeArticleTypeConfigurationArgs:
    def __init__(__self__, *,
                 document_data_field_name: pulumi.Input[str],
                 document_title_field_name: Optional[pulumi.Input[str]] = None,
                 field_mappings: Optional[pulumi.Input[Sequence[pulumi.Input['DataSourceDataSourceToIndexFieldMappingArgs']]]] = None):
        pulumi.set(__self__, "document_data_field_name", document_data_field_name)
        if document_title_field_name is not None:
            pulumi.set(__self__, "document_title_field_name", document_title_field_name)
        if field_mappings is not None:
            pulumi.set(__self__, "field_mappings", field_mappings)

    @property
    @pulumi.getter(name="documentDataFieldName")
    def document_data_field_name(self) -> pulumi.Input[str]:
        return pulumi.get(self, "document_data_field_name")

    @document_data_field_name.setter
    def document_data_field_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "document_data_field_name", value)

    @property
    @pulumi.getter(name="documentTitleFieldName")
    def document_title_field_name(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "document_title_field_name")

    @document_title_field_name.setter
    def document_title_field_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "document_title_field_name", value)

    @property
    @pulumi.getter(name="fieldMappings")
    def field_mappings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DataSourceDataSourceToIndexFieldMappingArgs']]]]:
        return pulumi.get(self, "field_mappings")

    @field_mappings.setter
    def field_mappings(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DataSourceDataSourceToIndexFieldMappingArgs']]]]):
        pulumi.set(self, "field_mappings", value)


@pulumi.input_type
class DataSourceSalesforceStandardObjectAttachmentConfigurationArgs:
    def __init__(__self__, *,
                 document_title_field_name: Optional[pulumi.Input[str]] = None,
                 field_mappings: Optional[pulumi.Input[Sequence[pulumi.Input['DataSourceDataSourceToIndexFieldMappingArgs']]]] = None):
        if document_title_field_name is not None:
            pulumi.set(__self__, "document_title_field_name", document_title_field_name)
        if field_mappings is not None:
            pulumi.set(__self__, "field_mappings", field_mappings)

    @property
    @pulumi.getter(name="documentTitleFieldName")
    def document_title_field_name(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "document_title_field_name")

    @document_title_field_name.setter
    def document_title_field_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "document_title_field_name", value)

    @property
    @pulumi.getter(name="fieldMappings")
    def field_mappings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DataSourceDataSourceToIndexFieldMappingArgs']]]]:
        return pulumi.get(self, "field_mappings")

    @field_mappings.setter
    def field_mappings(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DataSourceDataSourceToIndexFieldMappingArgs']]]]):
        pulumi.set(self, "field_mappings", value)


@pulumi.input_type
class DataSourceSalesforceStandardObjectConfigurationArgs:
    def __init__(__self__, *,
                 document_data_field_name: pulumi.Input[str],
                 name: pulumi.Input['DataSourceSalesforceStandardObjectName'],
                 document_title_field_name: Optional[pulumi.Input[str]] = None,
                 field_mappings: Optional[pulumi.Input[Sequence[pulumi.Input['DataSourceDataSourceToIndexFieldMappingArgs']]]] = None):
        pulumi.set(__self__, "document_data_field_name", document_data_field_name)
        pulumi.set(__self__, "name", name)
        if document_title_field_name is not None:
            pulumi.set(__self__, "document_title_field_name", document_title_field_name)
        if field_mappings is not None:
            pulumi.set(__self__, "field_mappings", field_mappings)

    @property
    @pulumi.getter(name="documentDataFieldName")
    def document_data_field_name(self) -> pulumi.Input[str]:
        return pulumi.get(self, "document_data_field_name")

    @document_data_field_name.setter
    def document_data_field_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "document_data_field_name", value)

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input['DataSourceSalesforceStandardObjectName']:
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: pulumi.Input['DataSourceSalesforceStandardObjectName']):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter(name="documentTitleFieldName")
    def document_title_field_name(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "document_title_field_name")

    @document_title_field_name.setter
    def document_title_field_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "document_title_field_name", value)

    @property
    @pulumi.getter(name="fieldMappings")
    def field_mappings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DataSourceDataSourceToIndexFieldMappingArgs']]]]:
        return pulumi.get(self, "field_mappings")

    @field_mappings.setter
    def field_mappings(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DataSourceDataSourceToIndexFieldMappingArgs']]]]):
        pulumi.set(self, "field_mappings", value)


@pulumi.input_type
class DataSourceServiceNowConfigurationArgs:
    def __init__(__self__, *,
                 host_url: pulumi.Input[str],
                 secret_arn: pulumi.Input[str],
                 service_now_build_version: pulumi.Input['DataSourceServiceNowBuildVersionType'],
                 knowledge_article_configuration: Optional[pulumi.Input['DataSourceServiceNowKnowledgeArticleConfigurationArgs']] = None,
                 service_catalog_configuration: Optional[pulumi.Input['DataSourceServiceNowServiceCatalogConfigurationArgs']] = None):
        pulumi.set(__self__, "host_url", host_url)
        pulumi.set(__self__, "secret_arn", secret_arn)
        pulumi.set(__self__, "service_now_build_version", service_now_build_version)
        if knowledge_article_configuration is not None:
            pulumi.set(__self__, "knowledge_article_configuration", knowledge_article_configuration)
        if service_catalog_configuration is not None:
            pulumi.set(__self__, "service_catalog_configuration", service_catalog_configuration)

    @property
    @pulumi.getter(name="hostUrl")
    def host_url(self) -> pulumi.Input[str]:
        return pulumi.get(self, "host_url")

    @host_url.setter
    def host_url(self, value: pulumi.Input[str]):
        pulumi.set(self, "host_url", value)

    @property
    @pulumi.getter(name="secretArn")
    def secret_arn(self) -> pulumi.Input[str]:
        return pulumi.get(self, "secret_arn")

    @secret_arn.setter
    def secret_arn(self, value: pulumi.Input[str]):
        pulumi.set(self, "secret_arn", value)

    @property
    @pulumi.getter(name="serviceNowBuildVersion")
    def service_now_build_version(self) -> pulumi.Input['DataSourceServiceNowBuildVersionType']:
        return pulumi.get(self, "service_now_build_version")

    @service_now_build_version.setter
    def service_now_build_version(self, value: pulumi.Input['DataSourceServiceNowBuildVersionType']):
        pulumi.set(self, "service_now_build_version", value)

    @property
    @pulumi.getter(name="knowledgeArticleConfiguration")
    def knowledge_article_configuration(self) -> Optional[pulumi.Input['DataSourceServiceNowKnowledgeArticleConfigurationArgs']]:
        return pulumi.get(self, "knowledge_article_configuration")

    @knowledge_article_configuration.setter
    def knowledge_article_configuration(self, value: Optional[pulumi.Input['DataSourceServiceNowKnowledgeArticleConfigurationArgs']]):
        pulumi.set(self, "knowledge_article_configuration", value)

    @property
    @pulumi.getter(name="serviceCatalogConfiguration")
    def service_catalog_configuration(self) -> Optional[pulumi.Input['DataSourceServiceNowServiceCatalogConfigurationArgs']]:
        return pulumi.get(self, "service_catalog_configuration")

    @service_catalog_configuration.setter
    def service_catalog_configuration(self, value: Optional[pulumi.Input['DataSourceServiceNowServiceCatalogConfigurationArgs']]):
        pulumi.set(self, "service_catalog_configuration", value)


@pulumi.input_type
class DataSourceServiceNowKnowledgeArticleConfigurationArgs:
    def __init__(__self__, *,
                 document_data_field_name: pulumi.Input[str],
                 crawl_attachments: Optional[pulumi.Input[bool]] = None,
                 document_title_field_name: Optional[pulumi.Input[str]] = None,
                 exclude_attachment_file_patterns: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 field_mappings: Optional[pulumi.Input[Sequence[pulumi.Input['DataSourceDataSourceToIndexFieldMappingArgs']]]] = None,
                 include_attachment_file_patterns: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        pulumi.set(__self__, "document_data_field_name", document_data_field_name)
        if crawl_attachments is not None:
            pulumi.set(__self__, "crawl_attachments", crawl_attachments)
        if document_title_field_name is not None:
            pulumi.set(__self__, "document_title_field_name", document_title_field_name)
        if exclude_attachment_file_patterns is not None:
            pulumi.set(__self__, "exclude_attachment_file_patterns", exclude_attachment_file_patterns)
        if field_mappings is not None:
            pulumi.set(__self__, "field_mappings", field_mappings)
        if include_attachment_file_patterns is not None:
            pulumi.set(__self__, "include_attachment_file_patterns", include_attachment_file_patterns)

    @property
    @pulumi.getter(name="documentDataFieldName")
    def document_data_field_name(self) -> pulumi.Input[str]:
        return pulumi.get(self, "document_data_field_name")

    @document_data_field_name.setter
    def document_data_field_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "document_data_field_name", value)

    @property
    @pulumi.getter(name="crawlAttachments")
    def crawl_attachments(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "crawl_attachments")

    @crawl_attachments.setter
    def crawl_attachments(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "crawl_attachments", value)

    @property
    @pulumi.getter(name="documentTitleFieldName")
    def document_title_field_name(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "document_title_field_name")

    @document_title_field_name.setter
    def document_title_field_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "document_title_field_name", value)

    @property
    @pulumi.getter(name="excludeAttachmentFilePatterns")
    def exclude_attachment_file_patterns(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "exclude_attachment_file_patterns")

    @exclude_attachment_file_patterns.setter
    def exclude_attachment_file_patterns(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "exclude_attachment_file_patterns", value)

    @property
    @pulumi.getter(name="fieldMappings")
    def field_mappings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DataSourceDataSourceToIndexFieldMappingArgs']]]]:
        return pulumi.get(self, "field_mappings")

    @field_mappings.setter
    def field_mappings(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DataSourceDataSourceToIndexFieldMappingArgs']]]]):
        pulumi.set(self, "field_mappings", value)

    @property
    @pulumi.getter(name="includeAttachmentFilePatterns")
    def include_attachment_file_patterns(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "include_attachment_file_patterns")

    @include_attachment_file_patterns.setter
    def include_attachment_file_patterns(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "include_attachment_file_patterns", value)


@pulumi.input_type
class DataSourceServiceNowServiceCatalogConfigurationArgs:
    def __init__(__self__, *,
                 document_data_field_name: pulumi.Input[str],
                 crawl_attachments: Optional[pulumi.Input[bool]] = None,
                 document_title_field_name: Optional[pulumi.Input[str]] = None,
                 exclude_attachment_file_patterns: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 field_mappings: Optional[pulumi.Input[Sequence[pulumi.Input['DataSourceDataSourceToIndexFieldMappingArgs']]]] = None,
                 include_attachment_file_patterns: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        pulumi.set(__self__, "document_data_field_name", document_data_field_name)
        if crawl_attachments is not None:
            pulumi.set(__self__, "crawl_attachments", crawl_attachments)
        if document_title_field_name is not None:
            pulumi.set(__self__, "document_title_field_name", document_title_field_name)
        if exclude_attachment_file_patterns is not None:
            pulumi.set(__self__, "exclude_attachment_file_patterns", exclude_attachment_file_patterns)
        if field_mappings is not None:
            pulumi.set(__self__, "field_mappings", field_mappings)
        if include_attachment_file_patterns is not None:
            pulumi.set(__self__, "include_attachment_file_patterns", include_attachment_file_patterns)

    @property
    @pulumi.getter(name="documentDataFieldName")
    def document_data_field_name(self) -> pulumi.Input[str]:
        return pulumi.get(self, "document_data_field_name")

    @document_data_field_name.setter
    def document_data_field_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "document_data_field_name", value)

    @property
    @pulumi.getter(name="crawlAttachments")
    def crawl_attachments(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "crawl_attachments")

    @crawl_attachments.setter
    def crawl_attachments(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "crawl_attachments", value)

    @property
    @pulumi.getter(name="documentTitleFieldName")
    def document_title_field_name(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "document_title_field_name")

    @document_title_field_name.setter
    def document_title_field_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "document_title_field_name", value)

    @property
    @pulumi.getter(name="excludeAttachmentFilePatterns")
    def exclude_attachment_file_patterns(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "exclude_attachment_file_patterns")

    @exclude_attachment_file_patterns.setter
    def exclude_attachment_file_patterns(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "exclude_attachment_file_patterns", value)

    @property
    @pulumi.getter(name="fieldMappings")
    def field_mappings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DataSourceDataSourceToIndexFieldMappingArgs']]]]:
        return pulumi.get(self, "field_mappings")

    @field_mappings.setter
    def field_mappings(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DataSourceDataSourceToIndexFieldMappingArgs']]]]):
        pulumi.set(self, "field_mappings", value)

    @property
    @pulumi.getter(name="includeAttachmentFilePatterns")
    def include_attachment_file_patterns(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "include_attachment_file_patterns")

    @include_attachment_file_patterns.setter
    def include_attachment_file_patterns(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "include_attachment_file_patterns", value)


@pulumi.input_type
class DataSourceSharePointConfigurationArgs:
    def __init__(__self__, *,
                 secret_arn: pulumi.Input[str],
                 share_point_version: pulumi.Input['DataSourceSharePointConfigurationSharePointVersion'],
                 urls: pulumi.Input[Sequence[pulumi.Input[str]]],
                 crawl_attachments: Optional[pulumi.Input[bool]] = None,
                 disable_local_groups: Optional[pulumi.Input[bool]] = None,
                 document_title_field_name: Optional[pulumi.Input[str]] = None,
                 exclusion_patterns: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 field_mappings: Optional[pulumi.Input[Sequence[pulumi.Input['DataSourceDataSourceToIndexFieldMappingArgs']]]] = None,
                 inclusion_patterns: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 use_change_log: Optional[pulumi.Input[bool]] = None,
                 vpc_configuration: Optional[pulumi.Input['DataSourceDataSourceVpcConfigurationArgs']] = None):
        """
        SharePoint configuration
        """
        pulumi.set(__self__, "secret_arn", secret_arn)
        pulumi.set(__self__, "share_point_version", share_point_version)
        pulumi.set(__self__, "urls", urls)
        if crawl_attachments is not None:
            pulumi.set(__self__, "crawl_attachments", crawl_attachments)
        if disable_local_groups is not None:
            pulumi.set(__self__, "disable_local_groups", disable_local_groups)
        if document_title_field_name is not None:
            pulumi.set(__self__, "document_title_field_name", document_title_field_name)
        if exclusion_patterns is not None:
            pulumi.set(__self__, "exclusion_patterns", exclusion_patterns)
        if field_mappings is not None:
            pulumi.set(__self__, "field_mappings", field_mappings)
        if inclusion_patterns is not None:
            pulumi.set(__self__, "inclusion_patterns", inclusion_patterns)
        if use_change_log is not None:
            pulumi.set(__self__, "use_change_log", use_change_log)
        if vpc_configuration is not None:
            pulumi.set(__self__, "vpc_configuration", vpc_configuration)

    @property
    @pulumi.getter(name="secretArn")
    def secret_arn(self) -> pulumi.Input[str]:
        return pulumi.get(self, "secret_arn")

    @secret_arn.setter
    def secret_arn(self, value: pulumi.Input[str]):
        pulumi.set(self, "secret_arn", value)

    @property
    @pulumi.getter(name="sharePointVersion")
    def share_point_version(self) -> pulumi.Input['DataSourceSharePointConfigurationSharePointVersion']:
        return pulumi.get(self, "share_point_version")

    @share_point_version.setter
    def share_point_version(self, value: pulumi.Input['DataSourceSharePointConfigurationSharePointVersion']):
        pulumi.set(self, "share_point_version", value)

    @property
    @pulumi.getter
    def urls(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        return pulumi.get(self, "urls")

    @urls.setter
    def urls(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(self, "urls", value)

    @property
    @pulumi.getter(name="crawlAttachments")
    def crawl_attachments(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "crawl_attachments")

    @crawl_attachments.setter
    def crawl_attachments(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "crawl_attachments", value)

    @property
    @pulumi.getter(name="disableLocalGroups")
    def disable_local_groups(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "disable_local_groups")

    @disable_local_groups.setter
    def disable_local_groups(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "disable_local_groups", value)

    @property
    @pulumi.getter(name="documentTitleFieldName")
    def document_title_field_name(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "document_title_field_name")

    @document_title_field_name.setter
    def document_title_field_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "document_title_field_name", value)

    @property
    @pulumi.getter(name="exclusionPatterns")
    def exclusion_patterns(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "exclusion_patterns")

    @exclusion_patterns.setter
    def exclusion_patterns(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "exclusion_patterns", value)

    @property
    @pulumi.getter(name="fieldMappings")
    def field_mappings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DataSourceDataSourceToIndexFieldMappingArgs']]]]:
        return pulumi.get(self, "field_mappings")

    @field_mappings.setter
    def field_mappings(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DataSourceDataSourceToIndexFieldMappingArgs']]]]):
        pulumi.set(self, "field_mappings", value)

    @property
    @pulumi.getter(name="inclusionPatterns")
    def inclusion_patterns(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "inclusion_patterns")

    @inclusion_patterns.setter
    def inclusion_patterns(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "inclusion_patterns", value)

    @property
    @pulumi.getter(name="useChangeLog")
    def use_change_log(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "use_change_log")

    @use_change_log.setter
    def use_change_log(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "use_change_log", value)

    @property
    @pulumi.getter(name="vpcConfiguration")
    def vpc_configuration(self) -> Optional[pulumi.Input['DataSourceDataSourceVpcConfigurationArgs']]:
        return pulumi.get(self, "vpc_configuration")

    @vpc_configuration.setter
    def vpc_configuration(self, value: Optional[pulumi.Input['DataSourceDataSourceVpcConfigurationArgs']]):
        pulumi.set(self, "vpc_configuration", value)


@pulumi.input_type
class DataSourceSqlConfigurationArgs:
    def __init__(__self__, *,
                 query_identifiers_enclosing_option: Optional[pulumi.Input['DataSourceQueryIdentifiersEnclosingOption']] = None):
        if query_identifiers_enclosing_option is not None:
            pulumi.set(__self__, "query_identifiers_enclosing_option", query_identifiers_enclosing_option)

    @property
    @pulumi.getter(name="queryIdentifiersEnclosingOption")
    def query_identifiers_enclosing_option(self) -> Optional[pulumi.Input['DataSourceQueryIdentifiersEnclosingOption']]:
        return pulumi.get(self, "query_identifiers_enclosing_option")

    @query_identifiers_enclosing_option.setter
    def query_identifiers_enclosing_option(self, value: Optional[pulumi.Input['DataSourceQueryIdentifiersEnclosingOption']]):
        pulumi.set(self, "query_identifiers_enclosing_option", value)


@pulumi.input_type
class DataSourceTagArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 value: pulumi.Input[str]):
        """
        A label for tagging Kendra resources
        :param pulumi.Input[str] key: A string used to identify this tag
        :param pulumi.Input[str] value: A string containing the value for the tag
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> pulumi.Input[str]:
        """
        A string used to identify this tag
        """
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)

    @property
    @pulumi.getter
    def value(self) -> pulumi.Input[str]:
        """
        A string containing the value for the tag
        """
        return pulumi.get(self, "value")

    @value.setter
    def value(self, value: pulumi.Input[str]):
        pulumi.set(self, "value", value)


@pulumi.input_type
class FaqS3PathArgs:
    def __init__(__self__, *,
                 bucket: pulumi.Input[str],
                 key: pulumi.Input[str]):
        pulumi.set(__self__, "bucket", bucket)
        pulumi.set(__self__, "key", key)

    @property
    @pulumi.getter
    def bucket(self) -> pulumi.Input[str]:
        return pulumi.get(self, "bucket")

    @bucket.setter
    def bucket(self, value: pulumi.Input[str]):
        pulumi.set(self, "bucket", value)

    @property
    @pulumi.getter
    def key(self) -> pulumi.Input[str]:
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)


@pulumi.input_type
class FaqTagArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 value: pulumi.Input[str]):
        """
        A label for tagging Kendra resources
        :param pulumi.Input[str] key: A string used to identify this tag
        :param pulumi.Input[str] value: A string containing the value for the tag
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> pulumi.Input[str]:
        """
        A string used to identify this tag
        """
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)

    @property
    @pulumi.getter
    def value(self) -> pulumi.Input[str]:
        """
        A string containing the value for the tag
        """
        return pulumi.get(self, "value")

    @value.setter
    def value(self, value: pulumi.Input[str]):
        pulumi.set(self, "value", value)


@pulumi.input_type
class IndexCapacityUnitsConfigurationArgs:
    def __init__(__self__, *,
                 query_capacity_units: pulumi.Input[int],
                 storage_capacity_units: pulumi.Input[int]):
        pulumi.set(__self__, "query_capacity_units", query_capacity_units)
        pulumi.set(__self__, "storage_capacity_units", storage_capacity_units)

    @property
    @pulumi.getter(name="queryCapacityUnits")
    def query_capacity_units(self) -> pulumi.Input[int]:
        return pulumi.get(self, "query_capacity_units")

    @query_capacity_units.setter
    def query_capacity_units(self, value: pulumi.Input[int]):
        pulumi.set(self, "query_capacity_units", value)

    @property
    @pulumi.getter(name="storageCapacityUnits")
    def storage_capacity_units(self) -> pulumi.Input[int]:
        return pulumi.get(self, "storage_capacity_units")

    @storage_capacity_units.setter
    def storage_capacity_units(self, value: pulumi.Input[int]):
        pulumi.set(self, "storage_capacity_units", value)


@pulumi.input_type
class IndexDocumentMetadataConfigurationArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 type: pulumi.Input['IndexDocumentAttributeValueType'],
                 relevance: Optional[pulumi.Input['IndexRelevanceArgs']] = None,
                 search: Optional[pulumi.Input['IndexSearchArgs']] = None):
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "type", type)
        if relevance is not None:
            pulumi.set(__self__, "relevance", relevance)
        if search is not None:
            pulumi.set(__self__, "search", search)

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: pulumi.Input[str]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter
    def type(self) -> pulumi.Input['IndexDocumentAttributeValueType']:
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: pulumi.Input['IndexDocumentAttributeValueType']):
        pulumi.set(self, "type", value)

    @property
    @pulumi.getter
    def relevance(self) -> Optional[pulumi.Input['IndexRelevanceArgs']]:
        return pulumi.get(self, "relevance")

    @relevance.setter
    def relevance(self, value: Optional[pulumi.Input['IndexRelevanceArgs']]):
        pulumi.set(self, "relevance", value)

    @property
    @pulumi.getter
    def search(self) -> Optional[pulumi.Input['IndexSearchArgs']]:
        return pulumi.get(self, "search")

    @search.setter
    def search(self, value: Optional[pulumi.Input['IndexSearchArgs']]):
        pulumi.set(self, "search", value)


@pulumi.input_type
class IndexJsonTokenTypeConfigurationArgs:
    def __init__(__self__, *,
                 group_attribute_field: pulumi.Input[str],
                 user_name_attribute_field: pulumi.Input[str]):
        pulumi.set(__self__, "group_attribute_field", group_attribute_field)
        pulumi.set(__self__, "user_name_attribute_field", user_name_attribute_field)

    @property
    @pulumi.getter(name="groupAttributeField")
    def group_attribute_field(self) -> pulumi.Input[str]:
        return pulumi.get(self, "group_attribute_field")

    @group_attribute_field.setter
    def group_attribute_field(self, value: pulumi.Input[str]):
        pulumi.set(self, "group_attribute_field", value)

    @property
    @pulumi.getter(name="userNameAttributeField")
    def user_name_attribute_field(self) -> pulumi.Input[str]:
        return pulumi.get(self, "user_name_attribute_field")

    @user_name_attribute_field.setter
    def user_name_attribute_field(self, value: pulumi.Input[str]):
        pulumi.set(self, "user_name_attribute_field", value)


@pulumi.input_type
class IndexJwtTokenTypeConfigurationArgs:
    def __init__(__self__, *,
                 key_location: pulumi.Input['IndexKeyLocation'],
                 claim_regex: Optional[pulumi.Input[str]] = None,
                 group_attribute_field: Optional[pulumi.Input[str]] = None,
                 issuer: Optional[pulumi.Input[str]] = None,
                 secret_manager_arn: Optional[pulumi.Input[str]] = None,
                 u_rl: Optional[pulumi.Input[str]] = None,
                 user_name_attribute_field: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "key_location", key_location)
        if claim_regex is not None:
            pulumi.set(__self__, "claim_regex", claim_regex)
        if group_attribute_field is not None:
            pulumi.set(__self__, "group_attribute_field", group_attribute_field)
        if issuer is not None:
            pulumi.set(__self__, "issuer", issuer)
        if secret_manager_arn is not None:
            pulumi.set(__self__, "secret_manager_arn", secret_manager_arn)
        if u_rl is not None:
            pulumi.set(__self__, "u_rl", u_rl)
        if user_name_attribute_field is not None:
            pulumi.set(__self__, "user_name_attribute_field", user_name_attribute_field)

    @property
    @pulumi.getter(name="keyLocation")
    def key_location(self) -> pulumi.Input['IndexKeyLocation']:
        return pulumi.get(self, "key_location")

    @key_location.setter
    def key_location(self, value: pulumi.Input['IndexKeyLocation']):
        pulumi.set(self, "key_location", value)

    @property
    @pulumi.getter(name="claimRegex")
    def claim_regex(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "claim_regex")

    @claim_regex.setter
    def claim_regex(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "claim_regex", value)

    @property
    @pulumi.getter(name="groupAttributeField")
    def group_attribute_field(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "group_attribute_field")

    @group_attribute_field.setter
    def group_attribute_field(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "group_attribute_field", value)

    @property
    @pulumi.getter
    def issuer(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "issuer")

    @issuer.setter
    def issuer(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "issuer", value)

    @property
    @pulumi.getter(name="secretManagerArn")
    def secret_manager_arn(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "secret_manager_arn")

    @secret_manager_arn.setter
    def secret_manager_arn(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "secret_manager_arn", value)

    @property
    @pulumi.getter(name="uRL")
    def u_rl(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "u_rl")

    @u_rl.setter
    def u_rl(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "u_rl", value)

    @property
    @pulumi.getter(name="userNameAttributeField")
    def user_name_attribute_field(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "user_name_attribute_field")

    @user_name_attribute_field.setter
    def user_name_attribute_field(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "user_name_attribute_field", value)


@pulumi.input_type
class IndexRelevanceArgs:
    def __init__(__self__, *,
                 duration: Optional[pulumi.Input[str]] = None,
                 freshness: Optional[pulumi.Input[bool]] = None,
                 importance: Optional[pulumi.Input[int]] = None,
                 rank_order: Optional[pulumi.Input['IndexOrder']] = None,
                 value_importance_items: Optional[pulumi.Input[Sequence[pulumi.Input['IndexValueImportanceItemArgs']]]] = None):
        if duration is not None:
            pulumi.set(__self__, "duration", duration)
        if freshness is not None:
            pulumi.set(__self__, "freshness", freshness)
        if importance is not None:
            pulumi.set(__self__, "importance", importance)
        if rank_order is not None:
            pulumi.set(__self__, "rank_order", rank_order)
        if value_importance_items is not None:
            pulumi.set(__self__, "value_importance_items", value_importance_items)

    @property
    @pulumi.getter
    def duration(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "duration")

    @duration.setter
    def duration(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "duration", value)

    @property
    @pulumi.getter
    def freshness(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "freshness")

    @freshness.setter
    def freshness(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "freshness", value)

    @property
    @pulumi.getter
    def importance(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "importance")

    @importance.setter
    def importance(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "importance", value)

    @property
    @pulumi.getter(name="rankOrder")
    def rank_order(self) -> Optional[pulumi.Input['IndexOrder']]:
        return pulumi.get(self, "rank_order")

    @rank_order.setter
    def rank_order(self, value: Optional[pulumi.Input['IndexOrder']]):
        pulumi.set(self, "rank_order", value)

    @property
    @pulumi.getter(name="valueImportanceItems")
    def value_importance_items(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['IndexValueImportanceItemArgs']]]]:
        return pulumi.get(self, "value_importance_items")

    @value_importance_items.setter
    def value_importance_items(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['IndexValueImportanceItemArgs']]]]):
        pulumi.set(self, "value_importance_items", value)


@pulumi.input_type
class IndexSearchArgs:
    def __init__(__self__, *,
                 displayable: Optional[pulumi.Input[bool]] = None,
                 facetable: Optional[pulumi.Input[bool]] = None,
                 searchable: Optional[pulumi.Input[bool]] = None,
                 sortable: Optional[pulumi.Input[bool]] = None):
        if displayable is not None:
            pulumi.set(__self__, "displayable", displayable)
        if facetable is not None:
            pulumi.set(__self__, "facetable", facetable)
        if searchable is not None:
            pulumi.set(__self__, "searchable", searchable)
        if sortable is not None:
            pulumi.set(__self__, "sortable", sortable)

    @property
    @pulumi.getter
    def displayable(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "displayable")

    @displayable.setter
    def displayable(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "displayable", value)

    @property
    @pulumi.getter
    def facetable(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "facetable")

    @facetable.setter
    def facetable(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "facetable", value)

    @property
    @pulumi.getter
    def searchable(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "searchable")

    @searchable.setter
    def searchable(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "searchable", value)

    @property
    @pulumi.getter
    def sortable(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "sortable")

    @sortable.setter
    def sortable(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "sortable", value)


@pulumi.input_type
class IndexServerSideEncryptionConfigurationArgs:
    def __init__(__self__, *,
                 kms_key_id: Optional[pulumi.Input[str]] = None):
        if kms_key_id is not None:
            pulumi.set(__self__, "kms_key_id", kms_key_id)

    @property
    @pulumi.getter(name="kmsKeyId")
    def kms_key_id(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "kms_key_id")

    @kms_key_id.setter
    def kms_key_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "kms_key_id", value)


@pulumi.input_type
class IndexTagArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 value: pulumi.Input[str]):
        """
        A label for tagging Kendra resources
        :param pulumi.Input[str] key: A string used to identify this tag
        :param pulumi.Input[str] value: A string containing the value for the tag
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> pulumi.Input[str]:
        """
        A string used to identify this tag
        """
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)

    @property
    @pulumi.getter
    def value(self) -> pulumi.Input[str]:
        """
        A string containing the value for the tag
        """
        return pulumi.get(self, "value")

    @value.setter
    def value(self, value: pulumi.Input[str]):
        pulumi.set(self, "value", value)


@pulumi.input_type
class IndexUserTokenConfigurationArgs:
    def __init__(__self__, *,
                 json_token_type_configuration: Optional[pulumi.Input['IndexJsonTokenTypeConfigurationArgs']] = None,
                 jwt_token_type_configuration: Optional[pulumi.Input['IndexJwtTokenTypeConfigurationArgs']] = None):
        if json_token_type_configuration is not None:
            pulumi.set(__self__, "json_token_type_configuration", json_token_type_configuration)
        if jwt_token_type_configuration is not None:
            pulumi.set(__self__, "jwt_token_type_configuration", jwt_token_type_configuration)

    @property
    @pulumi.getter(name="jsonTokenTypeConfiguration")
    def json_token_type_configuration(self) -> Optional[pulumi.Input['IndexJsonTokenTypeConfigurationArgs']]:
        return pulumi.get(self, "json_token_type_configuration")

    @json_token_type_configuration.setter
    def json_token_type_configuration(self, value: Optional[pulumi.Input['IndexJsonTokenTypeConfigurationArgs']]):
        pulumi.set(self, "json_token_type_configuration", value)

    @property
    @pulumi.getter(name="jwtTokenTypeConfiguration")
    def jwt_token_type_configuration(self) -> Optional[pulumi.Input['IndexJwtTokenTypeConfigurationArgs']]:
        return pulumi.get(self, "jwt_token_type_configuration")

    @jwt_token_type_configuration.setter
    def jwt_token_type_configuration(self, value: Optional[pulumi.Input['IndexJwtTokenTypeConfigurationArgs']]):
        pulumi.set(self, "jwt_token_type_configuration", value)


@pulumi.input_type
class IndexValueImportanceItemArgs:
    def __init__(__self__, *,
                 key: Optional[pulumi.Input[str]] = None,
                 value: Optional[pulumi.Input[int]] = None):
        if key is not None:
            pulumi.set(__self__, "key", key)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "key", value)

    @property
    @pulumi.getter
    def value(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "value")

    @value.setter
    def value(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "value", value)


