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

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

__all__ = [
    'IdentityPoolCognitoIdentityProvider',
    'IdentityPoolCognitoStreams',
    'IdentityPoolPushSync',
    'UserPoolAccountRecoverySetting',
    'UserPoolAdminCreateUserConfig',
    'UserPoolClientAnalyticsConfiguration',
    'UserPoolClientTokenValidityUnits',
    'UserPoolCustomEmailSender',
    'UserPoolCustomSMSSender',
    'UserPoolDeviceConfiguration',
    'UserPoolDomainCustomDomainConfigType',
    'UserPoolEmailConfiguration',
    'UserPoolInviteMessageTemplate',
    'UserPoolLambdaConfig',
    'UserPoolNumberAttributeConstraints',
    'UserPoolPasswordPolicy',
    'UserPoolPolicies',
    'UserPoolRecoveryOption',
    'UserPoolResourceServerResourceServerScopeType',
    'UserPoolRiskConfigurationAttachmentAccountTakeoverActionType',
    'UserPoolRiskConfigurationAttachmentAccountTakeoverActionsType',
    'UserPoolRiskConfigurationAttachmentAccountTakeoverRiskConfigurationType',
    'UserPoolRiskConfigurationAttachmentCompromisedCredentialsActionsType',
    'UserPoolRiskConfigurationAttachmentCompromisedCredentialsRiskConfigurationType',
    'UserPoolRiskConfigurationAttachmentNotifyConfigurationType',
    'UserPoolRiskConfigurationAttachmentNotifyEmailType',
    'UserPoolRiskConfigurationAttachmentRiskExceptionConfigurationType',
    'UserPoolSchemaAttribute',
    'UserPoolSmsConfiguration',
    'UserPoolStringAttributeConstraints',
    'UserPoolUserAttributeType',
    'UserPoolUserPoolAddOns',
    'UserPoolUsernameConfiguration',
    'UserPoolVerificationMessageTemplate',
]

@pulumi.output_type
class IdentityPoolCognitoIdentityProvider(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "clientId":
            suggest = "client_id"
        elif key == "providerName":
            suggest = "provider_name"
        elif key == "serverSideTokenCheck":
            suggest = "server_side_token_check"

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

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

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

    def __init__(__self__, *,
                 client_id: Optional[str] = None,
                 provider_name: Optional[str] = None,
                 server_side_token_check: Optional[bool] = None):
        if client_id is not None:
            pulumi.set(__self__, "client_id", client_id)
        if provider_name is not None:
            pulumi.set(__self__, "provider_name", provider_name)
        if server_side_token_check is not None:
            pulumi.set(__self__, "server_side_token_check", server_side_token_check)

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

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

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


@pulumi.output_type
class IdentityPoolCognitoStreams(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "roleArn":
            suggest = "role_arn"
        elif key == "streamName":
            suggest = "stream_name"
        elif key == "streamingStatus":
            suggest = "streaming_status"

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

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

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

    def __init__(__self__, *,
                 role_arn: Optional[str] = None,
                 stream_name: Optional[str] = None,
                 streaming_status: Optional[str] = None):
        if role_arn is not None:
            pulumi.set(__self__, "role_arn", role_arn)
        if stream_name is not None:
            pulumi.set(__self__, "stream_name", stream_name)
        if streaming_status is not None:
            pulumi.set(__self__, "streaming_status", streaming_status)

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

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

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


@pulumi.output_type
class IdentityPoolPushSync(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "applicationArns":
            suggest = "application_arns"
        elif key == "roleArn":
            suggest = "role_arn"

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

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

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

    def __init__(__self__, *,
                 application_arns: Optional[Sequence[str]] = None,
                 role_arn: Optional[str] = None):
        if application_arns is not None:
            pulumi.set(__self__, "application_arns", application_arns)
        if role_arn is not None:
            pulumi.set(__self__, "role_arn", role_arn)

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

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


@pulumi.output_type
class UserPoolAccountRecoverySetting(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "recoveryMechanisms":
            suggest = "recovery_mechanisms"

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

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

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

    def __init__(__self__, *,
                 recovery_mechanisms: Optional[Sequence['outputs.UserPoolRecoveryOption']] = None):
        if recovery_mechanisms is not None:
            pulumi.set(__self__, "recovery_mechanisms", recovery_mechanisms)

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


@pulumi.output_type
class UserPoolAdminCreateUserConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "allowAdminCreateUserOnly":
            suggest = "allow_admin_create_user_only"
        elif key == "inviteMessageTemplate":
            suggest = "invite_message_template"
        elif key == "unusedAccountValidityDays":
            suggest = "unused_account_validity_days"

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

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

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

    def __init__(__self__, *,
                 allow_admin_create_user_only: Optional[bool] = None,
                 invite_message_template: Optional['outputs.UserPoolInviteMessageTemplate'] = None,
                 unused_account_validity_days: Optional[int] = None):
        if allow_admin_create_user_only is not None:
            pulumi.set(__self__, "allow_admin_create_user_only", allow_admin_create_user_only)
        if invite_message_template is not None:
            pulumi.set(__self__, "invite_message_template", invite_message_template)
        if unused_account_validity_days is not None:
            pulumi.set(__self__, "unused_account_validity_days", unused_account_validity_days)

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

    @property
    @pulumi.getter(name="inviteMessageTemplate")
    def invite_message_template(self) -> Optional['outputs.UserPoolInviteMessageTemplate']:
        return pulumi.get(self, "invite_message_template")

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


@pulumi.output_type
class UserPoolClientAnalyticsConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "applicationArn":
            suggest = "application_arn"
        elif key == "applicationId":
            suggest = "application_id"
        elif key == "externalId":
            suggest = "external_id"
        elif key == "roleArn":
            suggest = "role_arn"
        elif key == "userDataShared":
            suggest = "user_data_shared"

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

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

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

    def __init__(__self__, *,
                 application_arn: Optional[str] = None,
                 application_id: Optional[str] = None,
                 external_id: Optional[str] = None,
                 role_arn: Optional[str] = None,
                 user_data_shared: Optional[bool] = None):
        if application_arn is not None:
            pulumi.set(__self__, "application_arn", application_arn)
        if application_id is not None:
            pulumi.set(__self__, "application_id", application_id)
        if external_id is not None:
            pulumi.set(__self__, "external_id", external_id)
        if role_arn is not None:
            pulumi.set(__self__, "role_arn", role_arn)
        if user_data_shared is not None:
            pulumi.set(__self__, "user_data_shared", user_data_shared)

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

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

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

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

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


@pulumi.output_type
class UserPoolClientTokenValidityUnits(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "accessToken":
            suggest = "access_token"
        elif key == "idToken":
            suggest = "id_token"
        elif key == "refreshToken":
            suggest = "refresh_token"

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

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

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

    def __init__(__self__, *,
                 access_token: Optional[str] = None,
                 id_token: Optional[str] = None,
                 refresh_token: Optional[str] = None):
        if access_token is not None:
            pulumi.set(__self__, "access_token", access_token)
        if id_token is not None:
            pulumi.set(__self__, "id_token", id_token)
        if refresh_token is not None:
            pulumi.set(__self__, "refresh_token", refresh_token)

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

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

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


@pulumi.output_type
class UserPoolCustomEmailSender(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "lambdaArn":
            suggest = "lambda_arn"
        elif key == "lambdaVersion":
            suggest = "lambda_version"

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

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

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

    def __init__(__self__, *,
                 lambda_arn: Optional[str] = None,
                 lambda_version: Optional[str] = None):
        if lambda_arn is not None:
            pulumi.set(__self__, "lambda_arn", lambda_arn)
        if lambda_version is not None:
            pulumi.set(__self__, "lambda_version", lambda_version)

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

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


@pulumi.output_type
class UserPoolCustomSMSSender(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "lambdaArn":
            suggest = "lambda_arn"
        elif key == "lambdaVersion":
            suggest = "lambda_version"

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

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

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

    def __init__(__self__, *,
                 lambda_arn: Optional[str] = None,
                 lambda_version: Optional[str] = None):
        if lambda_arn is not None:
            pulumi.set(__self__, "lambda_arn", lambda_arn)
        if lambda_version is not None:
            pulumi.set(__self__, "lambda_version", lambda_version)

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

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


@pulumi.output_type
class UserPoolDeviceConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "challengeRequiredOnNewDevice":
            suggest = "challenge_required_on_new_device"
        elif key == "deviceOnlyRememberedOnUserPrompt":
            suggest = "device_only_remembered_on_user_prompt"

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

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

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

    def __init__(__self__, *,
                 challenge_required_on_new_device: Optional[bool] = None,
                 device_only_remembered_on_user_prompt: Optional[bool] = None):
        if challenge_required_on_new_device is not None:
            pulumi.set(__self__, "challenge_required_on_new_device", challenge_required_on_new_device)
        if device_only_remembered_on_user_prompt is not None:
            pulumi.set(__self__, "device_only_remembered_on_user_prompt", device_only_remembered_on_user_prompt)

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

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


@pulumi.output_type
class UserPoolDomainCustomDomainConfigType(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "certificateArn":
            suggest = "certificate_arn"

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

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

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

    def __init__(__self__, *,
                 certificate_arn: Optional[str] = None):
        if certificate_arn is not None:
            pulumi.set(__self__, "certificate_arn", certificate_arn)

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


@pulumi.output_type
class UserPoolEmailConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "configurationSet":
            suggest = "configuration_set"
        elif key == "emailSendingAccount":
            suggest = "email_sending_account"
        elif key == "from":
            suggest = "from_"
        elif key == "replyToEmailAddress":
            suggest = "reply_to_email_address"
        elif key == "sourceArn":
            suggest = "source_arn"

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

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

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

    def __init__(__self__, *,
                 configuration_set: Optional[str] = None,
                 email_sending_account: Optional[str] = None,
                 from_: Optional[str] = None,
                 reply_to_email_address: Optional[str] = None,
                 source_arn: Optional[str] = None):
        if configuration_set is not None:
            pulumi.set(__self__, "configuration_set", configuration_set)
        if email_sending_account is not None:
            pulumi.set(__self__, "email_sending_account", email_sending_account)
        if from_ is not None:
            pulumi.set(__self__, "from_", from_)
        if reply_to_email_address is not None:
            pulumi.set(__self__, "reply_to_email_address", reply_to_email_address)
        if source_arn is not None:
            pulumi.set(__self__, "source_arn", source_arn)

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

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

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

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

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


@pulumi.output_type
class UserPoolInviteMessageTemplate(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "emailMessage":
            suggest = "email_message"
        elif key == "emailSubject":
            suggest = "email_subject"
        elif key == "sMSMessage":
            suggest = "s_ms_message"

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

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

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

    def __init__(__self__, *,
                 email_message: Optional[str] = None,
                 email_subject: Optional[str] = None,
                 s_ms_message: Optional[str] = None):
        if email_message is not None:
            pulumi.set(__self__, "email_message", email_message)
        if email_subject is not None:
            pulumi.set(__self__, "email_subject", email_subject)
        if s_ms_message is not None:
            pulumi.set(__self__, "s_ms_message", s_ms_message)

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

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

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


@pulumi.output_type
class UserPoolLambdaConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "createAuthChallenge":
            suggest = "create_auth_challenge"
        elif key == "customEmailSender":
            suggest = "custom_email_sender"
        elif key == "customMessage":
            suggest = "custom_message"
        elif key == "customSMSSender":
            suggest = "custom_sms_sender"
        elif key == "defineAuthChallenge":
            suggest = "define_auth_challenge"
        elif key == "kMSKeyID":
            suggest = "k_ms_key_id"
        elif key == "postAuthentication":
            suggest = "post_authentication"
        elif key == "postConfirmation":
            suggest = "post_confirmation"
        elif key == "preAuthentication":
            suggest = "pre_authentication"
        elif key == "preSignUp":
            suggest = "pre_sign_up"
        elif key == "preTokenGeneration":
            suggest = "pre_token_generation"
        elif key == "userMigration":
            suggest = "user_migration"
        elif key == "verifyAuthChallengeResponse":
            suggest = "verify_auth_challenge_response"

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

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

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

    def __init__(__self__, *,
                 create_auth_challenge: Optional[str] = None,
                 custom_email_sender: Optional['outputs.UserPoolCustomEmailSender'] = None,
                 custom_message: Optional[str] = None,
                 custom_sms_sender: Optional['outputs.UserPoolCustomSMSSender'] = None,
                 define_auth_challenge: Optional[str] = None,
                 k_ms_key_id: Optional[str] = None,
                 post_authentication: Optional[str] = None,
                 post_confirmation: Optional[str] = None,
                 pre_authentication: Optional[str] = None,
                 pre_sign_up: Optional[str] = None,
                 pre_token_generation: Optional[str] = None,
                 user_migration: Optional[str] = None,
                 verify_auth_challenge_response: Optional[str] = None):
        if create_auth_challenge is not None:
            pulumi.set(__self__, "create_auth_challenge", create_auth_challenge)
        if custom_email_sender is not None:
            pulumi.set(__self__, "custom_email_sender", custom_email_sender)
        if custom_message is not None:
            pulumi.set(__self__, "custom_message", custom_message)
        if custom_sms_sender is not None:
            pulumi.set(__self__, "custom_sms_sender", custom_sms_sender)
        if define_auth_challenge is not None:
            pulumi.set(__self__, "define_auth_challenge", define_auth_challenge)
        if k_ms_key_id is not None:
            pulumi.set(__self__, "k_ms_key_id", k_ms_key_id)
        if post_authentication is not None:
            pulumi.set(__self__, "post_authentication", post_authentication)
        if post_confirmation is not None:
            pulumi.set(__self__, "post_confirmation", post_confirmation)
        if pre_authentication is not None:
            pulumi.set(__self__, "pre_authentication", pre_authentication)
        if pre_sign_up is not None:
            pulumi.set(__self__, "pre_sign_up", pre_sign_up)
        if pre_token_generation is not None:
            pulumi.set(__self__, "pre_token_generation", pre_token_generation)
        if user_migration is not None:
            pulumi.set(__self__, "user_migration", user_migration)
        if verify_auth_challenge_response is not None:
            pulumi.set(__self__, "verify_auth_challenge_response", verify_auth_challenge_response)

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

    @property
    @pulumi.getter(name="customEmailSender")
    def custom_email_sender(self) -> Optional['outputs.UserPoolCustomEmailSender']:
        return pulumi.get(self, "custom_email_sender")

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

    @property
    @pulumi.getter(name="customSMSSender")
    def custom_sms_sender(self) -> Optional['outputs.UserPoolCustomSMSSender']:
        return pulumi.get(self, "custom_sms_sender")

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

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

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

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

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

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

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

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

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


@pulumi.output_type
class UserPoolNumberAttributeConstraints(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "maxValue":
            suggest = "max_value"
        elif key == "minValue":
            suggest = "min_value"

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

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

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

    def __init__(__self__, *,
                 max_value: Optional[str] = None,
                 min_value: Optional[str] = None):
        if max_value is not None:
            pulumi.set(__self__, "max_value", max_value)
        if min_value is not None:
            pulumi.set(__self__, "min_value", min_value)

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

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


@pulumi.output_type
class UserPoolPasswordPolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "minimumLength":
            suggest = "minimum_length"
        elif key == "requireLowercase":
            suggest = "require_lowercase"
        elif key == "requireNumbers":
            suggest = "require_numbers"
        elif key == "requireSymbols":
            suggest = "require_symbols"
        elif key == "requireUppercase":
            suggest = "require_uppercase"
        elif key == "temporaryPasswordValidityDays":
            suggest = "temporary_password_validity_days"

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

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

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

    def __init__(__self__, *,
                 minimum_length: Optional[int] = None,
                 require_lowercase: Optional[bool] = None,
                 require_numbers: Optional[bool] = None,
                 require_symbols: Optional[bool] = None,
                 require_uppercase: Optional[bool] = None,
                 temporary_password_validity_days: Optional[int] = None):
        if minimum_length is not None:
            pulumi.set(__self__, "minimum_length", minimum_length)
        if require_lowercase is not None:
            pulumi.set(__self__, "require_lowercase", require_lowercase)
        if require_numbers is not None:
            pulumi.set(__self__, "require_numbers", require_numbers)
        if require_symbols is not None:
            pulumi.set(__self__, "require_symbols", require_symbols)
        if require_uppercase is not None:
            pulumi.set(__self__, "require_uppercase", require_uppercase)
        if temporary_password_validity_days is not None:
            pulumi.set(__self__, "temporary_password_validity_days", temporary_password_validity_days)

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

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

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

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

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

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


@pulumi.output_type
class UserPoolPolicies(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "passwordPolicy":
            suggest = "password_policy"

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

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

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

    def __init__(__self__, *,
                 password_policy: Optional['outputs.UserPoolPasswordPolicy'] = None):
        if password_policy is not None:
            pulumi.set(__self__, "password_policy", password_policy)

    @property
    @pulumi.getter(name="passwordPolicy")
    def password_policy(self) -> Optional['outputs.UserPoolPasswordPolicy']:
        return pulumi.get(self, "password_policy")


@pulumi.output_type
class UserPoolRecoveryOption(dict):
    def __init__(__self__, *,
                 name: Optional[str] = None,
                 priority: Optional[int] = None):
        if name is not None:
            pulumi.set(__self__, "name", name)
        if priority is not None:
            pulumi.set(__self__, "priority", priority)

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

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


@pulumi.output_type
class UserPoolResourceServerResourceServerScopeType(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "scopeDescription":
            suggest = "scope_description"
        elif key == "scopeName":
            suggest = "scope_name"

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

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

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

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

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

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


@pulumi.output_type
class UserPoolRiskConfigurationAttachmentAccountTakeoverActionType(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "eventAction":
            suggest = "event_action"

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

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

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

    def __init__(__self__, *,
                 event_action: str,
                 notify: bool):
        pulumi.set(__self__, "event_action", event_action)
        pulumi.set(__self__, "notify", notify)

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

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


@pulumi.output_type
class UserPoolRiskConfigurationAttachmentAccountTakeoverActionsType(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "highAction":
            suggest = "high_action"
        elif key == "lowAction":
            suggest = "low_action"
        elif key == "mediumAction":
            suggest = "medium_action"

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

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

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

    def __init__(__self__, *,
                 high_action: Optional['outputs.UserPoolRiskConfigurationAttachmentAccountTakeoverActionType'] = None,
                 low_action: Optional['outputs.UserPoolRiskConfigurationAttachmentAccountTakeoverActionType'] = None,
                 medium_action: Optional['outputs.UserPoolRiskConfigurationAttachmentAccountTakeoverActionType'] = None):
        if high_action is not None:
            pulumi.set(__self__, "high_action", high_action)
        if low_action is not None:
            pulumi.set(__self__, "low_action", low_action)
        if medium_action is not None:
            pulumi.set(__self__, "medium_action", medium_action)

    @property
    @pulumi.getter(name="highAction")
    def high_action(self) -> Optional['outputs.UserPoolRiskConfigurationAttachmentAccountTakeoverActionType']:
        return pulumi.get(self, "high_action")

    @property
    @pulumi.getter(name="lowAction")
    def low_action(self) -> Optional['outputs.UserPoolRiskConfigurationAttachmentAccountTakeoverActionType']:
        return pulumi.get(self, "low_action")

    @property
    @pulumi.getter(name="mediumAction")
    def medium_action(self) -> Optional['outputs.UserPoolRiskConfigurationAttachmentAccountTakeoverActionType']:
        return pulumi.get(self, "medium_action")


@pulumi.output_type
class UserPoolRiskConfigurationAttachmentAccountTakeoverRiskConfigurationType(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "notifyConfiguration":
            suggest = "notify_configuration"

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

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

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

    def __init__(__self__, *,
                 actions: 'outputs.UserPoolRiskConfigurationAttachmentAccountTakeoverActionsType',
                 notify_configuration: Optional['outputs.UserPoolRiskConfigurationAttachmentNotifyConfigurationType'] = None):
        pulumi.set(__self__, "actions", actions)
        if notify_configuration is not None:
            pulumi.set(__self__, "notify_configuration", notify_configuration)

    @property
    @pulumi.getter
    def actions(self) -> 'outputs.UserPoolRiskConfigurationAttachmentAccountTakeoverActionsType':
        return pulumi.get(self, "actions")

    @property
    @pulumi.getter(name="notifyConfiguration")
    def notify_configuration(self) -> Optional['outputs.UserPoolRiskConfigurationAttachmentNotifyConfigurationType']:
        return pulumi.get(self, "notify_configuration")


@pulumi.output_type
class UserPoolRiskConfigurationAttachmentCompromisedCredentialsActionsType(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "eventAction":
            suggest = "event_action"

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

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

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

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

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


@pulumi.output_type
class UserPoolRiskConfigurationAttachmentCompromisedCredentialsRiskConfigurationType(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "eventFilter":
            suggest = "event_filter"

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

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

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

    def __init__(__self__, *,
                 actions: 'outputs.UserPoolRiskConfigurationAttachmentCompromisedCredentialsActionsType',
                 event_filter: Optional[Sequence[str]] = None):
        pulumi.set(__self__, "actions", actions)
        if event_filter is not None:
            pulumi.set(__self__, "event_filter", event_filter)

    @property
    @pulumi.getter
    def actions(self) -> 'outputs.UserPoolRiskConfigurationAttachmentCompromisedCredentialsActionsType':
        return pulumi.get(self, "actions")

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


@pulumi.output_type
class UserPoolRiskConfigurationAttachmentNotifyConfigurationType(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "sourceArn":
            suggest = "source_arn"
        elif key == "blockEmail":
            suggest = "block_email"
        elif key == "from":
            suggest = "from_"
        elif key == "mfaEmail":
            suggest = "mfa_email"
        elif key == "noActionEmail":
            suggest = "no_action_email"
        elif key == "replyTo":
            suggest = "reply_to"

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

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

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

    def __init__(__self__, *,
                 source_arn: str,
                 block_email: Optional['outputs.UserPoolRiskConfigurationAttachmentNotifyEmailType'] = None,
                 from_: Optional[str] = None,
                 mfa_email: Optional['outputs.UserPoolRiskConfigurationAttachmentNotifyEmailType'] = None,
                 no_action_email: Optional['outputs.UserPoolRiskConfigurationAttachmentNotifyEmailType'] = None,
                 reply_to: Optional[str] = None):
        pulumi.set(__self__, "source_arn", source_arn)
        if block_email is not None:
            pulumi.set(__self__, "block_email", block_email)
        if from_ is not None:
            pulumi.set(__self__, "from_", from_)
        if mfa_email is not None:
            pulumi.set(__self__, "mfa_email", mfa_email)
        if no_action_email is not None:
            pulumi.set(__self__, "no_action_email", no_action_email)
        if reply_to is not None:
            pulumi.set(__self__, "reply_to", reply_to)

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

    @property
    @pulumi.getter(name="blockEmail")
    def block_email(self) -> Optional['outputs.UserPoolRiskConfigurationAttachmentNotifyEmailType']:
        return pulumi.get(self, "block_email")

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

    @property
    @pulumi.getter(name="mfaEmail")
    def mfa_email(self) -> Optional['outputs.UserPoolRiskConfigurationAttachmentNotifyEmailType']:
        return pulumi.get(self, "mfa_email")

    @property
    @pulumi.getter(name="noActionEmail")
    def no_action_email(self) -> Optional['outputs.UserPoolRiskConfigurationAttachmentNotifyEmailType']:
        return pulumi.get(self, "no_action_email")

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


@pulumi.output_type
class UserPoolRiskConfigurationAttachmentNotifyEmailType(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "htmlBody":
            suggest = "html_body"
        elif key == "textBody":
            suggest = "text_body"

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

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

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

    def __init__(__self__, *,
                 subject: str,
                 html_body: Optional[str] = None,
                 text_body: Optional[str] = None):
        pulumi.set(__self__, "subject", subject)
        if html_body is not None:
            pulumi.set(__self__, "html_body", html_body)
        if text_body is not None:
            pulumi.set(__self__, "text_body", text_body)

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

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

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


@pulumi.output_type
class UserPoolRiskConfigurationAttachmentRiskExceptionConfigurationType(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "blockedIPRangeList":
            suggest = "blocked_ip_range_list"
        elif key == "skippedIPRangeList":
            suggest = "skipped_ip_range_list"

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

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

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

    def __init__(__self__, *,
                 blocked_ip_range_list: Optional[Sequence[str]] = None,
                 skipped_ip_range_list: Optional[Sequence[str]] = None):
        if blocked_ip_range_list is not None:
            pulumi.set(__self__, "blocked_ip_range_list", blocked_ip_range_list)
        if skipped_ip_range_list is not None:
            pulumi.set(__self__, "skipped_ip_range_list", skipped_ip_range_list)

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

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


@pulumi.output_type
class UserPoolSchemaAttribute(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "attributeDataType":
            suggest = "attribute_data_type"
        elif key == "developerOnlyAttribute":
            suggest = "developer_only_attribute"
        elif key == "numberAttributeConstraints":
            suggest = "number_attribute_constraints"
        elif key == "stringAttributeConstraints":
            suggest = "string_attribute_constraints"

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

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

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

    def __init__(__self__, *,
                 attribute_data_type: Optional[str] = None,
                 developer_only_attribute: Optional[bool] = None,
                 mutable: Optional[bool] = None,
                 name: Optional[str] = None,
                 number_attribute_constraints: Optional['outputs.UserPoolNumberAttributeConstraints'] = None,
                 required: Optional[bool] = None,
                 string_attribute_constraints: Optional['outputs.UserPoolStringAttributeConstraints'] = None):
        if attribute_data_type is not None:
            pulumi.set(__self__, "attribute_data_type", attribute_data_type)
        if developer_only_attribute is not None:
            pulumi.set(__self__, "developer_only_attribute", developer_only_attribute)
        if mutable is not None:
            pulumi.set(__self__, "mutable", mutable)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if number_attribute_constraints is not None:
            pulumi.set(__self__, "number_attribute_constraints", number_attribute_constraints)
        if required is not None:
            pulumi.set(__self__, "required", required)
        if string_attribute_constraints is not None:
            pulumi.set(__self__, "string_attribute_constraints", string_attribute_constraints)

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

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

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

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

    @property
    @pulumi.getter(name="numberAttributeConstraints")
    def number_attribute_constraints(self) -> Optional['outputs.UserPoolNumberAttributeConstraints']:
        return pulumi.get(self, "number_attribute_constraints")

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

    @property
    @pulumi.getter(name="stringAttributeConstraints")
    def string_attribute_constraints(self) -> Optional['outputs.UserPoolStringAttributeConstraints']:
        return pulumi.get(self, "string_attribute_constraints")


@pulumi.output_type
class UserPoolSmsConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "externalId":
            suggest = "external_id"
        elif key == "snsCallerArn":
            suggest = "sns_caller_arn"

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

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

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

    def __init__(__self__, *,
                 external_id: Optional[str] = None,
                 sns_caller_arn: Optional[str] = None):
        if external_id is not None:
            pulumi.set(__self__, "external_id", external_id)
        if sns_caller_arn is not None:
            pulumi.set(__self__, "sns_caller_arn", sns_caller_arn)

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

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


@pulumi.output_type
class UserPoolStringAttributeConstraints(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "maxLength":
            suggest = "max_length"
        elif key == "minLength":
            suggest = "min_length"

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

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

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

    def __init__(__self__, *,
                 max_length: Optional[str] = None,
                 min_length: Optional[str] = None):
        if max_length is not None:
            pulumi.set(__self__, "max_length", max_length)
        if min_length is not None:
            pulumi.set(__self__, "min_length", min_length)

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

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


@pulumi.output_type
class UserPoolUserAttributeType(dict):
    def __init__(__self__, *,
                 name: Optional[str] = None,
                 value: Optional[str] = None):
        if name is not None:
            pulumi.set(__self__, "name", name)
        if value is not None:
            pulumi.set(__self__, "value", value)

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

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


@pulumi.output_type
class UserPoolUserPoolAddOns(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "advancedSecurityMode":
            suggest = "advanced_security_mode"

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

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

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

    def __init__(__self__, *,
                 advanced_security_mode: Optional[str] = None):
        if advanced_security_mode is not None:
            pulumi.set(__self__, "advanced_security_mode", advanced_security_mode)

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


@pulumi.output_type
class UserPoolUsernameConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "caseSensitive":
            suggest = "case_sensitive"

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

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

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

    def __init__(__self__, *,
                 case_sensitive: Optional[bool] = None):
        if case_sensitive is not None:
            pulumi.set(__self__, "case_sensitive", case_sensitive)

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


@pulumi.output_type
class UserPoolVerificationMessageTemplate(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "defaultEmailOption":
            suggest = "default_email_option"
        elif key == "emailMessage":
            suggest = "email_message"
        elif key == "emailMessageByLink":
            suggest = "email_message_by_link"
        elif key == "emailSubject":
            suggest = "email_subject"
        elif key == "emailSubjectByLink":
            suggest = "email_subject_by_link"
        elif key == "smsMessage":
            suggest = "sms_message"

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

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

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

    def __init__(__self__, *,
                 default_email_option: Optional[str] = None,
                 email_message: Optional[str] = None,
                 email_message_by_link: Optional[str] = None,
                 email_subject: Optional[str] = None,
                 email_subject_by_link: Optional[str] = None,
                 sms_message: Optional[str] = None):
        if default_email_option is not None:
            pulumi.set(__self__, "default_email_option", default_email_option)
        if email_message is not None:
            pulumi.set(__self__, "email_message", email_message)
        if email_message_by_link is not None:
            pulumi.set(__self__, "email_message_by_link", email_message_by_link)
        if email_subject is not None:
            pulumi.set(__self__, "email_subject", email_subject)
        if email_subject_by_link is not None:
            pulumi.set(__self__, "email_subject_by_link", email_subject_by_link)
        if sms_message is not None:
            pulumi.set(__self__, "sms_message", sms_message)

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

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

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

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

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

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


