# coding=utf-8
# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***

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

__all__ = [
    'DataSourceConfigurationArgs',
    'DataSourceConfigurationS3ConfigurationArgs',
    'DataSourceConfigurationS3ConfigurationAccessControlListConfigurationArgs',
    'DataSourceConfigurationS3ConfigurationDocumentsMetadataConfigurationArgs',
    'DataSourceConfigurationWebCrawlerConfigurationArgs',
    'DataSourceConfigurationWebCrawlerConfigurationAuthenticationConfigurationArgs',
    'DataSourceConfigurationWebCrawlerConfigurationAuthenticationConfigurationBasicAuthenticationArgs',
    'DataSourceConfigurationWebCrawlerConfigurationProxyConfigurationArgs',
    'DataSourceConfigurationWebCrawlerConfigurationUrlsArgs',
    'DataSourceConfigurationWebCrawlerConfigurationUrlsSeedUrlConfigurationArgs',
    'DataSourceConfigurationWebCrawlerConfigurationUrlsSiteMapsConfigurationArgs',
    'DataSourceCustomDocumentEnrichmentConfigurationArgs',
    'DataSourceCustomDocumentEnrichmentConfigurationInlineConfigurationArgs',
    'DataSourceCustomDocumentEnrichmentConfigurationInlineConfigurationConditionArgs',
    'DataSourceCustomDocumentEnrichmentConfigurationInlineConfigurationConditionConditionOnValueArgs',
    'DataSourceCustomDocumentEnrichmentConfigurationInlineConfigurationTargetArgs',
    'DataSourceCustomDocumentEnrichmentConfigurationInlineConfigurationTargetTargetDocumentAttributeValueArgs',
    'DataSourceCustomDocumentEnrichmentConfigurationPostExtractionHookConfigurationArgs',
    'DataSourceCustomDocumentEnrichmentConfigurationPostExtractionHookConfigurationInvocationConditionArgs',
    'DataSourceCustomDocumentEnrichmentConfigurationPostExtractionHookConfigurationInvocationConditionConditionOnValueArgs',
    'DataSourceCustomDocumentEnrichmentConfigurationPreExtractionHookConfigurationArgs',
    'DataSourceCustomDocumentEnrichmentConfigurationPreExtractionHookConfigurationInvocationConditionArgs',
    'DataSourceCustomDocumentEnrichmentConfigurationPreExtractionHookConfigurationInvocationConditionConditionOnValueArgs',
    'ExperienceConfigurationArgs',
    'ExperienceConfigurationContentSourceConfigurationArgs',
    'ExperienceConfigurationUserIdentityConfigurationArgs',
    'ExperienceEndpointArgs',
    'FaqS3PathArgs',
    'IndexCapacityUnitsArgs',
    'IndexDocumentMetadataConfigurationUpdateArgs',
    'IndexDocumentMetadataConfigurationUpdateRelevanceArgs',
    'IndexDocumentMetadataConfigurationUpdateSearchArgs',
    'IndexIndexStatisticArgs',
    'IndexIndexStatisticFaqStatisticArgs',
    'IndexIndexStatisticTextDocumentStatisticArgs',
    'IndexServerSideEncryptionConfigurationArgs',
    'IndexUserGroupResolutionConfigurationArgs',
    'IndexUserTokenConfigurationsArgs',
    'IndexUserTokenConfigurationsJsonTokenTypeConfigurationArgs',
    'IndexUserTokenConfigurationsJwtTokenTypeConfigurationArgs',
    'QuerySuggestionsBlockListSourceS3PathArgs',
    'ThesaurusSourceS3PathArgs',
]

@pulumi.input_type
class DataSourceConfigurationArgs:
    def __init__(__self__, *,
                 s3_configuration: Optional[pulumi.Input['DataSourceConfigurationS3ConfigurationArgs']] = None,
                 web_crawler_configuration: Optional[pulumi.Input['DataSourceConfigurationWebCrawlerConfigurationArgs']] = None):
        """
        :param pulumi.Input['DataSourceConfigurationS3ConfigurationArgs'] s3_configuration: A block that provides the configuration information to connect to an Amazon S3 bucket as your data source. Detailed below.
        :param pulumi.Input['DataSourceConfigurationWebCrawlerConfigurationArgs'] web_crawler_configuration: A block that provides the configuration information required for Amazon Kendra Web Crawler. Detailed below.
        """
        if s3_configuration is not None:
            pulumi.set(__self__, "s3_configuration", s3_configuration)
        if web_crawler_configuration is not None:
            pulumi.set(__self__, "web_crawler_configuration", web_crawler_configuration)

    @property
    @pulumi.getter(name="s3Configuration")
    def s3_configuration(self) -> Optional[pulumi.Input['DataSourceConfigurationS3ConfigurationArgs']]:
        """
        A block that provides the configuration information to connect to an Amazon S3 bucket as your data source. Detailed below.
        """
        return pulumi.get(self, "s3_configuration")

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

    @property
    @pulumi.getter(name="webCrawlerConfiguration")
    def web_crawler_configuration(self) -> Optional[pulumi.Input['DataSourceConfigurationWebCrawlerConfigurationArgs']]:
        """
        A block that provides the configuration information required for Amazon Kendra Web Crawler. Detailed below.
        """
        return pulumi.get(self, "web_crawler_configuration")

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


@pulumi.input_type
class DataSourceConfigurationS3ConfigurationArgs:
    def __init__(__self__, *,
                 bucket_name: pulumi.Input[str],
                 access_control_list_configuration: Optional[pulumi.Input['DataSourceConfigurationS3ConfigurationAccessControlListConfigurationArgs']] = None,
                 documents_metadata_configuration: Optional[pulumi.Input['DataSourceConfigurationS3ConfigurationDocumentsMetadataConfigurationArgs']] = None,
                 exclusion_patterns: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 inclusion_patterns: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 inclusion_prefixes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[str] bucket_name: The name of the bucket that contains the documents.
        :param pulumi.Input['DataSourceConfigurationS3ConfigurationAccessControlListConfigurationArgs'] access_control_list_configuration: A block that provides the path to the S3 bucket that contains the user context filtering files for the data source. For the format of the file, see [Access control for S3 data sources](https://docs.aws.amazon.com/kendra/latest/dg/s3-acl.html). Detailed below.
        :param pulumi.Input['DataSourceConfigurationS3ConfigurationDocumentsMetadataConfigurationArgs'] documents_metadata_configuration: A block that defines the Ddcument metadata files that contain information such as the document access control information, source URI, document author, and custom attributes. Each metadata file contains metadata about a single document. Detailed below.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] exclusion_patterns: A list of glob patterns for documents that should not be indexed. If a document that matches an inclusion prefix or inclusion pattern also matches an exclusion pattern, the document is not indexed. Refer to [Exclusion Patterns for more examples](https://docs.aws.amazon.com/kendra/latest/dg/API_S3DataSourceConfiguration.html#Kendra-Type-S3DataSourceConfiguration-ExclusionPatterns).
        :param pulumi.Input[Sequence[pulumi.Input[str]]] inclusion_patterns: A list of glob patterns for documents that should be indexed. If a document that matches an inclusion pattern also matches an exclusion pattern, the document is not indexed. Refer to [Inclusion Patterns for more examples](https://docs.aws.amazon.com/kendra/latest/dg/API_S3DataSourceConfiguration.html#Kendra-Type-S3DataSourceConfiguration-InclusionPatterns).
        :param pulumi.Input[Sequence[pulumi.Input[str]]] inclusion_prefixes: A list of S3 prefixes for the documents that should be included in the index.
        """
        pulumi.set(__self__, "bucket_name", bucket_name)
        if access_control_list_configuration is not None:
            pulumi.set(__self__, "access_control_list_configuration", access_control_list_configuration)
        if documents_metadata_configuration is not None:
            pulumi.set(__self__, "documents_metadata_configuration", documents_metadata_configuration)
        if exclusion_patterns is not None:
            pulumi.set(__self__, "exclusion_patterns", exclusion_patterns)
        if inclusion_patterns is not None:
            pulumi.set(__self__, "inclusion_patterns", inclusion_patterns)
        if inclusion_prefixes is not None:
            pulumi.set(__self__, "inclusion_prefixes", inclusion_prefixes)

    @property
    @pulumi.getter(name="bucketName")
    def bucket_name(self) -> pulumi.Input[str]:
        """
        The name of the bucket that contains the documents.
        """
        return pulumi.get(self, "bucket_name")

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

    @property
    @pulumi.getter(name="accessControlListConfiguration")
    def access_control_list_configuration(self) -> Optional[pulumi.Input['DataSourceConfigurationS3ConfigurationAccessControlListConfigurationArgs']]:
        """
        A block that provides the path to the S3 bucket that contains the user context filtering files for the data source. For the format of the file, see [Access control for S3 data sources](https://docs.aws.amazon.com/kendra/latest/dg/s3-acl.html). Detailed below.
        """
        return pulumi.get(self, "access_control_list_configuration")

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

    @property
    @pulumi.getter(name="documentsMetadataConfiguration")
    def documents_metadata_configuration(self) -> Optional[pulumi.Input['DataSourceConfigurationS3ConfigurationDocumentsMetadataConfigurationArgs']]:
        """
        A block that defines the Ddcument metadata files that contain information such as the document access control information, source URI, document author, and custom attributes. Each metadata file contains metadata about a single document. Detailed below.
        """
        return pulumi.get(self, "documents_metadata_configuration")

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

    @property
    @pulumi.getter(name="exclusionPatterns")
    def exclusion_patterns(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        A list of glob patterns for documents that should not be indexed. If a document that matches an inclusion prefix or inclusion pattern also matches an exclusion pattern, the document is not indexed. Refer to [Exclusion Patterns for more examples](https://docs.aws.amazon.com/kendra/latest/dg/API_S3DataSourceConfiguration.html#Kendra-Type-S3DataSourceConfiguration-ExclusionPatterns).
        """
        return pulumi.get(self, "exclusion_patterns")

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

    @property
    @pulumi.getter(name="inclusionPatterns")
    def inclusion_patterns(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        A list of glob patterns for documents that should be indexed. If a document that matches an inclusion pattern also matches an exclusion pattern, the document is not indexed. Refer to [Inclusion Patterns for more examples](https://docs.aws.amazon.com/kendra/latest/dg/API_S3DataSourceConfiguration.html#Kendra-Type-S3DataSourceConfiguration-InclusionPatterns).
        """
        return pulumi.get(self, "inclusion_patterns")

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

    @property
    @pulumi.getter(name="inclusionPrefixes")
    def inclusion_prefixes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        A list of S3 prefixes for the documents that should be included in the index.
        """
        return pulumi.get(self, "inclusion_prefixes")

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


@pulumi.input_type
class DataSourceConfigurationS3ConfigurationAccessControlListConfigurationArgs:
    def __init__(__self__, *,
                 key_path: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] key_path: Path to the AWS S3 bucket that contains the ACL files.
        """
        if key_path is not None:
            pulumi.set(__self__, "key_path", key_path)

    @property
    @pulumi.getter(name="keyPath")
    def key_path(self) -> Optional[pulumi.Input[str]]:
        """
        Path to the AWS S3 bucket that contains the ACL files.
        """
        return pulumi.get(self, "key_path")

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


@pulumi.input_type
class DataSourceConfigurationS3ConfigurationDocumentsMetadataConfigurationArgs:
    def __init__(__self__, *,
                 s3_prefix: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] s3_prefix: A prefix used to filter metadata configuration files in the AWS S3 bucket. The S3 bucket might contain multiple metadata files. Use `s3_prefix` to include only the desired metadata files.
        """
        if s3_prefix is not None:
            pulumi.set(__self__, "s3_prefix", s3_prefix)

    @property
    @pulumi.getter(name="s3Prefix")
    def s3_prefix(self) -> Optional[pulumi.Input[str]]:
        """
        A prefix used to filter metadata configuration files in the AWS S3 bucket. The S3 bucket might contain multiple metadata files. Use `s3_prefix` to include only the desired metadata files.
        """
        return pulumi.get(self, "s3_prefix")

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


@pulumi.input_type
class DataSourceConfigurationWebCrawlerConfigurationArgs:
    def __init__(__self__, *,
                 urls: pulumi.Input['DataSourceConfigurationWebCrawlerConfigurationUrlsArgs'],
                 authentication_configuration: Optional[pulumi.Input['DataSourceConfigurationWebCrawlerConfigurationAuthenticationConfigurationArgs']] = None,
                 crawl_depth: Optional[pulumi.Input[int]] = None,
                 max_content_size_per_page_in_mega_bytes: Optional[pulumi.Input[float]] = None,
                 max_links_per_page: Optional[pulumi.Input[int]] = None,
                 max_urls_per_minute_crawl_rate: Optional[pulumi.Input[int]] = None,
                 proxy_configuration: Optional[pulumi.Input['DataSourceConfigurationWebCrawlerConfigurationProxyConfigurationArgs']] = None,
                 url_exclusion_patterns: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 url_inclusion_patterns: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input['DataSourceConfigurationWebCrawlerConfigurationUrlsArgs'] urls: A block that specifies the seed or starting point URLs of the websites or the sitemap URLs of the websites you want to crawl. You can include website subdomains. You can list up to `100` seed URLs and up to `3` sitemap URLs. You can only crawl websites that use the secure communication protocol, Hypertext Transfer Protocol Secure (HTTPS). If you receive an error when crawling a website, it could be that the website is blocked from crawling. When selecting websites to index, you must adhere to the [Amazon Acceptable Use Policy](https://aws.amazon.com/aup/) and all other Amazon terms. Remember that you must only use Amazon Kendra Web Crawler to index your own webpages, or webpages that you have authorization to index. Detailed below.
        :param pulumi.Input['DataSourceConfigurationWebCrawlerConfigurationAuthenticationConfigurationArgs'] authentication_configuration: A block with the configuration information required to connect to websites using authentication. You can connect to websites using basic authentication of user name and password. You use a secret in AWS Secrets Manager to store your authentication credentials. You must provide the website host name and port number. For example, the host name of `https://a.example.com/page1.html` is `"a.example.com"` and the port is `443`, the standard port for HTTPS. Detailed below.
        :param pulumi.Input[int] crawl_depth: Specifies the number of levels in a website that you want to crawl. The first level begins from the website seed or starting point URL. For example, if a website has 3 levels – index level (i.e. seed in this example), sections level, and subsections level – and you are only interested in crawling information up to the sections level (i.e. levels 0-1), you can set your depth to 1. The default crawl depth is set to `2`. Minimum value of `0`. Maximum value of `10`.
        :param pulumi.Input[float] max_content_size_per_page_in_mega_bytes: The maximum size (in MB) of a webpage or attachment to crawl. Files larger than this size (in MB) are skipped/not crawled. The default maximum size of a webpage or attachment is set to `50` MB. Minimum value of `1.0e-06`. Maximum value of `50`.
        :param pulumi.Input[int] max_links_per_page: The maximum number of URLs on a webpage to include when crawling a website. This number is per webpage. As a website’s webpages are crawled, any URLs the webpages link to are also crawled. URLs on a webpage are crawled in order of appearance. The default maximum links per page is `100`. Minimum value of `1`. Maximum value of `1000`.
        :param pulumi.Input[int] max_urls_per_minute_crawl_rate: The maximum number of URLs crawled per website host per minute. The default maximum number of URLs crawled per website host per minute is `300`. Minimum value of `1`. Maximum value of `300`.
        :param pulumi.Input['DataSourceConfigurationWebCrawlerConfigurationProxyConfigurationArgs'] proxy_configuration: Configuration information required to connect to your internal websites via a web proxy. You must provide the website host name and port number. For example, the host name of `https://a.example.com/page1.html` is `"a.example.com"` and the port is `443`, the standard port for HTTPS. Web proxy credentials are optional and you can use them to connect to a web proxy server that requires basic authentication. To store web proxy credentials, you use a secret in [AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html). Detailed below.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] url_exclusion_patterns: A list of regular expression patterns to exclude certain URLs to crawl. URLs that match the patterns are excluded from the index. URLs that don't match the patterns are included in the index. If a URL matches both an inclusion and exclusion pattern, the exclusion pattern takes precedence and the URL file isn't included in the index. Array Members: Minimum number of `0` items. Maximum number of `100` items. Length Constraints: Minimum length of `1`. Maximum length of `150`.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] url_inclusion_patterns: A list of regular expression patterns to include certain URLs to crawl. URLs that match the patterns are included in the index. URLs that don't match the patterns are excluded from the index. If a URL matches both an inclusion and exclusion pattern, the exclusion pattern takes precedence and the URL file isn't included in the index. Array Members: Minimum number of `0` items. Maximum number of `100` items. Length Constraints: Minimum length of `1`. Maximum length of `150`.
        """
        pulumi.set(__self__, "urls", urls)
        if authentication_configuration is not None:
            pulumi.set(__self__, "authentication_configuration", authentication_configuration)
        if crawl_depth is not None:
            pulumi.set(__self__, "crawl_depth", crawl_depth)
        if max_content_size_per_page_in_mega_bytes is not None:
            pulumi.set(__self__, "max_content_size_per_page_in_mega_bytes", max_content_size_per_page_in_mega_bytes)
        if max_links_per_page is not None:
            pulumi.set(__self__, "max_links_per_page", max_links_per_page)
        if max_urls_per_minute_crawl_rate is not None:
            pulumi.set(__self__, "max_urls_per_minute_crawl_rate", max_urls_per_minute_crawl_rate)
        if proxy_configuration is not None:
            pulumi.set(__self__, "proxy_configuration", proxy_configuration)
        if url_exclusion_patterns is not None:
            pulumi.set(__self__, "url_exclusion_patterns", url_exclusion_patterns)
        if url_inclusion_patterns is not None:
            pulumi.set(__self__, "url_inclusion_patterns", url_inclusion_patterns)

    @property
    @pulumi.getter
    def urls(self) -> pulumi.Input['DataSourceConfigurationWebCrawlerConfigurationUrlsArgs']:
        """
        A block that specifies the seed or starting point URLs of the websites or the sitemap URLs of the websites you want to crawl. You can include website subdomains. You can list up to `100` seed URLs and up to `3` sitemap URLs. You can only crawl websites that use the secure communication protocol, Hypertext Transfer Protocol Secure (HTTPS). If you receive an error when crawling a website, it could be that the website is blocked from crawling. When selecting websites to index, you must adhere to the [Amazon Acceptable Use Policy](https://aws.amazon.com/aup/) and all other Amazon terms. Remember that you must only use Amazon Kendra Web Crawler to index your own webpages, or webpages that you have authorization to index. Detailed below.
        """
        return pulumi.get(self, "urls")

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

    @property
    @pulumi.getter(name="authenticationConfiguration")
    def authentication_configuration(self) -> Optional[pulumi.Input['DataSourceConfigurationWebCrawlerConfigurationAuthenticationConfigurationArgs']]:
        """
        A block with the configuration information required to connect to websites using authentication. You can connect to websites using basic authentication of user name and password. You use a secret in AWS Secrets Manager to store your authentication credentials. You must provide the website host name and port number. For example, the host name of `https://a.example.com/page1.html` is `"a.example.com"` and the port is `443`, the standard port for HTTPS. Detailed below.
        """
        return pulumi.get(self, "authentication_configuration")

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

    @property
    @pulumi.getter(name="crawlDepth")
    def crawl_depth(self) -> Optional[pulumi.Input[int]]:
        """
        Specifies the number of levels in a website that you want to crawl. The first level begins from the website seed or starting point URL. For example, if a website has 3 levels – index level (i.e. seed in this example), sections level, and subsections level – and you are only interested in crawling information up to the sections level (i.e. levels 0-1), you can set your depth to 1. The default crawl depth is set to `2`. Minimum value of `0`. Maximum value of `10`.
        """
        return pulumi.get(self, "crawl_depth")

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

    @property
    @pulumi.getter(name="maxContentSizePerPageInMegaBytes")
    def max_content_size_per_page_in_mega_bytes(self) -> Optional[pulumi.Input[float]]:
        """
        The maximum size (in MB) of a webpage or attachment to crawl. Files larger than this size (in MB) are skipped/not crawled. The default maximum size of a webpage or attachment is set to `50` MB. Minimum value of `1.0e-06`. Maximum value of `50`.
        """
        return pulumi.get(self, "max_content_size_per_page_in_mega_bytes")

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

    @property
    @pulumi.getter(name="maxLinksPerPage")
    def max_links_per_page(self) -> Optional[pulumi.Input[int]]:
        """
        The maximum number of URLs on a webpage to include when crawling a website. This number is per webpage. As a website’s webpages are crawled, any URLs the webpages link to are also crawled. URLs on a webpage are crawled in order of appearance. The default maximum links per page is `100`. Minimum value of `1`. Maximum value of `1000`.
        """
        return pulumi.get(self, "max_links_per_page")

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

    @property
    @pulumi.getter(name="maxUrlsPerMinuteCrawlRate")
    def max_urls_per_minute_crawl_rate(self) -> Optional[pulumi.Input[int]]:
        """
        The maximum number of URLs crawled per website host per minute. The default maximum number of URLs crawled per website host per minute is `300`. Minimum value of `1`. Maximum value of `300`.
        """
        return pulumi.get(self, "max_urls_per_minute_crawl_rate")

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

    @property
    @pulumi.getter(name="proxyConfiguration")
    def proxy_configuration(self) -> Optional[pulumi.Input['DataSourceConfigurationWebCrawlerConfigurationProxyConfigurationArgs']]:
        """
        Configuration information required to connect to your internal websites via a web proxy. You must provide the website host name and port number. For example, the host name of `https://a.example.com/page1.html` is `"a.example.com"` and the port is `443`, the standard port for HTTPS. Web proxy credentials are optional and you can use them to connect to a web proxy server that requires basic authentication. To store web proxy credentials, you use a secret in [AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html). Detailed below.
        """
        return pulumi.get(self, "proxy_configuration")

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

    @property
    @pulumi.getter(name="urlExclusionPatterns")
    def url_exclusion_patterns(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        A list of regular expression patterns to exclude certain URLs to crawl. URLs that match the patterns are excluded from the index. URLs that don't match the patterns are included in the index. If a URL matches both an inclusion and exclusion pattern, the exclusion pattern takes precedence and the URL file isn't included in the index. Array Members: Minimum number of `0` items. Maximum number of `100` items. Length Constraints: Minimum length of `1`. Maximum length of `150`.
        """
        return pulumi.get(self, "url_exclusion_patterns")

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

    @property
    @pulumi.getter(name="urlInclusionPatterns")
    def url_inclusion_patterns(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        A list of regular expression patterns to include certain URLs to crawl. URLs that match the patterns are included in the index. URLs that don't match the patterns are excluded from the index. If a URL matches both an inclusion and exclusion pattern, the exclusion pattern takes precedence and the URL file isn't included in the index. Array Members: Minimum number of `0` items. Maximum number of `100` items. Length Constraints: Minimum length of `1`. Maximum length of `150`.
        """
        return pulumi.get(self, "url_inclusion_patterns")

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


@pulumi.input_type
class DataSourceConfigurationWebCrawlerConfigurationAuthenticationConfigurationArgs:
    def __init__(__self__, *,
                 basic_authentications: Optional[pulumi.Input[Sequence[pulumi.Input['DataSourceConfigurationWebCrawlerConfigurationAuthenticationConfigurationBasicAuthenticationArgs']]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['DataSourceConfigurationWebCrawlerConfigurationAuthenticationConfigurationBasicAuthenticationArgs']]] basic_authentications: The list of configuration information that's required to connect to and crawl a website host using basic authentication credentials. The list includes the name and port number of the website host. Detailed below.
        """
        if basic_authentications is not None:
            pulumi.set(__self__, "basic_authentications", basic_authentications)

    @property
    @pulumi.getter(name="basicAuthentications")
    def basic_authentications(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DataSourceConfigurationWebCrawlerConfigurationAuthenticationConfigurationBasicAuthenticationArgs']]]]:
        """
        The list of configuration information that's required to connect to and crawl a website host using basic authentication credentials. The list includes the name and port number of the website host. Detailed below.
        """
        return pulumi.get(self, "basic_authentications")

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


@pulumi.input_type
class DataSourceConfigurationWebCrawlerConfigurationAuthenticationConfigurationBasicAuthenticationArgs:
    def __init__(__self__, *,
                 credentials: pulumi.Input[str],
                 host: pulumi.Input[str],
                 port: pulumi.Input[int]):
        """
        :param pulumi.Input[str] credentials: Your secret ARN, which you can create in AWS Secrets Manager. You use a secret if basic authentication credentials are required to connect to a website. The secret stores your credentials of user name and password.
        :param pulumi.Input[str] host: The name of the website host you want to connect to using authentication credentials. For example, the host name of `https://a.example.com/page1.html` is `"a.example.com"`.
        :param pulumi.Input[int] port: The port number of the website host you want to connect to using authentication credentials. For example, the port for `https://a.example.com/page1.html` is `443`, the standard port for HTTPS.
        """
        pulumi.set(__self__, "credentials", credentials)
        pulumi.set(__self__, "host", host)
        pulumi.set(__self__, "port", port)

    @property
    @pulumi.getter
    def credentials(self) -> pulumi.Input[str]:
        """
        Your secret ARN, which you can create in AWS Secrets Manager. You use a secret if basic authentication credentials are required to connect to a website. The secret stores your credentials of user name and password.
        """
        return pulumi.get(self, "credentials")

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

    @property
    @pulumi.getter
    def host(self) -> pulumi.Input[str]:
        """
        The name of the website host you want to connect to using authentication credentials. For example, the host name of `https://a.example.com/page1.html` is `"a.example.com"`.
        """
        return pulumi.get(self, "host")

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

    @property
    @pulumi.getter
    def port(self) -> pulumi.Input[int]:
        """
        The port number of the website host you want to connect to using authentication credentials. For example, the port for `https://a.example.com/page1.html` is `443`, the standard port for HTTPS.
        """
        return pulumi.get(self, "port")

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


@pulumi.input_type
class DataSourceConfigurationWebCrawlerConfigurationProxyConfigurationArgs:
    def __init__(__self__, *,
                 host: pulumi.Input[str],
                 port: pulumi.Input[int],
                 credentials: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] host: The name of the website host you want to connect to via a web proxy server. For example, the host name of `https://a.example.com/page1.html` is `"a.example.com"`.
        :param pulumi.Input[int] port: The port number of the website host you want to connect to via a web proxy server. For example, the port for `https://a.example.com/page1.html` is `443`, the standard port for HTTPS.
        :param pulumi.Input[str] credentials: Your secret ARN, which you can create in AWS Secrets Manager. The credentials are optional. You use a secret if web proxy credentials are required to connect to a website host. Amazon Kendra currently support basic authentication to connect to a web proxy server. The secret stores your credentials.
        """
        pulumi.set(__self__, "host", host)
        pulumi.set(__self__, "port", port)
        if credentials is not None:
            pulumi.set(__self__, "credentials", credentials)

    @property
    @pulumi.getter
    def host(self) -> pulumi.Input[str]:
        """
        The name of the website host you want to connect to via a web proxy server. For example, the host name of `https://a.example.com/page1.html` is `"a.example.com"`.
        """
        return pulumi.get(self, "host")

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

    @property
    @pulumi.getter
    def port(self) -> pulumi.Input[int]:
        """
        The port number of the website host you want to connect to via a web proxy server. For example, the port for `https://a.example.com/page1.html` is `443`, the standard port for HTTPS.
        """
        return pulumi.get(self, "port")

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

    @property
    @pulumi.getter
    def credentials(self) -> Optional[pulumi.Input[str]]:
        """
        Your secret ARN, which you can create in AWS Secrets Manager. The credentials are optional. You use a secret if web proxy credentials are required to connect to a website host. Amazon Kendra currently support basic authentication to connect to a web proxy server. The secret stores your credentials.
        """
        return pulumi.get(self, "credentials")

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


@pulumi.input_type
class DataSourceConfigurationWebCrawlerConfigurationUrlsArgs:
    def __init__(__self__, *,
                 seed_url_configuration: Optional[pulumi.Input['DataSourceConfigurationWebCrawlerConfigurationUrlsSeedUrlConfigurationArgs']] = None,
                 site_maps_configuration: Optional[pulumi.Input['DataSourceConfigurationWebCrawlerConfigurationUrlsSiteMapsConfigurationArgs']] = None):
        """
        :param pulumi.Input['DataSourceConfigurationWebCrawlerConfigurationUrlsSeedUrlConfigurationArgs'] seed_url_configuration: A block that specifies the configuration of the seed or starting point URLs of the websites you want to crawl. You can choose to crawl only the website host names, or the website host names with subdomains, or the website host names with subdomains and other domains that the webpages link to. You can list up to `100` seed URLs. Detailed below.
        :param pulumi.Input['DataSourceConfigurationWebCrawlerConfigurationUrlsSiteMapsConfigurationArgs'] site_maps_configuration: A block that specifies the configuration of the sitemap URLs of the websites you want to crawl. Only URLs belonging to the same website host names are crawled. You can list up to `3` sitemap URLs. Detailed below.
        """
        if seed_url_configuration is not None:
            pulumi.set(__self__, "seed_url_configuration", seed_url_configuration)
        if site_maps_configuration is not None:
            pulumi.set(__self__, "site_maps_configuration", site_maps_configuration)

    @property
    @pulumi.getter(name="seedUrlConfiguration")
    def seed_url_configuration(self) -> Optional[pulumi.Input['DataSourceConfigurationWebCrawlerConfigurationUrlsSeedUrlConfigurationArgs']]:
        """
        A block that specifies the configuration of the seed or starting point URLs of the websites you want to crawl. You can choose to crawl only the website host names, or the website host names with subdomains, or the website host names with subdomains and other domains that the webpages link to. You can list up to `100` seed URLs. Detailed below.
        """
        return pulumi.get(self, "seed_url_configuration")

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

    @property
    @pulumi.getter(name="siteMapsConfiguration")
    def site_maps_configuration(self) -> Optional[pulumi.Input['DataSourceConfigurationWebCrawlerConfigurationUrlsSiteMapsConfigurationArgs']]:
        """
        A block that specifies the configuration of the sitemap URLs of the websites you want to crawl. Only URLs belonging to the same website host names are crawled. You can list up to `3` sitemap URLs. Detailed below.
        """
        return pulumi.get(self, "site_maps_configuration")

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


@pulumi.input_type
class DataSourceConfigurationWebCrawlerConfigurationUrlsSeedUrlConfigurationArgs:
    def __init__(__self__, *,
                 seed_urls: pulumi.Input[Sequence[pulumi.Input[str]]],
                 web_crawler_mode: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input[str]]] seed_urls: The list of seed or starting point URLs of the websites you want to crawl. The list can include a maximum of `100` seed URLs. Array Members: Minimum number of `0` items. Maximum number of `100` items. Length Constraints: Minimum length of `1`. Maximum length of `2048`.
        :param pulumi.Input[str] web_crawler_mode: The default mode is set to `HOST_ONLY`. You can choose one of the following modes:
        """
        pulumi.set(__self__, "seed_urls", seed_urls)
        if web_crawler_mode is not None:
            pulumi.set(__self__, "web_crawler_mode", web_crawler_mode)

    @property
    @pulumi.getter(name="seedUrls")
    def seed_urls(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        """
        The list of seed or starting point URLs of the websites you want to crawl. The list can include a maximum of `100` seed URLs. Array Members: Minimum number of `0` items. Maximum number of `100` items. Length Constraints: Minimum length of `1`. Maximum length of `2048`.
        """
        return pulumi.get(self, "seed_urls")

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

    @property
    @pulumi.getter(name="webCrawlerMode")
    def web_crawler_mode(self) -> Optional[pulumi.Input[str]]:
        """
        The default mode is set to `HOST_ONLY`. You can choose one of the following modes:
        """
        return pulumi.get(self, "web_crawler_mode")

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


@pulumi.input_type
class DataSourceConfigurationWebCrawlerConfigurationUrlsSiteMapsConfigurationArgs:
    def __init__(__self__, *,
                 site_maps: pulumi.Input[Sequence[pulumi.Input[str]]]):
        """
        :param pulumi.Input[Sequence[pulumi.Input[str]]] site_maps: The list of sitemap URLs of the websites you want to crawl. The list can include a maximum of `3` sitemap URLs.
        """
        pulumi.set(__self__, "site_maps", site_maps)

    @property
    @pulumi.getter(name="siteMaps")
    def site_maps(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        """
        The list of sitemap URLs of the websites you want to crawl. The list can include a maximum of `3` sitemap URLs.
        """
        return pulumi.get(self, "site_maps")

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


@pulumi.input_type
class DataSourceCustomDocumentEnrichmentConfigurationArgs:
    def __init__(__self__, *,
                 inline_configurations: Optional[pulumi.Input[Sequence[pulumi.Input['DataSourceCustomDocumentEnrichmentConfigurationInlineConfigurationArgs']]]] = None,
                 post_extraction_hook_configuration: Optional[pulumi.Input['DataSourceCustomDocumentEnrichmentConfigurationPostExtractionHookConfigurationArgs']] = None,
                 pre_extraction_hook_configuration: Optional[pulumi.Input['DataSourceCustomDocumentEnrichmentConfigurationPreExtractionHookConfigurationArgs']] = None,
                 role_arn: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['DataSourceCustomDocumentEnrichmentConfigurationInlineConfigurationArgs']]] inline_configurations: Configuration information to alter document attributes or metadata fields and content when ingesting documents into Amazon Kendra. Minimum number of `0` items. Maximum number of `100` items. Detailed below.
        :param pulumi.Input['DataSourceCustomDocumentEnrichmentConfigurationPostExtractionHookConfigurationArgs'] post_extraction_hook_configuration: A block that specifies the configuration information for invoking a Lambda function in AWS Lambda on the structured documents with their metadata and text extracted. You can use a Lambda function to apply advanced logic for creating, modifying, or deleting document metadata and content. For more information, see [Advanced data manipulation](https://docs.aws.amazon.com/kendra/latest/dg/custom-document-enrichment.html#advanced-data-manipulation). Detailed below.
        :param pulumi.Input['DataSourceCustomDocumentEnrichmentConfigurationPreExtractionHookConfigurationArgs'] pre_extraction_hook_configuration: Configuration information for invoking a Lambda function in AWS Lambda on the original or raw documents before extracting their metadata and text. You can use a Lambda function to apply advanced logic for creating, modifying, or deleting document metadata and content. For more information, see [Advanced data manipulation](https://docs.aws.amazon.com/kendra/latest/dg/custom-document-enrichment.html#advanced-data-manipulation). Detailed below.
        :param pulumi.Input[str] role_arn: The Amazon Resource Name (ARN) of a role with permission to run `pre_extraction_hook_configuration` and `post_extraction_hook_configuration` for altering document metadata and content during the document ingestion process. For more information, see [IAM roles for Amazon Kendra](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html).
        """
        if inline_configurations is not None:
            pulumi.set(__self__, "inline_configurations", inline_configurations)
        if post_extraction_hook_configuration is not None:
            pulumi.set(__self__, "post_extraction_hook_configuration", post_extraction_hook_configuration)
        if pre_extraction_hook_configuration is not None:
            pulumi.set(__self__, "pre_extraction_hook_configuration", pre_extraction_hook_configuration)
        if role_arn is not None:
            pulumi.set(__self__, "role_arn", role_arn)

    @property
    @pulumi.getter(name="inlineConfigurations")
    def inline_configurations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DataSourceCustomDocumentEnrichmentConfigurationInlineConfigurationArgs']]]]:
        """
        Configuration information to alter document attributes or metadata fields and content when ingesting documents into Amazon Kendra. Minimum number of `0` items. Maximum number of `100` items. Detailed below.
        """
        return pulumi.get(self, "inline_configurations")

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

    @property
    @pulumi.getter(name="postExtractionHookConfiguration")
    def post_extraction_hook_configuration(self) -> Optional[pulumi.Input['DataSourceCustomDocumentEnrichmentConfigurationPostExtractionHookConfigurationArgs']]:
        """
        A block that specifies the configuration information for invoking a Lambda function in AWS Lambda on the structured documents with their metadata and text extracted. You can use a Lambda function to apply advanced logic for creating, modifying, or deleting document metadata and content. For more information, see [Advanced data manipulation](https://docs.aws.amazon.com/kendra/latest/dg/custom-document-enrichment.html#advanced-data-manipulation). Detailed below.
        """
        return pulumi.get(self, "post_extraction_hook_configuration")

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

    @property
    @pulumi.getter(name="preExtractionHookConfiguration")
    def pre_extraction_hook_configuration(self) -> Optional[pulumi.Input['DataSourceCustomDocumentEnrichmentConfigurationPreExtractionHookConfigurationArgs']]:
        """
        Configuration information for invoking a Lambda function in AWS Lambda on the original or raw documents before extracting their metadata and text. You can use a Lambda function to apply advanced logic for creating, modifying, or deleting document metadata and content. For more information, see [Advanced data manipulation](https://docs.aws.amazon.com/kendra/latest/dg/custom-document-enrichment.html#advanced-data-manipulation). Detailed below.
        """
        return pulumi.get(self, "pre_extraction_hook_configuration")

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

    @property
    @pulumi.getter(name="roleArn")
    def role_arn(self) -> Optional[pulumi.Input[str]]:
        """
        The Amazon Resource Name (ARN) of a role with permission to run `pre_extraction_hook_configuration` and `post_extraction_hook_configuration` for altering document metadata and content during the document ingestion process. For more information, see [IAM roles for Amazon Kendra](https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html).
        """
        return pulumi.get(self, "role_arn")

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


@pulumi.input_type
class DataSourceCustomDocumentEnrichmentConfigurationInlineConfigurationArgs:
    def __init__(__self__, *,
                 condition: Optional[pulumi.Input['DataSourceCustomDocumentEnrichmentConfigurationInlineConfigurationConditionArgs']] = None,
                 document_content_deletion: Optional[pulumi.Input[bool]] = None,
                 target: Optional[pulumi.Input['DataSourceCustomDocumentEnrichmentConfigurationInlineConfigurationTargetArgs']] = None):
        """
        :param pulumi.Input['DataSourceCustomDocumentEnrichmentConfigurationInlineConfigurationConditionArgs'] condition: Configuration of the condition used for the target document attribute or metadata field when ingesting documents into Amazon Kendra. See Document Attribute Condition.
        :param pulumi.Input[bool] document_content_deletion: `TRUE` to delete content if the condition used for the target attribute is met.
        :param pulumi.Input['DataSourceCustomDocumentEnrichmentConfigurationInlineConfigurationTargetArgs'] target: Configuration of the target document attribute or metadata field when ingesting documents into Amazon Kendra. You can also include a value. Detailed below.
        """
        if condition is not None:
            pulumi.set(__self__, "condition", condition)
        if document_content_deletion is not None:
            pulumi.set(__self__, "document_content_deletion", document_content_deletion)
        if target is not None:
            pulumi.set(__self__, "target", target)

    @property
    @pulumi.getter
    def condition(self) -> Optional[pulumi.Input['DataSourceCustomDocumentEnrichmentConfigurationInlineConfigurationConditionArgs']]:
        """
        Configuration of the condition used for the target document attribute or metadata field when ingesting documents into Amazon Kendra. See Document Attribute Condition.
        """
        return pulumi.get(self, "condition")

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

    @property
    @pulumi.getter(name="documentContentDeletion")
    def document_content_deletion(self) -> Optional[pulumi.Input[bool]]:
        """
        `TRUE` to delete content if the condition used for the target attribute is met.
        """
        return pulumi.get(self, "document_content_deletion")

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

    @property
    @pulumi.getter
    def target(self) -> Optional[pulumi.Input['DataSourceCustomDocumentEnrichmentConfigurationInlineConfigurationTargetArgs']]:
        """
        Configuration of the target document attribute or metadata field when ingesting documents into Amazon Kendra. You can also include a value. Detailed below.
        """
        return pulumi.get(self, "target")

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


@pulumi.input_type
class DataSourceCustomDocumentEnrichmentConfigurationInlineConfigurationConditionArgs:
    def __init__(__self__, *,
                 condition_document_attribute_key: pulumi.Input[str],
                 operator: pulumi.Input[str],
                 condition_on_value: Optional[pulumi.Input['DataSourceCustomDocumentEnrichmentConfigurationInlineConfigurationConditionConditionOnValueArgs']] = None):
        """
        :param pulumi.Input[str] condition_document_attribute_key: The identifier of the document attribute used for the condition. For example, `_source_uri` could be an identifier for the attribute or metadata field that contains source URIs associated with the documents. Amazon Kendra currently does not support `_document_body` as an attribute key used for the condition.
        :param pulumi.Input[str] operator: The condition operator. For example, you can use `Contains` to partially match a string. Valid Values: `GreaterThan` | `GreaterThanOrEquals` | `LessThan` | `LessThanOrEquals` | `Equals` | `NotEquals` | `Contains` | `NotContains` | `Exists` | `NotExists` | `BeginsWith`.
        :param pulumi.Input['DataSourceCustomDocumentEnrichmentConfigurationInlineConfigurationConditionConditionOnValueArgs'] condition_on_value: The value used by the operator. For example, you can specify the value 'financial' for strings in the `_source_uri` field that partially match or contain this value. See Document Attribute Value.
        """
        pulumi.set(__self__, "condition_document_attribute_key", condition_document_attribute_key)
        pulumi.set(__self__, "operator", operator)
        if condition_on_value is not None:
            pulumi.set(__self__, "condition_on_value", condition_on_value)

    @property
    @pulumi.getter(name="conditionDocumentAttributeKey")
    def condition_document_attribute_key(self) -> pulumi.Input[str]:
        """
        The identifier of the document attribute used for the condition. For example, `_source_uri` could be an identifier for the attribute or metadata field that contains source URIs associated with the documents. Amazon Kendra currently does not support `_document_body` as an attribute key used for the condition.
        """
        return pulumi.get(self, "condition_document_attribute_key")

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

    @property
    @pulumi.getter
    def operator(self) -> pulumi.Input[str]:
        """
        The condition operator. For example, you can use `Contains` to partially match a string. Valid Values: `GreaterThan` | `GreaterThanOrEquals` | `LessThan` | `LessThanOrEquals` | `Equals` | `NotEquals` | `Contains` | `NotContains` | `Exists` | `NotExists` | `BeginsWith`.
        """
        return pulumi.get(self, "operator")

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

    @property
    @pulumi.getter(name="conditionOnValue")
    def condition_on_value(self) -> Optional[pulumi.Input['DataSourceCustomDocumentEnrichmentConfigurationInlineConfigurationConditionConditionOnValueArgs']]:
        """
        The value used by the operator. For example, you can specify the value 'financial' for strings in the `_source_uri` field that partially match or contain this value. See Document Attribute Value.
        """
        return pulumi.get(self, "condition_on_value")

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


@pulumi.input_type
class DataSourceCustomDocumentEnrichmentConfigurationInlineConfigurationConditionConditionOnValueArgs:
    def __init__(__self__, *,
                 date_value: Optional[pulumi.Input[str]] = None,
                 long_value: Optional[pulumi.Input[int]] = None,
                 string_list_values: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 string_value: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] date_value: A date expressed as an ISO 8601 string. It is important for the time zone to be included in the ISO 8601 date-time format. As of this writing only UTC is supported. For example, `2012-03-25T12:30:10+00:00`.
        :param pulumi.Input[int] long_value: A long integer value.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] string_list_values: A list of strings.
        """
        if date_value is not None:
            pulumi.set(__self__, "date_value", date_value)
        if long_value is not None:
            pulumi.set(__self__, "long_value", long_value)
        if string_list_values is not None:
            pulumi.set(__self__, "string_list_values", string_list_values)
        if string_value is not None:
            pulumi.set(__self__, "string_value", string_value)

    @property
    @pulumi.getter(name="dateValue")
    def date_value(self) -> Optional[pulumi.Input[str]]:
        """
        A date expressed as an ISO 8601 string. It is important for the time zone to be included in the ISO 8601 date-time format. As of this writing only UTC is supported. For example, `2012-03-25T12:30:10+00:00`.
        """
        return pulumi.get(self, "date_value")

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

    @property
    @pulumi.getter(name="longValue")
    def long_value(self) -> Optional[pulumi.Input[int]]:
        """
        A long integer value.
        """
        return pulumi.get(self, "long_value")

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

    @property
    @pulumi.getter(name="stringListValues")
    def string_list_values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        A list of strings.
        """
        return pulumi.get(self, "string_list_values")

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

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

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


@pulumi.input_type
class DataSourceCustomDocumentEnrichmentConfigurationInlineConfigurationTargetArgs:
    def __init__(__self__, *,
                 target_document_attribute_key: Optional[pulumi.Input[str]] = None,
                 target_document_attribute_value: Optional[pulumi.Input['DataSourceCustomDocumentEnrichmentConfigurationInlineConfigurationTargetTargetDocumentAttributeValueArgs']] = None,
                 target_document_attribute_value_deletion: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[str] target_document_attribute_key: The identifier of the target document attribute or metadata field. For example, 'Department' could be an identifier for the target attribute or metadata field that includes the department names associated with the documents.
        :param pulumi.Input['DataSourceCustomDocumentEnrichmentConfigurationInlineConfigurationTargetTargetDocumentAttributeValueArgs'] target_document_attribute_value: The target value you want to create for the target attribute. For example, 'Finance' could be the target value for the target attribute key 'Department'.
               See Document Attribute Value.
        :param pulumi.Input[bool] target_document_attribute_value_deletion: `TRUE` to delete the existing target value for your specified target attribute key. You cannot create a target value and set this to `TRUE`. To create a target value (`TargetDocumentAttributeValue`), set this to `FALSE`.
        """
        if target_document_attribute_key is not None:
            pulumi.set(__self__, "target_document_attribute_key", target_document_attribute_key)
        if target_document_attribute_value is not None:
            pulumi.set(__self__, "target_document_attribute_value", target_document_attribute_value)
        if target_document_attribute_value_deletion is not None:
            pulumi.set(__self__, "target_document_attribute_value_deletion", target_document_attribute_value_deletion)

    @property
    @pulumi.getter(name="targetDocumentAttributeKey")
    def target_document_attribute_key(self) -> Optional[pulumi.Input[str]]:
        """
        The identifier of the target document attribute or metadata field. For example, 'Department' could be an identifier for the target attribute or metadata field that includes the department names associated with the documents.
        """
        return pulumi.get(self, "target_document_attribute_key")

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

    @property
    @pulumi.getter(name="targetDocumentAttributeValue")
    def target_document_attribute_value(self) -> Optional[pulumi.Input['DataSourceCustomDocumentEnrichmentConfigurationInlineConfigurationTargetTargetDocumentAttributeValueArgs']]:
        """
        The target value you want to create for the target attribute. For example, 'Finance' could be the target value for the target attribute key 'Department'.
        See Document Attribute Value.
        """
        return pulumi.get(self, "target_document_attribute_value")

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

    @property
    @pulumi.getter(name="targetDocumentAttributeValueDeletion")
    def target_document_attribute_value_deletion(self) -> Optional[pulumi.Input[bool]]:
        """
        `TRUE` to delete the existing target value for your specified target attribute key. You cannot create a target value and set this to `TRUE`. To create a target value (`TargetDocumentAttributeValue`), set this to `FALSE`.
        """
        return pulumi.get(self, "target_document_attribute_value_deletion")

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


@pulumi.input_type
class DataSourceCustomDocumentEnrichmentConfigurationInlineConfigurationTargetTargetDocumentAttributeValueArgs:
    def __init__(__self__, *,
                 date_value: Optional[pulumi.Input[str]] = None,
                 long_value: Optional[pulumi.Input[int]] = None,
                 string_list_values: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 string_value: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] date_value: A date expressed as an ISO 8601 string. It is important for the time zone to be included in the ISO 8601 date-time format. As of this writing only UTC is supported. For example, `2012-03-25T12:30:10+00:00`.
        :param pulumi.Input[int] long_value: A long integer value.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] string_list_values: A list of strings.
        """
        if date_value is not None:
            pulumi.set(__self__, "date_value", date_value)
        if long_value is not None:
            pulumi.set(__self__, "long_value", long_value)
        if string_list_values is not None:
            pulumi.set(__self__, "string_list_values", string_list_values)
        if string_value is not None:
            pulumi.set(__self__, "string_value", string_value)

    @property
    @pulumi.getter(name="dateValue")
    def date_value(self) -> Optional[pulumi.Input[str]]:
        """
        A date expressed as an ISO 8601 string. It is important for the time zone to be included in the ISO 8601 date-time format. As of this writing only UTC is supported. For example, `2012-03-25T12:30:10+00:00`.
        """
        return pulumi.get(self, "date_value")

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

    @property
    @pulumi.getter(name="longValue")
    def long_value(self) -> Optional[pulumi.Input[int]]:
        """
        A long integer value.
        """
        return pulumi.get(self, "long_value")

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

    @property
    @pulumi.getter(name="stringListValues")
    def string_list_values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        A list of strings.
        """
        return pulumi.get(self, "string_list_values")

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

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

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


@pulumi.input_type
class DataSourceCustomDocumentEnrichmentConfigurationPostExtractionHookConfigurationArgs:
    def __init__(__self__, *,
                 lambda_arn: pulumi.Input[str],
                 s3_bucket: pulumi.Input[str],
                 invocation_condition: Optional[pulumi.Input['DataSourceCustomDocumentEnrichmentConfigurationPostExtractionHookConfigurationInvocationConditionArgs']] = None):
        """
        :param pulumi.Input[str] lambda_arn: The Amazon Resource Name (ARN) of a Lambda Function that can manipulate your document metadata fields or attributes and content.
        :param pulumi.Input[str] s3_bucket: Stores the original, raw documents or the structured, parsed documents before and after altering them. For more information, see [Data contracts for Lambda functions](https://docs.aws.amazon.com/kendra/latest/dg/custom-document-enrichment.html#cde-data-contracts-lambda).
        :param pulumi.Input['DataSourceCustomDocumentEnrichmentConfigurationPostExtractionHookConfigurationInvocationConditionArgs'] invocation_condition: A block that specifies the condition used for when a Lambda function should be invoked. For example, you can specify a condition that if there are empty date-time values, then Amazon Kendra should invoke a function that inserts the current date-time. See Document Attribute Condition.
        """
        pulumi.set(__self__, "lambda_arn", lambda_arn)
        pulumi.set(__self__, "s3_bucket", s3_bucket)
        if invocation_condition is not None:
            pulumi.set(__self__, "invocation_condition", invocation_condition)

    @property
    @pulumi.getter(name="lambdaArn")
    def lambda_arn(self) -> pulumi.Input[str]:
        """
        The Amazon Resource Name (ARN) of a Lambda Function that can manipulate your document metadata fields or attributes and content.
        """
        return pulumi.get(self, "lambda_arn")

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

    @property
    @pulumi.getter(name="s3Bucket")
    def s3_bucket(self) -> pulumi.Input[str]:
        """
        Stores the original, raw documents or the structured, parsed documents before and after altering them. For more information, see [Data contracts for Lambda functions](https://docs.aws.amazon.com/kendra/latest/dg/custom-document-enrichment.html#cde-data-contracts-lambda).
        """
        return pulumi.get(self, "s3_bucket")

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

    @property
    @pulumi.getter(name="invocationCondition")
    def invocation_condition(self) -> Optional[pulumi.Input['DataSourceCustomDocumentEnrichmentConfigurationPostExtractionHookConfigurationInvocationConditionArgs']]:
        """
        A block that specifies the condition used for when a Lambda function should be invoked. For example, you can specify a condition that if there are empty date-time values, then Amazon Kendra should invoke a function that inserts the current date-time. See Document Attribute Condition.
        """
        return pulumi.get(self, "invocation_condition")

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


@pulumi.input_type
class DataSourceCustomDocumentEnrichmentConfigurationPostExtractionHookConfigurationInvocationConditionArgs:
    def __init__(__self__, *,
                 condition_document_attribute_key: pulumi.Input[str],
                 operator: pulumi.Input[str],
                 condition_on_value: Optional[pulumi.Input['DataSourceCustomDocumentEnrichmentConfigurationPostExtractionHookConfigurationInvocationConditionConditionOnValueArgs']] = None):
        """
        :param pulumi.Input[str] condition_document_attribute_key: The identifier of the document attribute used for the condition. For example, `_source_uri` could be an identifier for the attribute or metadata field that contains source URIs associated with the documents. Amazon Kendra currently does not support `_document_body` as an attribute key used for the condition.
        :param pulumi.Input[str] operator: The condition operator. For example, you can use `Contains` to partially match a string. Valid Values: `GreaterThan` | `GreaterThanOrEquals` | `LessThan` | `LessThanOrEquals` | `Equals` | `NotEquals` | `Contains` | `NotContains` | `Exists` | `NotExists` | `BeginsWith`.
        :param pulumi.Input['DataSourceCustomDocumentEnrichmentConfigurationPostExtractionHookConfigurationInvocationConditionConditionOnValueArgs'] condition_on_value: The value used by the operator. For example, you can specify the value 'financial' for strings in the `_source_uri` field that partially match or contain this value. See Document Attribute Value.
        """
        pulumi.set(__self__, "condition_document_attribute_key", condition_document_attribute_key)
        pulumi.set(__self__, "operator", operator)
        if condition_on_value is not None:
            pulumi.set(__self__, "condition_on_value", condition_on_value)

    @property
    @pulumi.getter(name="conditionDocumentAttributeKey")
    def condition_document_attribute_key(self) -> pulumi.Input[str]:
        """
        The identifier of the document attribute used for the condition. For example, `_source_uri` could be an identifier for the attribute or metadata field that contains source URIs associated with the documents. Amazon Kendra currently does not support `_document_body` as an attribute key used for the condition.
        """
        return pulumi.get(self, "condition_document_attribute_key")

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

    @property
    @pulumi.getter
    def operator(self) -> pulumi.Input[str]:
        """
        The condition operator. For example, you can use `Contains` to partially match a string. Valid Values: `GreaterThan` | `GreaterThanOrEquals` | `LessThan` | `LessThanOrEquals` | `Equals` | `NotEquals` | `Contains` | `NotContains` | `Exists` | `NotExists` | `BeginsWith`.
        """
        return pulumi.get(self, "operator")

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

    @property
    @pulumi.getter(name="conditionOnValue")
    def condition_on_value(self) -> Optional[pulumi.Input['DataSourceCustomDocumentEnrichmentConfigurationPostExtractionHookConfigurationInvocationConditionConditionOnValueArgs']]:
        """
        The value used by the operator. For example, you can specify the value 'financial' for strings in the `_source_uri` field that partially match or contain this value. See Document Attribute Value.
        """
        return pulumi.get(self, "condition_on_value")

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


@pulumi.input_type
class DataSourceCustomDocumentEnrichmentConfigurationPostExtractionHookConfigurationInvocationConditionConditionOnValueArgs:
    def __init__(__self__, *,
                 date_value: Optional[pulumi.Input[str]] = None,
                 long_value: Optional[pulumi.Input[int]] = None,
                 string_list_values: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 string_value: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] date_value: A date expressed as an ISO 8601 string. It is important for the time zone to be included in the ISO 8601 date-time format. As of this writing only UTC is supported. For example, `2012-03-25T12:30:10+00:00`.
        :param pulumi.Input[int] long_value: A long integer value.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] string_list_values: A list of strings.
        """
        if date_value is not None:
            pulumi.set(__self__, "date_value", date_value)
        if long_value is not None:
            pulumi.set(__self__, "long_value", long_value)
        if string_list_values is not None:
            pulumi.set(__self__, "string_list_values", string_list_values)
        if string_value is not None:
            pulumi.set(__self__, "string_value", string_value)

    @property
    @pulumi.getter(name="dateValue")
    def date_value(self) -> Optional[pulumi.Input[str]]:
        """
        A date expressed as an ISO 8601 string. It is important for the time zone to be included in the ISO 8601 date-time format. As of this writing only UTC is supported. For example, `2012-03-25T12:30:10+00:00`.
        """
        return pulumi.get(self, "date_value")

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

    @property
    @pulumi.getter(name="longValue")
    def long_value(self) -> Optional[pulumi.Input[int]]:
        """
        A long integer value.
        """
        return pulumi.get(self, "long_value")

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

    @property
    @pulumi.getter(name="stringListValues")
    def string_list_values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        A list of strings.
        """
        return pulumi.get(self, "string_list_values")

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

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

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


@pulumi.input_type
class DataSourceCustomDocumentEnrichmentConfigurationPreExtractionHookConfigurationArgs:
    def __init__(__self__, *,
                 lambda_arn: pulumi.Input[str],
                 s3_bucket: pulumi.Input[str],
                 invocation_condition: Optional[pulumi.Input['DataSourceCustomDocumentEnrichmentConfigurationPreExtractionHookConfigurationInvocationConditionArgs']] = None):
        """
        :param pulumi.Input[str] lambda_arn: The Amazon Resource Name (ARN) of a Lambda Function that can manipulate your document metadata fields or attributes and content.
        :param pulumi.Input[str] s3_bucket: Stores the original, raw documents or the structured, parsed documents before and after altering them. For more information, see [Data contracts for Lambda functions](https://docs.aws.amazon.com/kendra/latest/dg/custom-document-enrichment.html#cde-data-contracts-lambda).
        :param pulumi.Input['DataSourceCustomDocumentEnrichmentConfigurationPreExtractionHookConfigurationInvocationConditionArgs'] invocation_condition: A block that specifies the condition used for when a Lambda function should be invoked. For example, you can specify a condition that if there are empty date-time values, then Amazon Kendra should invoke a function that inserts the current date-time. See Document Attribute Condition.
        """
        pulumi.set(__self__, "lambda_arn", lambda_arn)
        pulumi.set(__self__, "s3_bucket", s3_bucket)
        if invocation_condition is not None:
            pulumi.set(__self__, "invocation_condition", invocation_condition)

    @property
    @pulumi.getter(name="lambdaArn")
    def lambda_arn(self) -> pulumi.Input[str]:
        """
        The Amazon Resource Name (ARN) of a Lambda Function that can manipulate your document metadata fields or attributes and content.
        """
        return pulumi.get(self, "lambda_arn")

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

    @property
    @pulumi.getter(name="s3Bucket")
    def s3_bucket(self) -> pulumi.Input[str]:
        """
        Stores the original, raw documents or the structured, parsed documents before and after altering them. For more information, see [Data contracts for Lambda functions](https://docs.aws.amazon.com/kendra/latest/dg/custom-document-enrichment.html#cde-data-contracts-lambda).
        """
        return pulumi.get(self, "s3_bucket")

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

    @property
    @pulumi.getter(name="invocationCondition")
    def invocation_condition(self) -> Optional[pulumi.Input['DataSourceCustomDocumentEnrichmentConfigurationPreExtractionHookConfigurationInvocationConditionArgs']]:
        """
        A block that specifies the condition used for when a Lambda function should be invoked. For example, you can specify a condition that if there are empty date-time values, then Amazon Kendra should invoke a function that inserts the current date-time. See Document Attribute Condition.
        """
        return pulumi.get(self, "invocation_condition")

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


@pulumi.input_type
class DataSourceCustomDocumentEnrichmentConfigurationPreExtractionHookConfigurationInvocationConditionArgs:
    def __init__(__self__, *,
                 condition_document_attribute_key: pulumi.Input[str],
                 operator: pulumi.Input[str],
                 condition_on_value: Optional[pulumi.Input['DataSourceCustomDocumentEnrichmentConfigurationPreExtractionHookConfigurationInvocationConditionConditionOnValueArgs']] = None):
        """
        :param pulumi.Input[str] condition_document_attribute_key: The identifier of the document attribute used for the condition. For example, `_source_uri` could be an identifier for the attribute or metadata field that contains source URIs associated with the documents. Amazon Kendra currently does not support `_document_body` as an attribute key used for the condition.
        :param pulumi.Input[str] operator: The condition operator. For example, you can use `Contains` to partially match a string. Valid Values: `GreaterThan` | `GreaterThanOrEquals` | `LessThan` | `LessThanOrEquals` | `Equals` | `NotEquals` | `Contains` | `NotContains` | `Exists` | `NotExists` | `BeginsWith`.
        :param pulumi.Input['DataSourceCustomDocumentEnrichmentConfigurationPreExtractionHookConfigurationInvocationConditionConditionOnValueArgs'] condition_on_value: The value used by the operator. For example, you can specify the value 'financial' for strings in the `_source_uri` field that partially match or contain this value. See Document Attribute Value.
        """
        pulumi.set(__self__, "condition_document_attribute_key", condition_document_attribute_key)
        pulumi.set(__self__, "operator", operator)
        if condition_on_value is not None:
            pulumi.set(__self__, "condition_on_value", condition_on_value)

    @property
    @pulumi.getter(name="conditionDocumentAttributeKey")
    def condition_document_attribute_key(self) -> pulumi.Input[str]:
        """
        The identifier of the document attribute used for the condition. For example, `_source_uri` could be an identifier for the attribute or metadata field that contains source URIs associated with the documents. Amazon Kendra currently does not support `_document_body` as an attribute key used for the condition.
        """
        return pulumi.get(self, "condition_document_attribute_key")

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

    @property
    @pulumi.getter
    def operator(self) -> pulumi.Input[str]:
        """
        The condition operator. For example, you can use `Contains` to partially match a string. Valid Values: `GreaterThan` | `GreaterThanOrEquals` | `LessThan` | `LessThanOrEquals` | `Equals` | `NotEquals` | `Contains` | `NotContains` | `Exists` | `NotExists` | `BeginsWith`.
        """
        return pulumi.get(self, "operator")

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

    @property
    @pulumi.getter(name="conditionOnValue")
    def condition_on_value(self) -> Optional[pulumi.Input['DataSourceCustomDocumentEnrichmentConfigurationPreExtractionHookConfigurationInvocationConditionConditionOnValueArgs']]:
        """
        The value used by the operator. For example, you can specify the value 'financial' for strings in the `_source_uri` field that partially match or contain this value. See Document Attribute Value.
        """
        return pulumi.get(self, "condition_on_value")

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


@pulumi.input_type
class DataSourceCustomDocumentEnrichmentConfigurationPreExtractionHookConfigurationInvocationConditionConditionOnValueArgs:
    def __init__(__self__, *,
                 date_value: Optional[pulumi.Input[str]] = None,
                 long_value: Optional[pulumi.Input[int]] = None,
                 string_list_values: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 string_value: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] date_value: A date expressed as an ISO 8601 string. It is important for the time zone to be included in the ISO 8601 date-time format. As of this writing only UTC is supported. For example, `2012-03-25T12:30:10+00:00`.
        :param pulumi.Input[int] long_value: A long integer value.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] string_list_values: A list of strings.
        """
        if date_value is not None:
            pulumi.set(__self__, "date_value", date_value)
        if long_value is not None:
            pulumi.set(__self__, "long_value", long_value)
        if string_list_values is not None:
            pulumi.set(__self__, "string_list_values", string_list_values)
        if string_value is not None:
            pulumi.set(__self__, "string_value", string_value)

    @property
    @pulumi.getter(name="dateValue")
    def date_value(self) -> Optional[pulumi.Input[str]]:
        """
        A date expressed as an ISO 8601 string. It is important for the time zone to be included in the ISO 8601 date-time format. As of this writing only UTC is supported. For example, `2012-03-25T12:30:10+00:00`.
        """
        return pulumi.get(self, "date_value")

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

    @property
    @pulumi.getter(name="longValue")
    def long_value(self) -> Optional[pulumi.Input[int]]:
        """
        A long integer value.
        """
        return pulumi.get(self, "long_value")

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

    @property
    @pulumi.getter(name="stringListValues")
    def string_list_values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        A list of strings.
        """
        return pulumi.get(self, "string_list_values")

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

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

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


@pulumi.input_type
class ExperienceConfigurationArgs:
    def __init__(__self__, *,
                 content_source_configuration: Optional[pulumi.Input['ExperienceConfigurationContentSourceConfigurationArgs']] = None,
                 user_identity_configuration: Optional[pulumi.Input['ExperienceConfigurationUserIdentityConfigurationArgs']] = None):
        """
        :param pulumi.Input['ExperienceConfigurationContentSourceConfigurationArgs'] content_source_configuration: The identifiers of your data sources and FAQs. Or, you can specify that you want to use documents indexed via the `BatchPutDocument API`. The provider will only perform drift detection of its value when present in a configuration. Detailed below.
        :param pulumi.Input['ExperienceConfigurationUserIdentityConfigurationArgs'] user_identity_configuration: The AWS SSO field name that contains the identifiers of your users, such as their emails. Detailed below.
        """
        if content_source_configuration is not None:
            pulumi.set(__self__, "content_source_configuration", content_source_configuration)
        if user_identity_configuration is not None:
            pulumi.set(__self__, "user_identity_configuration", user_identity_configuration)

    @property
    @pulumi.getter(name="contentSourceConfiguration")
    def content_source_configuration(self) -> Optional[pulumi.Input['ExperienceConfigurationContentSourceConfigurationArgs']]:
        """
        The identifiers of your data sources and FAQs. Or, you can specify that you want to use documents indexed via the `BatchPutDocument API`. The provider will only perform drift detection of its value when present in a configuration. Detailed below.
        """
        return pulumi.get(self, "content_source_configuration")

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

    @property
    @pulumi.getter(name="userIdentityConfiguration")
    def user_identity_configuration(self) -> Optional[pulumi.Input['ExperienceConfigurationUserIdentityConfigurationArgs']]:
        """
        The AWS SSO field name that contains the identifiers of your users, such as their emails. Detailed below.
        """
        return pulumi.get(self, "user_identity_configuration")

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


@pulumi.input_type
class ExperienceConfigurationContentSourceConfigurationArgs:
    def __init__(__self__, *,
                 data_source_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 direct_put_content: Optional[pulumi.Input[bool]] = None,
                 faq_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input[str]]] data_source_ids: The identifiers of the data sources you want to use for your Amazon Kendra experience. Maximum number of 100 items.
        :param pulumi.Input[bool] direct_put_content: Whether to use documents you indexed directly using the `BatchPutDocument API`. Defaults to `false`.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] faq_ids: The identifier of the FAQs that you want to use for your Amazon Kendra experience. Maximum number of 100 items.
        """
        if data_source_ids is not None:
            pulumi.set(__self__, "data_source_ids", data_source_ids)
        if direct_put_content is not None:
            pulumi.set(__self__, "direct_put_content", direct_put_content)
        if faq_ids is not None:
            pulumi.set(__self__, "faq_ids", faq_ids)

    @property
    @pulumi.getter(name="dataSourceIds")
    def data_source_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        The identifiers of the data sources you want to use for your Amazon Kendra experience. Maximum number of 100 items.
        """
        return pulumi.get(self, "data_source_ids")

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

    @property
    @pulumi.getter(name="directPutContent")
    def direct_put_content(self) -> Optional[pulumi.Input[bool]]:
        """
        Whether to use documents you indexed directly using the `BatchPutDocument API`. Defaults to `false`.
        """
        return pulumi.get(self, "direct_put_content")

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

    @property
    @pulumi.getter(name="faqIds")
    def faq_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        The identifier of the FAQs that you want to use for your Amazon Kendra experience. Maximum number of 100 items.
        """
        return pulumi.get(self, "faq_ids")

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


@pulumi.input_type
class ExperienceConfigurationUserIdentityConfigurationArgs:
    def __init__(__self__, *,
                 identity_attribute_name: pulumi.Input[str]):
        """
        :param pulumi.Input[str] identity_attribute_name: The AWS SSO field name that contains the identifiers of your users, such as their emails.
        """
        pulumi.set(__self__, "identity_attribute_name", identity_attribute_name)

    @property
    @pulumi.getter(name="identityAttributeName")
    def identity_attribute_name(self) -> pulumi.Input[str]:
        """
        The AWS SSO field name that contains the identifiers of your users, such as their emails.
        """
        return pulumi.get(self, "identity_attribute_name")

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


@pulumi.input_type
class ExperienceEndpointArgs:
    def __init__(__self__, *,
                 endpoint: Optional[pulumi.Input[str]] = None,
                 endpoint_type: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] endpoint: The endpoint of your Amazon Kendra experience.
        :param pulumi.Input[str] endpoint_type: The type of endpoint for your Amazon Kendra experience.
        """
        if endpoint is not None:
            pulumi.set(__self__, "endpoint", endpoint)
        if endpoint_type is not None:
            pulumi.set(__self__, "endpoint_type", endpoint_type)

    @property
    @pulumi.getter
    def endpoint(self) -> Optional[pulumi.Input[str]]:
        """
        The endpoint of your Amazon Kendra experience.
        """
        return pulumi.get(self, "endpoint")

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

    @property
    @pulumi.getter(name="endpointType")
    def endpoint_type(self) -> Optional[pulumi.Input[str]]:
        """
        The type of endpoint for your Amazon Kendra experience.
        """
        return pulumi.get(self, "endpoint_type")

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


@pulumi.input_type
class FaqS3PathArgs:
    def __init__(__self__, *,
                 bucket: pulumi.Input[str],
                 key: pulumi.Input[str]):
        """
        :param pulumi.Input[str] bucket: The name of the S3 bucket that contains the file.
        :param pulumi.Input[str] key: The name of the file.
        """
        pulumi.set(__self__, "bucket", bucket)
        pulumi.set(__self__, "key", key)

    @property
    @pulumi.getter
    def bucket(self) -> pulumi.Input[str]:
        """
        The name of the S3 bucket that contains the file.
        """
        return pulumi.get(self, "bucket")

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

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

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


@pulumi.input_type
class IndexCapacityUnitsArgs:
    def __init__(__self__, *,
                 query_capacity_units: Optional[pulumi.Input[int]] = None,
                 storage_capacity_units: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[int] query_capacity_units: The amount of extra query capacity for an index and GetQuerySuggestions capacity. For more information, refer to [QueryCapacityUnits](https://docs.aws.amazon.com/kendra/latest/dg/API_CapacityUnitsConfiguration.html#Kendra-Type-CapacityUnitsConfiguration-QueryCapacityUnits).
        :param pulumi.Input[int] storage_capacity_units: The amount of extra storage capacity for an index. A single capacity unit provides 30 GB of storage space or 100,000 documents, whichever is reached first. Minimum value of 0.
        """
        if query_capacity_units is not None:
            pulumi.set(__self__, "query_capacity_units", query_capacity_units)
        if storage_capacity_units is not None:
            pulumi.set(__self__, "storage_capacity_units", storage_capacity_units)

    @property
    @pulumi.getter(name="queryCapacityUnits")
    def query_capacity_units(self) -> Optional[pulumi.Input[int]]:
        """
        The amount of extra query capacity for an index and GetQuerySuggestions capacity. For more information, refer to [QueryCapacityUnits](https://docs.aws.amazon.com/kendra/latest/dg/API_CapacityUnitsConfiguration.html#Kendra-Type-CapacityUnitsConfiguration-QueryCapacityUnits).
        """
        return pulumi.get(self, "query_capacity_units")

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

    @property
    @pulumi.getter(name="storageCapacityUnits")
    def storage_capacity_units(self) -> Optional[pulumi.Input[int]]:
        """
        The amount of extra storage capacity for an index. A single capacity unit provides 30 GB of storage space or 100,000 documents, whichever is reached first. Minimum value of 0.
        """
        return pulumi.get(self, "storage_capacity_units")

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


@pulumi.input_type
class IndexDocumentMetadataConfigurationUpdateArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 type: pulumi.Input[str],
                 relevance: Optional[pulumi.Input['IndexDocumentMetadataConfigurationUpdateRelevanceArgs']] = None,
                 search: Optional[pulumi.Input['IndexDocumentMetadataConfigurationUpdateSearchArgs']] = None):
        """
        :param pulumi.Input[str] name: The name of the index field. Minimum length of 1. Maximum length of 30.
        :param pulumi.Input[str] type: The data type of the index field. Valid values are `STRING_VALUE`, `STRING_LIST_VALUE`, `LONG_VALUE`, `DATE_VALUE`.
        :param pulumi.Input['IndexDocumentMetadataConfigurationUpdateRelevanceArgs'] relevance: A block that provides manual tuning parameters to determine how the field affects the search results. Detailed below
        :param pulumi.Input['IndexDocumentMetadataConfigurationUpdateSearchArgs'] search: A block that provides information about how the field is used during a search. Documented below. Detailed below
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "type", type)
        if relevance is not None:
            pulumi.set(__self__, "relevance", relevance)
        if search is not None:
            pulumi.set(__self__, "search", search)

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        The name of the index field. Minimum length of 1. Maximum length of 30.
        """
        return pulumi.get(self, "name")

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

    @property
    @pulumi.getter
    def type(self) -> pulumi.Input[str]:
        """
        The data type of the index field. Valid values are `STRING_VALUE`, `STRING_LIST_VALUE`, `LONG_VALUE`, `DATE_VALUE`.
        """
        return pulumi.get(self, "type")

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

    @property
    @pulumi.getter
    def relevance(self) -> Optional[pulumi.Input['IndexDocumentMetadataConfigurationUpdateRelevanceArgs']]:
        """
        A block that provides manual tuning parameters to determine how the field affects the search results. Detailed below
        """
        return pulumi.get(self, "relevance")

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

    @property
    @pulumi.getter
    def search(self) -> Optional[pulumi.Input['IndexDocumentMetadataConfigurationUpdateSearchArgs']]:
        """
        A block that provides information about how the field is used during a search. Documented below. Detailed below
        """
        return pulumi.get(self, "search")

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


@pulumi.input_type
class IndexDocumentMetadataConfigurationUpdateRelevanceArgs:
    def __init__(__self__, *,
                 duration: Optional[pulumi.Input[str]] = None,
                 freshness: Optional[pulumi.Input[bool]] = None,
                 importance: Optional[pulumi.Input[int]] = None,
                 rank_order: Optional[pulumi.Input[str]] = None,
                 values_importance_map: Optional[pulumi.Input[Mapping[str, pulumi.Input[int]]]] = None):
        """
        :param pulumi.Input[str] duration: Specifies the time period that the boost applies to. For more information, refer to [Duration](https://docs.aws.amazon.com/kendra/latest/dg/API_Relevance.html#Kendra-Type-Relevance-Duration).
        :param pulumi.Input[bool] freshness: Indicates that this field determines how "fresh" a document is. For more information, refer to [Freshness](https://docs.aws.amazon.com/kendra/latest/dg/API_Relevance.html#Kendra-Type-Relevance-Freshness).
        :param pulumi.Input[int] importance: The relative importance of the field in the search. Larger numbers provide more of a boost than smaller numbers. Minimum value of 1. Maximum value of 10.
        :param pulumi.Input[str] rank_order: Determines how values should be interpreted. For more information, refer to [RankOrder](https://docs.aws.amazon.com/kendra/latest/dg/API_Relevance.html#Kendra-Type-Relevance-RankOrder).
        :param pulumi.Input[Mapping[str, pulumi.Input[int]]] values_importance_map: A list of values that should be given a different boost when they appear in the result list. For more information, refer to [ValueImportanceMap](https://docs.aws.amazon.com/kendra/latest/dg/API_Relevance.html#Kendra-Type-Relevance-ValueImportanceMap).
        """
        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 values_importance_map is not None:
            pulumi.set(__self__, "values_importance_map", values_importance_map)

    @property
    @pulumi.getter
    def duration(self) -> Optional[pulumi.Input[str]]:
        """
        Specifies the time period that the boost applies to. For more information, refer to [Duration](https://docs.aws.amazon.com/kendra/latest/dg/API_Relevance.html#Kendra-Type-Relevance-Duration).
        """
        return pulumi.get(self, "duration")

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

    @property
    @pulumi.getter
    def freshness(self) -> Optional[pulumi.Input[bool]]:
        """
        Indicates that this field determines how "fresh" a document is. For more information, refer to [Freshness](https://docs.aws.amazon.com/kendra/latest/dg/API_Relevance.html#Kendra-Type-Relevance-Freshness).
        """
        return pulumi.get(self, "freshness")

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

    @property
    @pulumi.getter
    def importance(self) -> Optional[pulumi.Input[int]]:
        """
        The relative importance of the field in the search. Larger numbers provide more of a boost than smaller numbers. Minimum value of 1. Maximum value of 10.
        """
        return pulumi.get(self, "importance")

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

    @property
    @pulumi.getter(name="rankOrder")
    def rank_order(self) -> Optional[pulumi.Input[str]]:
        """
        Determines how values should be interpreted. For more information, refer to [RankOrder](https://docs.aws.amazon.com/kendra/latest/dg/API_Relevance.html#Kendra-Type-Relevance-RankOrder).
        """
        return pulumi.get(self, "rank_order")

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

    @property
    @pulumi.getter(name="valuesImportanceMap")
    def values_importance_map(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[int]]]]:
        """
        A list of values that should be given a different boost when they appear in the result list. For more information, refer to [ValueImportanceMap](https://docs.aws.amazon.com/kendra/latest/dg/API_Relevance.html#Kendra-Type-Relevance-ValueImportanceMap).
        """
        return pulumi.get(self, "values_importance_map")

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


@pulumi.input_type
class IndexDocumentMetadataConfigurationUpdateSearchArgs:
    def __init__(__self__, *,
                 displayable: Optional[pulumi.Input[bool]] = None,
                 facetable: Optional[pulumi.Input[bool]] = None,
                 searchable: Optional[pulumi.Input[bool]] = None,
                 sortable: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[bool] displayable: Determines whether the field is returned in the query response. The default is `true`.
        :param pulumi.Input[bool] facetable: Indicates that the field can be used to create search facets, a count of results for each value in the field. The default is `false`.
        :param pulumi.Input[bool] searchable: Determines whether the field is used in the search. If the Searchable field is true, you can use relevance tuning to manually tune how Amazon Kendra weights the field in the search. The default is `true` for `string` fields and `false` for `number` and `date` fields.
        :param pulumi.Input[bool] sortable: Determines whether the field can be used to sort the results of a query. If you specify sorting on a field that does not have Sortable set to true, Amazon Kendra returns an exception. The default is `false`.
        """
        if displayable is not None:
            pulumi.set(__self__, "displayable", displayable)
        if facetable is not None:
            pulumi.set(__self__, "facetable", facetable)
        if searchable is not None:
            pulumi.set(__self__, "searchable", searchable)
        if sortable is not None:
            pulumi.set(__self__, "sortable", sortable)

    @property
    @pulumi.getter
    def displayable(self) -> Optional[pulumi.Input[bool]]:
        """
        Determines whether the field is returned in the query response. The default is `true`.
        """
        return pulumi.get(self, "displayable")

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

    @property
    @pulumi.getter
    def facetable(self) -> Optional[pulumi.Input[bool]]:
        """
        Indicates that the field can be used to create search facets, a count of results for each value in the field. The default is `false`.
        """
        return pulumi.get(self, "facetable")

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

    @property
    @pulumi.getter
    def searchable(self) -> Optional[pulumi.Input[bool]]:
        """
        Determines whether the field is used in the search. If the Searchable field is true, you can use relevance tuning to manually tune how Amazon Kendra weights the field in the search. The default is `true` for `string` fields and `false` for `number` and `date` fields.
        """
        return pulumi.get(self, "searchable")

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

    @property
    @pulumi.getter
    def sortable(self) -> Optional[pulumi.Input[bool]]:
        """
        Determines whether the field can be used to sort the results of a query. If you specify sorting on a field that does not have Sortable set to true, Amazon Kendra returns an exception. The default is `false`.
        """
        return pulumi.get(self, "sortable")

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


@pulumi.input_type
class IndexIndexStatisticArgs:
    def __init__(__self__, *,
                 faq_statistics: Optional[pulumi.Input[Sequence[pulumi.Input['IndexIndexStatisticFaqStatisticArgs']]]] = None,
                 text_document_statistics: Optional[pulumi.Input[Sequence[pulumi.Input['IndexIndexStatisticTextDocumentStatisticArgs']]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['IndexIndexStatisticFaqStatisticArgs']]] faq_statistics: A block that specifies the number of question and answer topics in the index. Detailed below.
        :param pulumi.Input[Sequence[pulumi.Input['IndexIndexStatisticTextDocumentStatisticArgs']]] text_document_statistics: A block that specifies the number of text documents indexed. Detailed below.
        """
        if faq_statistics is not None:
            pulumi.set(__self__, "faq_statistics", faq_statistics)
        if text_document_statistics is not None:
            pulumi.set(__self__, "text_document_statistics", text_document_statistics)

    @property
    @pulumi.getter(name="faqStatistics")
    def faq_statistics(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['IndexIndexStatisticFaqStatisticArgs']]]]:
        """
        A block that specifies the number of question and answer topics in the index. Detailed below.
        """
        return pulumi.get(self, "faq_statistics")

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

    @property
    @pulumi.getter(name="textDocumentStatistics")
    def text_document_statistics(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['IndexIndexStatisticTextDocumentStatisticArgs']]]]:
        """
        A block that specifies the number of text documents indexed. Detailed below.
        """
        return pulumi.get(self, "text_document_statistics")

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


@pulumi.input_type
class IndexIndexStatisticFaqStatisticArgs:
    def __init__(__self__, *,
                 indexed_question_answers_count: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[int] indexed_question_answers_count: The total number of FAQ questions and answers contained in the index.
        """
        if indexed_question_answers_count is not None:
            pulumi.set(__self__, "indexed_question_answers_count", indexed_question_answers_count)

    @property
    @pulumi.getter(name="indexedQuestionAnswersCount")
    def indexed_question_answers_count(self) -> Optional[pulumi.Input[int]]:
        """
        The total number of FAQ questions and answers contained in the index.
        """
        return pulumi.get(self, "indexed_question_answers_count")

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


@pulumi.input_type
class IndexIndexStatisticTextDocumentStatisticArgs:
    def __init__(__self__, *,
                 indexed_text_bytes: Optional[pulumi.Input[int]] = None,
                 indexed_text_documents_count: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[int] indexed_text_bytes: The total size, in bytes, of the indexed documents.
        :param pulumi.Input[int] indexed_text_documents_count: The number of text documents indexed.
        """
        if indexed_text_bytes is not None:
            pulumi.set(__self__, "indexed_text_bytes", indexed_text_bytes)
        if indexed_text_documents_count is not None:
            pulumi.set(__self__, "indexed_text_documents_count", indexed_text_documents_count)

    @property
    @pulumi.getter(name="indexedTextBytes")
    def indexed_text_bytes(self) -> Optional[pulumi.Input[int]]:
        """
        The total size, in bytes, of the indexed documents.
        """
        return pulumi.get(self, "indexed_text_bytes")

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

    @property
    @pulumi.getter(name="indexedTextDocumentsCount")
    def indexed_text_documents_count(self) -> Optional[pulumi.Input[int]]:
        """
        The number of text documents indexed.
        """
        return pulumi.get(self, "indexed_text_documents_count")

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


@pulumi.input_type
class IndexServerSideEncryptionConfigurationArgs:
    def __init__(__self__, *,
                 kms_key_id: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] kms_key_id: The identifier of the AWS KMScustomer master key (CMK). Amazon Kendra doesn't support asymmetric CMKs.
        """
        if kms_key_id is not None:
            pulumi.set(__self__, "kms_key_id", kms_key_id)

    @property
    @pulumi.getter(name="kmsKeyId")
    def kms_key_id(self) -> Optional[pulumi.Input[str]]:
        """
        The identifier of the AWS KMScustomer master key (CMK). Amazon Kendra doesn't support asymmetric CMKs.
        """
        return pulumi.get(self, "kms_key_id")

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


@pulumi.input_type
class IndexUserGroupResolutionConfigurationArgs:
    def __init__(__self__, *,
                 user_group_resolution_mode: pulumi.Input[str]):
        """
        :param pulumi.Input[str] user_group_resolution_mode: The identity store provider (mode) you want to use to fetch access levels of groups and users. AWS Single Sign-On is currently the only available mode. Your users and groups must exist in an AWS SSO identity source in order to use this mode. Valid Values are `AWS_SSO` or `NONE`.
        """
        pulumi.set(__self__, "user_group_resolution_mode", user_group_resolution_mode)

    @property
    @pulumi.getter(name="userGroupResolutionMode")
    def user_group_resolution_mode(self) -> pulumi.Input[str]:
        """
        The identity store provider (mode) you want to use to fetch access levels of groups and users. AWS Single Sign-On is currently the only available mode. Your users and groups must exist in an AWS SSO identity source in order to use this mode. Valid Values are `AWS_SSO` or `NONE`.
        """
        return pulumi.get(self, "user_group_resolution_mode")

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


@pulumi.input_type
class IndexUserTokenConfigurationsArgs:
    def __init__(__self__, *,
                 json_token_type_configuration: Optional[pulumi.Input['IndexUserTokenConfigurationsJsonTokenTypeConfigurationArgs']] = None,
                 jwt_token_type_configuration: Optional[pulumi.Input['IndexUserTokenConfigurationsJwtTokenTypeConfigurationArgs']] = None):
        """
        :param pulumi.Input['IndexUserTokenConfigurationsJsonTokenTypeConfigurationArgs'] json_token_type_configuration: A block that specifies the information about the JSON token type configuration. Detailed below.
        :param pulumi.Input['IndexUserTokenConfigurationsJwtTokenTypeConfigurationArgs'] jwt_token_type_configuration: A block that specifies the information about the JWT token type configuration. Detailed below.
        """
        if json_token_type_configuration is not None:
            pulumi.set(__self__, "json_token_type_configuration", json_token_type_configuration)
        if jwt_token_type_configuration is not None:
            pulumi.set(__self__, "jwt_token_type_configuration", jwt_token_type_configuration)

    @property
    @pulumi.getter(name="jsonTokenTypeConfiguration")
    def json_token_type_configuration(self) -> Optional[pulumi.Input['IndexUserTokenConfigurationsJsonTokenTypeConfigurationArgs']]:
        """
        A block that specifies the information about the JSON token type configuration. Detailed below.
        """
        return pulumi.get(self, "json_token_type_configuration")

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

    @property
    @pulumi.getter(name="jwtTokenTypeConfiguration")
    def jwt_token_type_configuration(self) -> Optional[pulumi.Input['IndexUserTokenConfigurationsJwtTokenTypeConfigurationArgs']]:
        """
        A block that specifies the information about the JWT token type configuration. Detailed below.
        """
        return pulumi.get(self, "jwt_token_type_configuration")

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


@pulumi.input_type
class IndexUserTokenConfigurationsJsonTokenTypeConfigurationArgs:
    def __init__(__self__, *,
                 group_attribute_field: pulumi.Input[str],
                 user_name_attribute_field: pulumi.Input[str]):
        """
        :param pulumi.Input[str] group_attribute_field: The group attribute field. Minimum length of 1. Maximum length of 2048.
        :param pulumi.Input[str] user_name_attribute_field: The user name attribute field. Minimum length of 1. Maximum length of 2048.
        """
        pulumi.set(__self__, "group_attribute_field", group_attribute_field)
        pulumi.set(__self__, "user_name_attribute_field", user_name_attribute_field)

    @property
    @pulumi.getter(name="groupAttributeField")
    def group_attribute_field(self) -> pulumi.Input[str]:
        """
        The group attribute field. Minimum length of 1. Maximum length of 2048.
        """
        return pulumi.get(self, "group_attribute_field")

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

    @property
    @pulumi.getter(name="userNameAttributeField")
    def user_name_attribute_field(self) -> pulumi.Input[str]:
        """
        The user name attribute field. Minimum length of 1. Maximum length of 2048.
        """
        return pulumi.get(self, "user_name_attribute_field")

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


@pulumi.input_type
class IndexUserTokenConfigurationsJwtTokenTypeConfigurationArgs:
    def __init__(__self__, *,
                 key_location: pulumi.Input[str],
                 claim_regex: Optional[pulumi.Input[str]] = None,
                 group_attribute_field: Optional[pulumi.Input[str]] = None,
                 issuer: Optional[pulumi.Input[str]] = None,
                 secrets_manager_arn: Optional[pulumi.Input[str]] = None,
                 url: Optional[pulumi.Input[str]] = None,
                 user_name_attribute_field: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] key_location: The location of the key. Valid values are `URL` or `SECRET_MANAGER`
        :param pulumi.Input[str] claim_regex: The regular expression that identifies the claim. Minimum length of 1. Maximum length of 100.
        :param pulumi.Input[str] group_attribute_field: The group attribute field. Minimum length of 1. Maximum length of 100.
        :param pulumi.Input[str] issuer: The issuer of the token. Minimum length of 1. Maximum length of 65.
        :param pulumi.Input[str] secrets_manager_arn: The Amazon Resource Name (ARN) of the secret.
        :param pulumi.Input[str] url: The signing key URL. Valid pattern is `^(https?|ftp|file):\\/\\/([^\\s]*)`
        :param pulumi.Input[str] user_name_attribute_field: The user name attribute field. Minimum length of 1. Maximum length of 100.
        """
        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 secrets_manager_arn is not None:
            pulumi.set(__self__, "secrets_manager_arn", secrets_manager_arn)
        if url is not None:
            pulumi.set(__self__, "url", url)
        if user_name_attribute_field is not None:
            pulumi.set(__self__, "user_name_attribute_field", user_name_attribute_field)

    @property
    @pulumi.getter(name="keyLocation")
    def key_location(self) -> pulumi.Input[str]:
        """
        The location of the key. Valid values are `URL` or `SECRET_MANAGER`
        """
        return pulumi.get(self, "key_location")

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

    @property
    @pulumi.getter(name="claimRegex")
    def claim_regex(self) -> Optional[pulumi.Input[str]]:
        """
        The regular expression that identifies the claim. Minimum length of 1. Maximum length of 100.
        """
        return pulumi.get(self, "claim_regex")

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

    @property
    @pulumi.getter(name="groupAttributeField")
    def group_attribute_field(self) -> Optional[pulumi.Input[str]]:
        """
        The group attribute field. Minimum length of 1. Maximum length of 100.
        """
        return pulumi.get(self, "group_attribute_field")

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

    @property
    @pulumi.getter
    def issuer(self) -> Optional[pulumi.Input[str]]:
        """
        The issuer of the token. Minimum length of 1. Maximum length of 65.
        """
        return pulumi.get(self, "issuer")

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

    @property
    @pulumi.getter(name="secretsManagerArn")
    def secrets_manager_arn(self) -> Optional[pulumi.Input[str]]:
        """
        The Amazon Resource Name (ARN) of the secret.
        """
        return pulumi.get(self, "secrets_manager_arn")

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

    @property
    @pulumi.getter
    def url(self) -> Optional[pulumi.Input[str]]:
        """
        The signing key URL. Valid pattern is `^(https?|ftp|file):\\/\\/([^\\s]*)`
        """
        return pulumi.get(self, "url")

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

    @property
    @pulumi.getter(name="userNameAttributeField")
    def user_name_attribute_field(self) -> Optional[pulumi.Input[str]]:
        """
        The user name attribute field. Minimum length of 1. Maximum length of 100.
        """
        return pulumi.get(self, "user_name_attribute_field")

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


@pulumi.input_type
class QuerySuggestionsBlockListSourceS3PathArgs:
    def __init__(__self__, *,
                 bucket: pulumi.Input[str],
                 key: pulumi.Input[str]):
        """
        :param pulumi.Input[str] bucket: The name of the S3 bucket that contains the file.
        :param pulumi.Input[str] key: The name of the file.
        """
        pulumi.set(__self__, "bucket", bucket)
        pulumi.set(__self__, "key", key)

    @property
    @pulumi.getter
    def bucket(self) -> pulumi.Input[str]:
        """
        The name of the S3 bucket that contains the file.
        """
        return pulumi.get(self, "bucket")

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

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

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


@pulumi.input_type
class ThesaurusSourceS3PathArgs:
    def __init__(__self__, *,
                 bucket: pulumi.Input[str],
                 key: pulumi.Input[str]):
        """
        :param pulumi.Input[str] bucket: The name of the S3 bucket that contains the file.
        :param pulumi.Input[str] key: The name of the file.
        """
        pulumi.set(__self__, "bucket", bucket)
        pulumi.set(__self__, "key", key)

    @property
    @pulumi.getter
    def bucket(self) -> pulumi.Input[str]:
        """
        The name of the S3 bucket that contains the file.
        """
        return pulumi.get(self, "bucket")

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

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

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


