# 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 . import outputs
from ._enums import *

__all__ = [
    'DataSourceAccessControlListConfiguration',
    'DataSourceAclConfiguration',
    'DataSourceColumnConfiguration',
    'DataSourceConfluenceAttachmentConfiguration',
    'DataSourceConfluenceAttachmentToIndexFieldMapping',
    'DataSourceConfluenceBlogConfiguration',
    'DataSourceConfluenceBlogToIndexFieldMapping',
    'DataSourceConfluenceConfiguration',
    'DataSourceConfluencePageConfiguration',
    'DataSourceConfluencePageToIndexFieldMapping',
    'DataSourceConfluenceSpaceConfiguration',
    'DataSourceConfluenceSpaceToIndexFieldMapping',
    'DataSourceConnectionConfiguration',
    'DataSourceDataSourceConfiguration',
    'DataSourceDataSourceToIndexFieldMapping',
    'DataSourceDataSourceVpcConfiguration',
    'DataSourceDatabaseConfiguration',
    'DataSourceDocumentsMetadataConfiguration',
    'DataSourceGoogleDriveConfiguration',
    'DataSourceOneDriveConfiguration',
    'DataSourceOneDriveUsers',
    'DataSourceS3DataSourceConfiguration',
    'DataSourceS3Path',
    'DataSourceSalesforceChatterFeedConfiguration',
    'DataSourceSalesforceConfiguration',
    'DataSourceSalesforceCustomKnowledgeArticleTypeConfiguration',
    'DataSourceSalesforceKnowledgeArticleConfiguration',
    'DataSourceSalesforceStandardKnowledgeArticleTypeConfiguration',
    'DataSourceSalesforceStandardObjectAttachmentConfiguration',
    'DataSourceSalesforceStandardObjectConfiguration',
    'DataSourceServiceNowConfiguration',
    'DataSourceServiceNowKnowledgeArticleConfiguration',
    'DataSourceServiceNowServiceCatalogConfiguration',
    'DataSourceSharePointConfiguration',
    'DataSourceSqlConfiguration',
    'DataSourceTag',
    'FaqS3Path',
    'FaqTag',
    'IndexCapacityUnitsConfiguration',
    'IndexDocumentMetadataConfiguration',
    'IndexJsonTokenTypeConfiguration',
    'IndexJwtTokenTypeConfiguration',
    'IndexRelevance',
    'IndexSearch',
    'IndexServerSideEncryptionConfiguration',
    'IndexTag',
    'IndexUserTokenConfiguration',
    'IndexValueImportanceItem',
]

@pulumi.output_type
class DataSourceAccessControlListConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "keyPath":
            suggest = "key_path"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DataSourceAccessControlListConfiguration. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DataSourceAccessControlListConfiguration.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DataSourceAccessControlListConfiguration.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 key_path: Optional[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[str]:
        return pulumi.get(self, "key_path")


@pulumi.output_type
class DataSourceAclConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "allowedGroupsColumnName":
            suggest = "allowed_groups_column_name"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DataSourceAclConfiguration. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DataSourceAclConfiguration.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DataSourceAclConfiguration.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 allowed_groups_column_name: str):
        pulumi.set(__self__, "allowed_groups_column_name", allowed_groups_column_name)

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


@pulumi.output_type
class DataSourceColumnConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "changeDetectingColumns":
            suggest = "change_detecting_columns"
        elif key == "documentDataColumnName":
            suggest = "document_data_column_name"
        elif key == "documentIdColumnName":
            suggest = "document_id_column_name"
        elif key == "documentTitleColumnName":
            suggest = "document_title_column_name"
        elif key == "fieldMappings":
            suggest = "field_mappings"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DataSourceColumnConfiguration. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DataSourceColumnConfiguration.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DataSourceColumnConfiguration.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 change_detecting_columns: Sequence[str],
                 document_data_column_name: str,
                 document_id_column_name: str,
                 document_title_column_name: Optional[str] = None,
                 field_mappings: Optional[Sequence['outputs.DataSourceDataSourceToIndexFieldMapping']] = 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) -> Sequence[str]:
        return pulumi.get(self, "change_detecting_columns")

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

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

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

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


@pulumi.output_type
class DataSourceConfluenceAttachmentConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "attachmentFieldMappings":
            suggest = "attachment_field_mappings"
        elif key == "crawlAttachments":
            suggest = "crawl_attachments"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DataSourceConfluenceAttachmentConfiguration. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DataSourceConfluenceAttachmentConfiguration.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DataSourceConfluenceAttachmentConfiguration.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 attachment_field_mappings: Optional[Sequence['outputs.DataSourceConfluenceAttachmentToIndexFieldMapping']] = None,
                 crawl_attachments: Optional[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[Sequence['outputs.DataSourceConfluenceAttachmentToIndexFieldMapping']]:
        return pulumi.get(self, "attachment_field_mappings")

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


@pulumi.output_type
class DataSourceConfluenceAttachmentToIndexFieldMapping(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "dataSourceFieldName":
            suggest = "data_source_field_name"
        elif key == "indexFieldName":
            suggest = "index_field_name"
        elif key == "dateFieldFormat":
            suggest = "date_field_format"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DataSourceConfluenceAttachmentToIndexFieldMapping. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DataSourceConfluenceAttachmentToIndexFieldMapping.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DataSourceConfluenceAttachmentToIndexFieldMapping.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 data_source_field_name: 'DataSourceConfluenceAttachmentFieldName',
                 index_field_name: str,
                 date_field_format: Optional[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) -> 'DataSourceConfluenceAttachmentFieldName':
        return pulumi.get(self, "data_source_field_name")

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

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


@pulumi.output_type
class DataSourceConfluenceBlogConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "blogFieldMappings":
            suggest = "blog_field_mappings"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DataSourceConfluenceBlogConfiguration. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DataSourceConfluenceBlogConfiguration.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DataSourceConfluenceBlogConfiguration.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 blog_field_mappings: Optional[Sequence['outputs.DataSourceConfluenceBlogToIndexFieldMapping']] = 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[Sequence['outputs.DataSourceConfluenceBlogToIndexFieldMapping']]:
        return pulumi.get(self, "blog_field_mappings")


@pulumi.output_type
class DataSourceConfluenceBlogToIndexFieldMapping(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "dataSourceFieldName":
            suggest = "data_source_field_name"
        elif key == "indexFieldName":
            suggest = "index_field_name"
        elif key == "dateFieldFormat":
            suggest = "date_field_format"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DataSourceConfluenceBlogToIndexFieldMapping. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DataSourceConfluenceBlogToIndexFieldMapping.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DataSourceConfluenceBlogToIndexFieldMapping.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 data_source_field_name: 'DataSourceConfluenceBlogFieldName',
                 index_field_name: str,
                 date_field_format: Optional[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) -> 'DataSourceConfluenceBlogFieldName':
        return pulumi.get(self, "data_source_field_name")

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

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


@pulumi.output_type
class DataSourceConfluenceConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "secretArn":
            suggest = "secret_arn"
        elif key == "serverUrl":
            suggest = "server_url"
        elif key == "attachmentConfiguration":
            suggest = "attachment_configuration"
        elif key == "blogConfiguration":
            suggest = "blog_configuration"
        elif key == "exclusionPatterns":
            suggest = "exclusion_patterns"
        elif key == "inclusionPatterns":
            suggest = "inclusion_patterns"
        elif key == "pageConfiguration":
            suggest = "page_configuration"
        elif key == "spaceConfiguration":
            suggest = "space_configuration"
        elif key == "vpcConfiguration":
            suggest = "vpc_configuration"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DataSourceConfluenceConfiguration. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DataSourceConfluenceConfiguration.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DataSourceConfluenceConfiguration.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 secret_arn: str,
                 server_url: str,
                 version: 'DataSourceConfluenceVersion',
                 attachment_configuration: Optional['outputs.DataSourceConfluenceAttachmentConfiguration'] = None,
                 blog_configuration: Optional['outputs.DataSourceConfluenceBlogConfiguration'] = None,
                 exclusion_patterns: Optional[Sequence[str]] = None,
                 inclusion_patterns: Optional[Sequence[str]] = None,
                 page_configuration: Optional['outputs.DataSourceConfluencePageConfiguration'] = None,
                 space_configuration: Optional['outputs.DataSourceConfluenceSpaceConfiguration'] = None,
                 vpc_configuration: Optional['outputs.DataSourceDataSourceVpcConfiguration'] = 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) -> str:
        return pulumi.get(self, "secret_arn")

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

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

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

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

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

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

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

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

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


@pulumi.output_type
class DataSourceConfluencePageConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "pageFieldMappings":
            suggest = "page_field_mappings"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DataSourceConfluencePageConfiguration. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DataSourceConfluencePageConfiguration.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DataSourceConfluencePageConfiguration.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 page_field_mappings: Optional[Sequence['outputs.DataSourceConfluencePageToIndexFieldMapping']] = 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[Sequence['outputs.DataSourceConfluencePageToIndexFieldMapping']]:
        return pulumi.get(self, "page_field_mappings")


@pulumi.output_type
class DataSourceConfluencePageToIndexFieldMapping(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "dataSourceFieldName":
            suggest = "data_source_field_name"
        elif key == "indexFieldName":
            suggest = "index_field_name"
        elif key == "dateFieldFormat":
            suggest = "date_field_format"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DataSourceConfluencePageToIndexFieldMapping. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DataSourceConfluencePageToIndexFieldMapping.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DataSourceConfluencePageToIndexFieldMapping.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 data_source_field_name: 'DataSourceConfluencePageFieldName',
                 index_field_name: str,
                 date_field_format: Optional[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) -> 'DataSourceConfluencePageFieldName':
        return pulumi.get(self, "data_source_field_name")

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

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


@pulumi.output_type
class DataSourceConfluenceSpaceConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "crawlArchivedSpaces":
            suggest = "crawl_archived_spaces"
        elif key == "crawlPersonalSpaces":
            suggest = "crawl_personal_spaces"
        elif key == "excludeSpaces":
            suggest = "exclude_spaces"
        elif key == "includeSpaces":
            suggest = "include_spaces"
        elif key == "spaceFieldMappings":
            suggest = "space_field_mappings"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DataSourceConfluenceSpaceConfiguration. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DataSourceConfluenceSpaceConfiguration.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DataSourceConfluenceSpaceConfiguration.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 crawl_archived_spaces: Optional[bool] = None,
                 crawl_personal_spaces: Optional[bool] = None,
                 exclude_spaces: Optional[Sequence[str]] = None,
                 include_spaces: Optional[Sequence[str]] = None,
                 space_field_mappings: Optional[Sequence['outputs.DataSourceConfluenceSpaceToIndexFieldMapping']] = 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[bool]:
        return pulumi.get(self, "crawl_archived_spaces")

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

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

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

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


@pulumi.output_type
class DataSourceConfluenceSpaceToIndexFieldMapping(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "dataSourceFieldName":
            suggest = "data_source_field_name"
        elif key == "indexFieldName":
            suggest = "index_field_name"
        elif key == "dateFieldFormat":
            suggest = "date_field_format"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DataSourceConfluenceSpaceToIndexFieldMapping. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DataSourceConfluenceSpaceToIndexFieldMapping.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DataSourceConfluenceSpaceToIndexFieldMapping.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 data_source_field_name: 'DataSourceConfluenceSpaceFieldName',
                 index_field_name: str,
                 date_field_format: Optional[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) -> 'DataSourceConfluenceSpaceFieldName':
        return pulumi.get(self, "data_source_field_name")

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

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


@pulumi.output_type
class DataSourceConnectionConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "databaseHost":
            suggest = "database_host"
        elif key == "databaseName":
            suggest = "database_name"
        elif key == "databasePort":
            suggest = "database_port"
        elif key == "secretArn":
            suggest = "secret_arn"
        elif key == "tableName":
            suggest = "table_name"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DataSourceConnectionConfiguration. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DataSourceConnectionConfiguration.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DataSourceConnectionConfiguration.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 database_host: str,
                 database_name: str,
                 database_port: int,
                 secret_arn: str,
                 table_name: 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) -> str:
        return pulumi.get(self, "database_host")

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

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

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

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


@pulumi.output_type
class DataSourceDataSourceConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "confluenceConfiguration":
            suggest = "confluence_configuration"
        elif key == "databaseConfiguration":
            suggest = "database_configuration"
        elif key == "googleDriveConfiguration":
            suggest = "google_drive_configuration"
        elif key == "oneDriveConfiguration":
            suggest = "one_drive_configuration"
        elif key == "s3Configuration":
            suggest = "s3_configuration"
        elif key == "salesforceConfiguration":
            suggest = "salesforce_configuration"
        elif key == "serviceNowConfiguration":
            suggest = "service_now_configuration"
        elif key == "sharePointConfiguration":
            suggest = "share_point_configuration"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DataSourceDataSourceConfiguration. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DataSourceDataSourceConfiguration.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DataSourceDataSourceConfiguration.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 confluence_configuration: Optional['outputs.DataSourceConfluenceConfiguration'] = None,
                 database_configuration: Optional['outputs.DataSourceDatabaseConfiguration'] = None,
                 google_drive_configuration: Optional['outputs.DataSourceGoogleDriveConfiguration'] = None,
                 one_drive_configuration: Optional['outputs.DataSourceOneDriveConfiguration'] = None,
                 s3_configuration: Optional['outputs.DataSourceS3DataSourceConfiguration'] = None,
                 salesforce_configuration: Optional['outputs.DataSourceSalesforceConfiguration'] = None,
                 service_now_configuration: Optional['outputs.DataSourceServiceNowConfiguration'] = None,
                 share_point_configuration: Optional['outputs.DataSourceSharePointConfiguration'] = 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['outputs.DataSourceConfluenceConfiguration']:
        return pulumi.get(self, "confluence_configuration")

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

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

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

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

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

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

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


@pulumi.output_type
class DataSourceDataSourceToIndexFieldMapping(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "dataSourceFieldName":
            suggest = "data_source_field_name"
        elif key == "indexFieldName":
            suggest = "index_field_name"
        elif key == "dateFieldFormat":
            suggest = "date_field_format"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DataSourceDataSourceToIndexFieldMapping. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DataSourceDataSourceToIndexFieldMapping.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DataSourceDataSourceToIndexFieldMapping.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 data_source_field_name: str,
                 index_field_name: str,
                 date_field_format: Optional[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) -> str:
        return pulumi.get(self, "data_source_field_name")

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

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


@pulumi.output_type
class DataSourceDataSourceVpcConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "securityGroupIds":
            suggest = "security_group_ids"
        elif key == "subnetIds":
            suggest = "subnet_ids"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DataSourceDataSourceVpcConfiguration. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DataSourceDataSourceVpcConfiguration.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DataSourceDataSourceVpcConfiguration.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 security_group_ids: Sequence[str],
                 subnet_ids: Sequence[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) -> Sequence[str]:
        return pulumi.get(self, "security_group_ids")

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


@pulumi.output_type
class DataSourceDatabaseConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "columnConfiguration":
            suggest = "column_configuration"
        elif key == "connectionConfiguration":
            suggest = "connection_configuration"
        elif key == "databaseEngineType":
            suggest = "database_engine_type"
        elif key == "aclConfiguration":
            suggest = "acl_configuration"
        elif key == "sqlConfiguration":
            suggest = "sql_configuration"
        elif key == "vpcConfiguration":
            suggest = "vpc_configuration"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DataSourceDatabaseConfiguration. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DataSourceDatabaseConfiguration.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DataSourceDatabaseConfiguration.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 column_configuration: 'outputs.DataSourceColumnConfiguration',
                 connection_configuration: 'outputs.DataSourceConnectionConfiguration',
                 database_engine_type: 'DataSourceDatabaseEngineType',
                 acl_configuration: Optional['outputs.DataSourceAclConfiguration'] = None,
                 sql_configuration: Optional['outputs.DataSourceSqlConfiguration'] = None,
                 vpc_configuration: Optional['outputs.DataSourceDataSourceVpcConfiguration'] = 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) -> 'outputs.DataSourceColumnConfiguration':
        return pulumi.get(self, "column_configuration")

    @property
    @pulumi.getter(name="connectionConfiguration")
    def connection_configuration(self) -> 'outputs.DataSourceConnectionConfiguration':
        return pulumi.get(self, "connection_configuration")

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

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

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

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


@pulumi.output_type
class DataSourceDocumentsMetadataConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "s3Prefix":
            suggest = "s3_prefix"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DataSourceDocumentsMetadataConfiguration. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DataSourceDocumentsMetadataConfiguration.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DataSourceDocumentsMetadataConfiguration.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 s3_prefix: Optional[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[str]:
        return pulumi.get(self, "s3_prefix")


@pulumi.output_type
class DataSourceGoogleDriveConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "secretArn":
            suggest = "secret_arn"
        elif key == "excludeMimeTypes":
            suggest = "exclude_mime_types"
        elif key == "excludeSharedDrives":
            suggest = "exclude_shared_drives"
        elif key == "excludeUserAccounts":
            suggest = "exclude_user_accounts"
        elif key == "exclusionPatterns":
            suggest = "exclusion_patterns"
        elif key == "fieldMappings":
            suggest = "field_mappings"
        elif key == "inclusionPatterns":
            suggest = "inclusion_patterns"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DataSourceGoogleDriveConfiguration. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DataSourceGoogleDriveConfiguration.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DataSourceGoogleDriveConfiguration.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 secret_arn: str,
                 exclude_mime_types: Optional[Sequence[str]] = None,
                 exclude_shared_drives: Optional[Sequence[str]] = None,
                 exclude_user_accounts: Optional[Sequence[str]] = None,
                 exclusion_patterns: Optional[Sequence[str]] = None,
                 field_mappings: Optional[Sequence['outputs.DataSourceDataSourceToIndexFieldMapping']] = None,
                 inclusion_patterns: Optional[Sequence[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) -> str:
        return pulumi.get(self, "secret_arn")

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

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

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

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

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

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


@pulumi.output_type
class DataSourceOneDriveConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "oneDriveUsers":
            suggest = "one_drive_users"
        elif key == "secretArn":
            suggest = "secret_arn"
        elif key == "tenantDomain":
            suggest = "tenant_domain"
        elif key == "disableLocalGroups":
            suggest = "disable_local_groups"
        elif key == "exclusionPatterns":
            suggest = "exclusion_patterns"
        elif key == "fieldMappings":
            suggest = "field_mappings"
        elif key == "inclusionPatterns":
            suggest = "inclusion_patterns"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DataSourceOneDriveConfiguration. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DataSourceOneDriveConfiguration.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DataSourceOneDriveConfiguration.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 one_drive_users: 'outputs.DataSourceOneDriveUsers',
                 secret_arn: str,
                 tenant_domain: str,
                 disable_local_groups: Optional[bool] = None,
                 exclusion_patterns: Optional[Sequence[str]] = None,
                 field_mappings: Optional[Sequence['outputs.DataSourceDataSourceToIndexFieldMapping']] = None,
                 inclusion_patterns: Optional[Sequence[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) -> 'outputs.DataSourceOneDriveUsers':
        return pulumi.get(self, "one_drive_users")

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

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

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

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

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

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


@pulumi.output_type
class DataSourceOneDriveUsers(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "oneDriveUserList":
            suggest = "one_drive_user_list"
        elif key == "oneDriveUserS3Path":
            suggest = "one_drive_user_s3_path"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DataSourceOneDriveUsers. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DataSourceOneDriveUsers.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DataSourceOneDriveUsers.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 one_drive_user_list: Optional[Sequence[str]] = None,
                 one_drive_user_s3_path: Optional['outputs.DataSourceS3Path'] = 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[Sequence[str]]:
        return pulumi.get(self, "one_drive_user_list")

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


@pulumi.output_type
class DataSourceS3DataSourceConfiguration(dict):
    """
    S3 data source configuration
    """
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "bucketName":
            suggest = "bucket_name"
        elif key == "accessControlListConfiguration":
            suggest = "access_control_list_configuration"
        elif key == "documentsMetadataConfiguration":
            suggest = "documents_metadata_configuration"
        elif key == "exclusionPatterns":
            suggest = "exclusion_patterns"
        elif key == "inclusionPatterns":
            suggest = "inclusion_patterns"
        elif key == "inclusionPrefixes":
            suggest = "inclusion_prefixes"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DataSourceS3DataSourceConfiguration. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DataSourceS3DataSourceConfiguration.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DataSourceS3DataSourceConfiguration.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 bucket_name: str,
                 access_control_list_configuration: Optional['outputs.DataSourceAccessControlListConfiguration'] = None,
                 documents_metadata_configuration: Optional['outputs.DataSourceDocumentsMetadataConfiguration'] = None,
                 exclusion_patterns: Optional[Sequence[str]] = None,
                 inclusion_patterns: Optional[Sequence[str]] = None,
                 inclusion_prefixes: Optional[Sequence[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) -> str:
        return pulumi.get(self, "bucket_name")

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

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

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

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

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


@pulumi.output_type
class DataSourceS3Path(dict):
    def __init__(__self__, *,
                 bucket: str,
                 key: str):
        pulumi.set(__self__, "bucket", bucket)
        pulumi.set(__self__, "key", key)

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

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


@pulumi.output_type
class DataSourceSalesforceChatterFeedConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "documentDataFieldName":
            suggest = "document_data_field_name"
        elif key == "documentTitleFieldName":
            suggest = "document_title_field_name"
        elif key == "fieldMappings":
            suggest = "field_mappings"
        elif key == "includeFilterTypes":
            suggest = "include_filter_types"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DataSourceSalesforceChatterFeedConfiguration. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DataSourceSalesforceChatterFeedConfiguration.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DataSourceSalesforceChatterFeedConfiguration.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 document_data_field_name: str,
                 document_title_field_name: Optional[str] = None,
                 field_mappings: Optional[Sequence['outputs.DataSourceDataSourceToIndexFieldMapping']] = None,
                 include_filter_types: Optional[Sequence['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) -> str:
        return pulumi.get(self, "document_data_field_name")

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

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

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


@pulumi.output_type
class DataSourceSalesforceConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "secretArn":
            suggest = "secret_arn"
        elif key == "serverUrl":
            suggest = "server_url"
        elif key == "chatterFeedConfiguration":
            suggest = "chatter_feed_configuration"
        elif key == "crawlAttachments":
            suggest = "crawl_attachments"
        elif key == "excludeAttachmentFilePatterns":
            suggest = "exclude_attachment_file_patterns"
        elif key == "includeAttachmentFilePatterns":
            suggest = "include_attachment_file_patterns"
        elif key == "knowledgeArticleConfiguration":
            suggest = "knowledge_article_configuration"
        elif key == "standardObjectAttachmentConfiguration":
            suggest = "standard_object_attachment_configuration"
        elif key == "standardObjectConfigurations":
            suggest = "standard_object_configurations"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DataSourceSalesforceConfiguration. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DataSourceSalesforceConfiguration.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DataSourceSalesforceConfiguration.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 secret_arn: str,
                 server_url: str,
                 chatter_feed_configuration: Optional['outputs.DataSourceSalesforceChatterFeedConfiguration'] = None,
                 crawl_attachments: Optional[bool] = None,
                 exclude_attachment_file_patterns: Optional[Sequence[str]] = None,
                 include_attachment_file_patterns: Optional[Sequence[str]] = None,
                 knowledge_article_configuration: Optional['outputs.DataSourceSalesforceKnowledgeArticleConfiguration'] = None,
                 standard_object_attachment_configuration: Optional['outputs.DataSourceSalesforceStandardObjectAttachmentConfiguration'] = None,
                 standard_object_configurations: Optional[Sequence['outputs.DataSourceSalesforceStandardObjectConfiguration']] = 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) -> str:
        return pulumi.get(self, "secret_arn")

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

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

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

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

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

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

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

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


@pulumi.output_type
class DataSourceSalesforceCustomKnowledgeArticleTypeConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "documentDataFieldName":
            suggest = "document_data_field_name"
        elif key == "documentTitleFieldName":
            suggest = "document_title_field_name"
        elif key == "fieldMappings":
            suggest = "field_mappings"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DataSourceSalesforceCustomKnowledgeArticleTypeConfiguration. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DataSourceSalesforceCustomKnowledgeArticleTypeConfiguration.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DataSourceSalesforceCustomKnowledgeArticleTypeConfiguration.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 document_data_field_name: str,
                 name: str,
                 document_title_field_name: Optional[str] = None,
                 field_mappings: Optional[Sequence['outputs.DataSourceDataSourceToIndexFieldMapping']] = 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) -> str:
        return pulumi.get(self, "document_data_field_name")

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

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

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


@pulumi.output_type
class DataSourceSalesforceKnowledgeArticleConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "includedStates":
            suggest = "included_states"
        elif key == "customKnowledgeArticleTypeConfigurations":
            suggest = "custom_knowledge_article_type_configurations"
        elif key == "standardKnowledgeArticleTypeConfiguration":
            suggest = "standard_knowledge_article_type_configuration"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DataSourceSalesforceKnowledgeArticleConfiguration. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DataSourceSalesforceKnowledgeArticleConfiguration.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DataSourceSalesforceKnowledgeArticleConfiguration.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 included_states: Sequence['DataSourceSalesforceKnowledgeArticleState'],
                 custom_knowledge_article_type_configurations: Optional[Sequence['outputs.DataSourceSalesforceCustomKnowledgeArticleTypeConfiguration']] = None,
                 standard_knowledge_article_type_configuration: Optional['outputs.DataSourceSalesforceStandardKnowledgeArticleTypeConfiguration'] = 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) -> Sequence['DataSourceSalesforceKnowledgeArticleState']:
        return pulumi.get(self, "included_states")

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

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


@pulumi.output_type
class DataSourceSalesforceStandardKnowledgeArticleTypeConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "documentDataFieldName":
            suggest = "document_data_field_name"
        elif key == "documentTitleFieldName":
            suggest = "document_title_field_name"
        elif key == "fieldMappings":
            suggest = "field_mappings"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DataSourceSalesforceStandardKnowledgeArticleTypeConfiguration. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DataSourceSalesforceStandardKnowledgeArticleTypeConfiguration.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DataSourceSalesforceStandardKnowledgeArticleTypeConfiguration.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 document_data_field_name: str,
                 document_title_field_name: Optional[str] = None,
                 field_mappings: Optional[Sequence['outputs.DataSourceDataSourceToIndexFieldMapping']] = 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) -> str:
        return pulumi.get(self, "document_data_field_name")

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

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


@pulumi.output_type
class DataSourceSalesforceStandardObjectAttachmentConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "documentTitleFieldName":
            suggest = "document_title_field_name"
        elif key == "fieldMappings":
            suggest = "field_mappings"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DataSourceSalesforceStandardObjectAttachmentConfiguration. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DataSourceSalesforceStandardObjectAttachmentConfiguration.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DataSourceSalesforceStandardObjectAttachmentConfiguration.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 document_title_field_name: Optional[str] = None,
                 field_mappings: Optional[Sequence['outputs.DataSourceDataSourceToIndexFieldMapping']] = 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[str]:
        return pulumi.get(self, "document_title_field_name")

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


@pulumi.output_type
class DataSourceSalesforceStandardObjectConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "documentDataFieldName":
            suggest = "document_data_field_name"
        elif key == "documentTitleFieldName":
            suggest = "document_title_field_name"
        elif key == "fieldMappings":
            suggest = "field_mappings"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DataSourceSalesforceStandardObjectConfiguration. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DataSourceSalesforceStandardObjectConfiguration.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DataSourceSalesforceStandardObjectConfiguration.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 document_data_field_name: str,
                 name: 'DataSourceSalesforceStandardObjectName',
                 document_title_field_name: Optional[str] = None,
                 field_mappings: Optional[Sequence['outputs.DataSourceDataSourceToIndexFieldMapping']] = 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) -> str:
        return pulumi.get(self, "document_data_field_name")

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

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

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


@pulumi.output_type
class DataSourceServiceNowConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "hostUrl":
            suggest = "host_url"
        elif key == "secretArn":
            suggest = "secret_arn"
        elif key == "serviceNowBuildVersion":
            suggest = "service_now_build_version"
        elif key == "knowledgeArticleConfiguration":
            suggest = "knowledge_article_configuration"
        elif key == "serviceCatalogConfiguration":
            suggest = "service_catalog_configuration"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DataSourceServiceNowConfiguration. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DataSourceServiceNowConfiguration.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DataSourceServiceNowConfiguration.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 host_url: str,
                 secret_arn: str,
                 service_now_build_version: 'DataSourceServiceNowBuildVersionType',
                 knowledge_article_configuration: Optional['outputs.DataSourceServiceNowKnowledgeArticleConfiguration'] = None,
                 service_catalog_configuration: Optional['outputs.DataSourceServiceNowServiceCatalogConfiguration'] = 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) -> str:
        return pulumi.get(self, "host_url")

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

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

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

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


@pulumi.output_type
class DataSourceServiceNowKnowledgeArticleConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "documentDataFieldName":
            suggest = "document_data_field_name"
        elif key == "crawlAttachments":
            suggest = "crawl_attachments"
        elif key == "documentTitleFieldName":
            suggest = "document_title_field_name"
        elif key == "excludeAttachmentFilePatterns":
            suggest = "exclude_attachment_file_patterns"
        elif key == "fieldMappings":
            suggest = "field_mappings"
        elif key == "includeAttachmentFilePatterns":
            suggest = "include_attachment_file_patterns"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DataSourceServiceNowKnowledgeArticleConfiguration. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DataSourceServiceNowKnowledgeArticleConfiguration.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DataSourceServiceNowKnowledgeArticleConfiguration.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 document_data_field_name: str,
                 crawl_attachments: Optional[bool] = None,
                 document_title_field_name: Optional[str] = None,
                 exclude_attachment_file_patterns: Optional[Sequence[str]] = None,
                 field_mappings: Optional[Sequence['outputs.DataSourceDataSourceToIndexFieldMapping']] = None,
                 include_attachment_file_patterns: Optional[Sequence[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) -> str:
        return pulumi.get(self, "document_data_field_name")

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

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

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

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

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


@pulumi.output_type
class DataSourceServiceNowServiceCatalogConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "documentDataFieldName":
            suggest = "document_data_field_name"
        elif key == "crawlAttachments":
            suggest = "crawl_attachments"
        elif key == "documentTitleFieldName":
            suggest = "document_title_field_name"
        elif key == "excludeAttachmentFilePatterns":
            suggest = "exclude_attachment_file_patterns"
        elif key == "fieldMappings":
            suggest = "field_mappings"
        elif key == "includeAttachmentFilePatterns":
            suggest = "include_attachment_file_patterns"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DataSourceServiceNowServiceCatalogConfiguration. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DataSourceServiceNowServiceCatalogConfiguration.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DataSourceServiceNowServiceCatalogConfiguration.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 document_data_field_name: str,
                 crawl_attachments: Optional[bool] = None,
                 document_title_field_name: Optional[str] = None,
                 exclude_attachment_file_patterns: Optional[Sequence[str]] = None,
                 field_mappings: Optional[Sequence['outputs.DataSourceDataSourceToIndexFieldMapping']] = None,
                 include_attachment_file_patterns: Optional[Sequence[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) -> str:
        return pulumi.get(self, "document_data_field_name")

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

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

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

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

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


@pulumi.output_type
class DataSourceSharePointConfiguration(dict):
    """
    SharePoint configuration
    """
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "secretArn":
            suggest = "secret_arn"
        elif key == "sharePointVersion":
            suggest = "share_point_version"
        elif key == "crawlAttachments":
            suggest = "crawl_attachments"
        elif key == "disableLocalGroups":
            suggest = "disable_local_groups"
        elif key == "documentTitleFieldName":
            suggest = "document_title_field_name"
        elif key == "exclusionPatterns":
            suggest = "exclusion_patterns"
        elif key == "fieldMappings":
            suggest = "field_mappings"
        elif key == "inclusionPatterns":
            suggest = "inclusion_patterns"
        elif key == "useChangeLog":
            suggest = "use_change_log"
        elif key == "vpcConfiguration":
            suggest = "vpc_configuration"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DataSourceSharePointConfiguration. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DataSourceSharePointConfiguration.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DataSourceSharePointConfiguration.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 secret_arn: str,
                 share_point_version: 'DataSourceSharePointConfigurationSharePointVersion',
                 urls: Sequence[str],
                 crawl_attachments: Optional[bool] = None,
                 disable_local_groups: Optional[bool] = None,
                 document_title_field_name: Optional[str] = None,
                 exclusion_patterns: Optional[Sequence[str]] = None,
                 field_mappings: Optional[Sequence['outputs.DataSourceDataSourceToIndexFieldMapping']] = None,
                 inclusion_patterns: Optional[Sequence[str]] = None,
                 use_change_log: Optional[bool] = None,
                 vpc_configuration: Optional['outputs.DataSourceDataSourceVpcConfiguration'] = 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) -> str:
        return pulumi.get(self, "secret_arn")

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

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

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

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

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

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

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

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

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

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


@pulumi.output_type
class DataSourceSqlConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "queryIdentifiersEnclosingOption":
            suggest = "query_identifiers_enclosing_option"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in DataSourceSqlConfiguration. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        DataSourceSqlConfiguration.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        DataSourceSqlConfiguration.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 query_identifiers_enclosing_option: Optional['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['DataSourceQueryIdentifiersEnclosingOption']:
        return pulumi.get(self, "query_identifiers_enclosing_option")


@pulumi.output_type
class DataSourceTag(dict):
    """
    A label for tagging Kendra resources
    """
    def __init__(__self__, *,
                 key: str,
                 value: str):
        """
        A label for tagging Kendra resources
        :param str key: A string used to identify this tag
        :param 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) -> str:
        """
        A string used to identify this tag
        """
        return pulumi.get(self, "key")

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


@pulumi.output_type
class FaqS3Path(dict):
    def __init__(__self__, *,
                 bucket: str,
                 key: str):
        pulumi.set(__self__, "bucket", bucket)
        pulumi.set(__self__, "key", key)

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

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


@pulumi.output_type
class FaqTag(dict):
    """
    A label for tagging Kendra resources
    """
    def __init__(__self__, *,
                 key: str,
                 value: str):
        """
        A label for tagging Kendra resources
        :param str key: A string used to identify this tag
        :param 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) -> str:
        """
        A string used to identify this tag
        """
        return pulumi.get(self, "key")

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


@pulumi.output_type
class IndexCapacityUnitsConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "queryCapacityUnits":
            suggest = "query_capacity_units"
        elif key == "storageCapacityUnits":
            suggest = "storage_capacity_units"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in IndexCapacityUnitsConfiguration. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        IndexCapacityUnitsConfiguration.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        IndexCapacityUnitsConfiguration.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 query_capacity_units: int,
                 storage_capacity_units: 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) -> int:
        return pulumi.get(self, "query_capacity_units")

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


@pulumi.output_type
class IndexDocumentMetadataConfiguration(dict):
    def __init__(__self__, *,
                 name: str,
                 type: 'IndexDocumentAttributeValueType',
                 relevance: Optional['outputs.IndexRelevance'] = None,
                 search: Optional['outputs.IndexSearch'] = 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) -> str:
        return pulumi.get(self, "name")

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

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

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


@pulumi.output_type
class IndexJsonTokenTypeConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "groupAttributeField":
            suggest = "group_attribute_field"
        elif key == "userNameAttributeField":
            suggest = "user_name_attribute_field"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in IndexJsonTokenTypeConfiguration. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        IndexJsonTokenTypeConfiguration.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        IndexJsonTokenTypeConfiguration.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 group_attribute_field: str,
                 user_name_attribute_field: 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) -> str:
        return pulumi.get(self, "group_attribute_field")

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


@pulumi.output_type
class IndexJwtTokenTypeConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "keyLocation":
            suggest = "key_location"
        elif key == "claimRegex":
            suggest = "claim_regex"
        elif key == "groupAttributeField":
            suggest = "group_attribute_field"
        elif key == "secretManagerArn":
            suggest = "secret_manager_arn"
        elif key == "uRL":
            suggest = "u_rl"
        elif key == "userNameAttributeField":
            suggest = "user_name_attribute_field"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in IndexJwtTokenTypeConfiguration. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        IndexJwtTokenTypeConfiguration.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        IndexJwtTokenTypeConfiguration.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 key_location: 'IndexKeyLocation',
                 claim_regex: Optional[str] = None,
                 group_attribute_field: Optional[str] = None,
                 issuer: Optional[str] = None,
                 secret_manager_arn: Optional[str] = None,
                 u_rl: Optional[str] = None,
                 user_name_attribute_field: Optional[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) -> 'IndexKeyLocation':
        return pulumi.get(self, "key_location")

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

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

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

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

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

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


@pulumi.output_type
class IndexRelevance(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "rankOrder":
            suggest = "rank_order"
        elif key == "valueImportanceItems":
            suggest = "value_importance_items"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in IndexRelevance. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        IndexRelevance.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        IndexRelevance.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 duration: Optional[str] = None,
                 freshness: Optional[bool] = None,
                 importance: Optional[int] = None,
                 rank_order: Optional['IndexOrder'] = None,
                 value_importance_items: Optional[Sequence['outputs.IndexValueImportanceItem']] = 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[str]:
        return pulumi.get(self, "duration")

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

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

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

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


@pulumi.output_type
class IndexSearch(dict):
    def __init__(__self__, *,
                 displayable: Optional[bool] = None,
                 facetable: Optional[bool] = None,
                 searchable: Optional[bool] = None,
                 sortable: Optional[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[bool]:
        return pulumi.get(self, "displayable")

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

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

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


@pulumi.output_type
class IndexServerSideEncryptionConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "kmsKeyId":
            suggest = "kms_key_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in IndexServerSideEncryptionConfiguration. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        IndexServerSideEncryptionConfiguration.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        IndexServerSideEncryptionConfiguration.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 kms_key_id: Optional[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[str]:
        return pulumi.get(self, "kms_key_id")


@pulumi.output_type
class IndexTag(dict):
    """
    A label for tagging Kendra resources
    """
    def __init__(__self__, *,
                 key: str,
                 value: str):
        """
        A label for tagging Kendra resources
        :param str key: A string used to identify this tag
        :param 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) -> str:
        """
        A string used to identify this tag
        """
        return pulumi.get(self, "key")

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


@pulumi.output_type
class IndexUserTokenConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "jsonTokenTypeConfiguration":
            suggest = "json_token_type_configuration"
        elif key == "jwtTokenTypeConfiguration":
            suggest = "jwt_token_type_configuration"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in IndexUserTokenConfiguration. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        IndexUserTokenConfiguration.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        IndexUserTokenConfiguration.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 json_token_type_configuration: Optional['outputs.IndexJsonTokenTypeConfiguration'] = None,
                 jwt_token_type_configuration: Optional['outputs.IndexJwtTokenTypeConfiguration'] = 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['outputs.IndexJsonTokenTypeConfiguration']:
        return pulumi.get(self, "json_token_type_configuration")

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


@pulumi.output_type
class IndexValueImportanceItem(dict):
    def __init__(__self__, *,
                 key: Optional[str] = None,
                 value: Optional[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[str]:
        return pulumi.get(self, "key")

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


