# 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 warnings
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
from . import outputs

__all__ = [
    'IndexCapacityUnits',
    'IndexDocumentMetadataConfigurationUpdate',
    'IndexDocumentMetadataConfigurationUpdateRelevance',
    'IndexDocumentMetadataConfigurationUpdateSearch',
    'IndexIndexStatistic',
    'IndexIndexStatisticFaqStatistic',
    'IndexIndexStatisticTextDocumentStatistic',
    'IndexServerSideEncryptionConfiguration',
    'IndexUserGroupResolutionConfiguration',
    'IndexUserTokenConfigurations',
    'IndexUserTokenConfigurationsJsonTokenTypeConfiguration',
    'IndexUserTokenConfigurationsJwtTokenTypeConfiguration',
]

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

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

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

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

    def __init__(__self__, *,
                 query_capacity_units: Optional[int] = None,
                 storage_capacity_units: Optional[int] = None):
        """
        :param 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 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[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")

    @property
    @pulumi.getter(name="storageCapacityUnits")
    def storage_capacity_units(self) -> Optional[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")


@pulumi.output_type
class IndexDocumentMetadataConfigurationUpdate(dict):
    def __init__(__self__, *,
                 name: Optional[str] = None,
                 relevances: Optional[Sequence['outputs.IndexDocumentMetadataConfigurationUpdateRelevance']] = None,
                 searches: Optional[Sequence['outputs.IndexDocumentMetadataConfigurationUpdateSearch']] = None,
                 type: Optional[str] = None):
        """
        :param str name: Specifies the name of the Index.
        :param Sequence['IndexDocumentMetadataConfigurationUpdateRelevanceArgs'] relevances: A block that provides manual tuning parameters to determine how the field affects the search results. Documented below.
        :param Sequence['IndexDocumentMetadataConfigurationUpdateSearchArgs'] searches: A block that provides information about how the field is used during a search. Documented below.
        :param str type: The data type of the index field. Valid values are `STRING_VALUE`, `STRING_LIST_VALUE`, `LONG_VALUE`, `DATE_VALUE`.
        """
        if name is not None:
            pulumi.set(__self__, "name", name)
        if relevances is not None:
            pulumi.set(__self__, "relevances", relevances)
        if searches is not None:
            pulumi.set(__self__, "searches", searches)
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def name(self) -> Optional[str]:
        """
        Specifies the name of the Index.
        """
        return pulumi.get(self, "name")

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

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

    @property
    @pulumi.getter
    def type(self) -> Optional[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")


@pulumi.output_type
class IndexDocumentMetadataConfigurationUpdateRelevance(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "rankOrder":
            suggest = "rank_order"
        elif key == "valuesImportanceMap":
            suggest = "values_importance_map"

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

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

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

    def __init__(__self__, *,
                 duration: Optional[str] = None,
                 freshness: Optional[bool] = None,
                 importance: Optional[int] = None,
                 rank_order: Optional[str] = None,
                 values_importance_map: Optional[Mapping[str, int]] = None):
        """
        :param 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 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 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 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 Mapping[str, 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[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")

    @property
    @pulumi.getter
    def freshness(self) -> Optional[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")

    @property
    @pulumi.getter
    def importance(self) -> Optional[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")

    @property
    @pulumi.getter(name="rankOrder")
    def rank_order(self) -> Optional[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")

    @property
    @pulumi.getter(name="valuesImportanceMap")
    def values_importance_map(self) -> Optional[Mapping[str, 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")


@pulumi.output_type
class IndexDocumentMetadataConfigurationUpdateSearch(dict):
    def __init__(__self__, *,
                 displayable: Optional[bool] = None,
                 facetable: Optional[bool] = None,
                 searchable: Optional[bool] = None,
                 sortable: Optional[bool] = None):
        """
        :param bool displayable: Determines whether the field is returned in the query response. The default is `true`.
        :param 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 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 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[bool]:
        """
        Determines whether the field is returned in the query response. The default is `true`.
        """
        return pulumi.get(self, "displayable")

    @property
    @pulumi.getter
    def facetable(self) -> Optional[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")

    @property
    @pulumi.getter
    def searchable(self) -> Optional[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")

    @property
    @pulumi.getter
    def sortable(self) -> Optional[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")


@pulumi.output_type
class IndexIndexStatistic(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "faqStatistics":
            suggest = "faq_statistics"
        elif key == "textDocumentStatistics":
            suggest = "text_document_statistics"

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

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

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

    def __init__(__self__, *,
                 faq_statistics: Optional[Sequence['outputs.IndexIndexStatisticFaqStatistic']] = None,
                 text_document_statistics: Optional[Sequence['outputs.IndexIndexStatisticTextDocumentStatistic']] = None):
        """
        :param Sequence['IndexIndexStatisticFaqStatisticArgs'] faq_statistics: A block that specifies the number of question and answer topics in the index. Documented below.
        :param Sequence['IndexIndexStatisticTextDocumentStatisticArgs'] text_document_statistics: A block that specifies the number of text documents indexed.
        """
        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[Sequence['outputs.IndexIndexStatisticFaqStatistic']]:
        """
        A block that specifies the number of question and answer topics in the index. Documented below.
        """
        return pulumi.get(self, "faq_statistics")

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


@pulumi.output_type
class IndexIndexStatisticFaqStatistic(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "indexedQuestionAnswersCount":
            suggest = "indexed_question_answers_count"

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

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

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

    def __init__(__self__, *,
                 indexed_question_answers_count: Optional[int] = None):
        """
        :param 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[int]:
        """
        The total number of FAQ questions and answers contained in the index.
        """
        return pulumi.get(self, "indexed_question_answers_count")


@pulumi.output_type
class IndexIndexStatisticTextDocumentStatistic(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "indexedTextBytes":
            suggest = "indexed_text_bytes"
        elif key == "indexedTextDocumentsCount":
            suggest = "indexed_text_documents_count"

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

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

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

    def __init__(__self__, *,
                 indexed_text_bytes: Optional[int] = None,
                 indexed_text_documents_count: Optional[int] = None):
        """
        :param int indexed_text_bytes: The total size, in bytes, of the indexed documents.
        :param 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[int]:
        """
        The total size, in bytes, of the indexed documents.
        """
        return pulumi.get(self, "indexed_text_bytes")

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


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

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

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

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

    def __init__(__self__, *,
                 kms_key_id: Optional[str] = None):
        """
        :param 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[str]:
        """
        The identifier of the AWS KMScustomer master key (CMK). Amazon Kendra doesn't support asymmetric CMKs.
        """
        return pulumi.get(self, "kms_key_id")


@pulumi.output_type
class IndexUserGroupResolutionConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "userGroupResolutionMode":
            suggest = "user_group_resolution_mode"

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

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

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

    def __init__(__self__, *,
                 user_group_resolution_mode: str):
        """
        :param 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) -> 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")


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

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

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

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

    def __init__(__self__, *,
                 json_token_type_configuration: Optional['outputs.IndexUserTokenConfigurationsJsonTokenTypeConfiguration'] = None,
                 jwt_token_type_configuration: Optional['outputs.IndexUserTokenConfigurationsJwtTokenTypeConfiguration'] = None):
        """
        :param 'IndexUserTokenConfigurationsJsonTokenTypeConfigurationArgs' json_token_type_configuration: A block that specifies the information about the JSON token type configuration.
        :param 'IndexUserTokenConfigurationsJwtTokenTypeConfigurationArgs' jwt_token_type_configuration: A block that specifies the information about the JWT token type configuration.
        """
        if json_token_type_configuration is not None:
            pulumi.set(__self__, "json_token_type_configuration", json_token_type_configuration)
        if jwt_token_type_configuration is not None:
            pulumi.set(__self__, "jwt_token_type_configuration", jwt_token_type_configuration)

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

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


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

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

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

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

    def __init__(__self__, *,
                 group_attribute_field: str,
                 user_name_attribute_field: str):
        """
        :param str group_attribute_field: The group attribute field. Minimum length of 1. Maximum length of 2048.
        :param 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) -> str:
        """
        The group attribute field. Minimum length of 1. Maximum length of 2048.
        """
        return pulumi.get(self, "group_attribute_field")

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


@pulumi.output_type
class IndexUserTokenConfigurationsJwtTokenTypeConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "keyLocation":
            suggest = "key_location"
        elif key == "claimRegex":
            suggest = "claim_regex"
        elif key == "groupAttributeField":
            suggest = "group_attribute_field"
        elif key == "secretsManagerArn":
            suggest = "secrets_manager_arn"
        elif key == "userNameAttributeField":
            suggest = "user_name_attribute_field"

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

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

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

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

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

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

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

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

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

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


