# 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

__all__ = [
    'IdentityPoolCognitoIdentityProviderArgs',
    'IdentityPoolCognitoStreamsArgs',
    'IdentityPoolPushSyncArgs',
    'UserPoolAccountRecoverySettingArgs',
    'UserPoolAdminCreateUserConfigArgs',
    'UserPoolClientAnalyticsConfigurationArgs',
    'UserPoolClientTokenValidityUnitsArgs',
    'UserPoolCustomEmailSenderArgs',
    'UserPoolCustomSMSSenderArgs',
    'UserPoolDeviceConfigurationArgs',
    'UserPoolDomainCustomDomainConfigTypeArgs',
    'UserPoolEmailConfigurationArgs',
    'UserPoolInviteMessageTemplateArgs',
    'UserPoolLambdaConfigArgs',
    'UserPoolNumberAttributeConstraintsArgs',
    'UserPoolPasswordPolicyArgs',
    'UserPoolPoliciesArgs',
    'UserPoolRecoveryOptionArgs',
    'UserPoolResourceServerResourceServerScopeTypeArgs',
    'UserPoolRiskConfigurationAttachmentAccountTakeoverActionTypeArgs',
    'UserPoolRiskConfigurationAttachmentAccountTakeoverActionsTypeArgs',
    'UserPoolRiskConfigurationAttachmentAccountTakeoverRiskConfigurationTypeArgs',
    'UserPoolRiskConfigurationAttachmentCompromisedCredentialsActionsTypeArgs',
    'UserPoolRiskConfigurationAttachmentCompromisedCredentialsRiskConfigurationTypeArgs',
    'UserPoolRiskConfigurationAttachmentNotifyConfigurationTypeArgs',
    'UserPoolRiskConfigurationAttachmentNotifyEmailTypeArgs',
    'UserPoolRiskConfigurationAttachmentRiskExceptionConfigurationTypeArgs',
    'UserPoolSchemaAttributeArgs',
    'UserPoolSmsConfigurationArgs',
    'UserPoolStringAttributeConstraintsArgs',
    'UserPoolUserAttributeTypeArgs',
    'UserPoolUserPoolAddOnsArgs',
    'UserPoolUsernameConfigurationArgs',
    'UserPoolVerificationMessageTemplateArgs',
]

@pulumi.input_type
class IdentityPoolCognitoIdentityProviderArgs:
    def __init__(__self__, *,
                 client_id: Optional[pulumi.Input[str]] = None,
                 provider_name: Optional[pulumi.Input[str]] = None,
                 server_side_token_check: Optional[pulumi.Input[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[pulumi.Input[str]]:
        return pulumi.get(self, "client_id")

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

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

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

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

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


@pulumi.input_type
class IdentityPoolCognitoStreamsArgs:
    def __init__(__self__, *,
                 role_arn: Optional[pulumi.Input[str]] = None,
                 stream_name: Optional[pulumi.Input[str]] = None,
                 streaming_status: Optional[pulumi.Input[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[pulumi.Input[str]]:
        return pulumi.get(self, "role_arn")

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

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

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

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

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


@pulumi.input_type
class IdentityPoolPushSyncArgs:
    def __init__(__self__, *,
                 application_arns: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 role_arn: Optional[pulumi.Input[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[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "application_arns")

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

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

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


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

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

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


@pulumi.input_type
class UserPoolAdminCreateUserConfigArgs:
    def __init__(__self__, *,
                 allow_admin_create_user_only: Optional[pulumi.Input[bool]] = None,
                 invite_message_template: Optional[pulumi.Input['UserPoolInviteMessageTemplateArgs']] = None,
                 unused_account_validity_days: Optional[pulumi.Input[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[pulumi.Input[bool]]:
        return pulumi.get(self, "allow_admin_create_user_only")

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

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

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

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

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


@pulumi.input_type
class UserPoolClientAnalyticsConfigurationArgs:
    def __init__(__self__, *,
                 application_arn: Optional[pulumi.Input[str]] = None,
                 application_id: Optional[pulumi.Input[str]] = None,
                 external_id: Optional[pulumi.Input[str]] = None,
                 role_arn: Optional[pulumi.Input[str]] = None,
                 user_data_shared: Optional[pulumi.Input[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[pulumi.Input[str]]:
        return pulumi.get(self, "application_arn")

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class UserPoolClientTokenValidityUnitsArgs:
    def __init__(__self__, *,
                 access_token: Optional[pulumi.Input[str]] = None,
                 id_token: Optional[pulumi.Input[str]] = None,
                 refresh_token: Optional[pulumi.Input[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[pulumi.Input[str]]:
        return pulumi.get(self, "access_token")

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

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

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

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

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


@pulumi.input_type
class UserPoolCustomEmailSenderArgs:
    def __init__(__self__, *,
                 lambda_arn: Optional[pulumi.Input[str]] = None,
                 lambda_version: Optional[pulumi.Input[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[pulumi.Input[str]]:
        return pulumi.get(self, "lambda_arn")

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

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

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


@pulumi.input_type
class UserPoolCustomSMSSenderArgs:
    def __init__(__self__, *,
                 lambda_arn: Optional[pulumi.Input[str]] = None,
                 lambda_version: Optional[pulumi.Input[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[pulumi.Input[str]]:
        return pulumi.get(self, "lambda_arn")

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

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

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


@pulumi.input_type
class UserPoolDeviceConfigurationArgs:
    def __init__(__self__, *,
                 challenge_required_on_new_device: Optional[pulumi.Input[bool]] = None,
                 device_only_remembered_on_user_prompt: Optional[pulumi.Input[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[pulumi.Input[bool]]:
        return pulumi.get(self, "challenge_required_on_new_device")

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

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

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


@pulumi.input_type
class UserPoolDomainCustomDomainConfigTypeArgs:
    def __init__(__self__, *,
                 certificate_arn: Optional[pulumi.Input[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[pulumi.Input[str]]:
        return pulumi.get(self, "certificate_arn")

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


@pulumi.input_type
class UserPoolEmailConfigurationArgs:
    def __init__(__self__, *,
                 configuration_set: Optional[pulumi.Input[str]] = None,
                 email_sending_account: Optional[pulumi.Input[str]] = None,
                 from_: Optional[pulumi.Input[str]] = None,
                 reply_to_email_address: Optional[pulumi.Input[str]] = None,
                 source_arn: Optional[pulumi.Input[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[pulumi.Input[str]]:
        return pulumi.get(self, "configuration_set")

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class UserPoolInviteMessageTemplateArgs:
    def __init__(__self__, *,
                 email_message: Optional[pulumi.Input[str]] = None,
                 email_subject: Optional[pulumi.Input[str]] = None,
                 s_ms_message: Optional[pulumi.Input[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[pulumi.Input[str]]:
        return pulumi.get(self, "email_message")

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

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

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

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

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


@pulumi.input_type
class UserPoolLambdaConfigArgs:
    def __init__(__self__, *,
                 create_auth_challenge: Optional[pulumi.Input[str]] = None,
                 custom_email_sender: Optional[pulumi.Input['UserPoolCustomEmailSenderArgs']] = None,
                 custom_message: Optional[pulumi.Input[str]] = None,
                 custom_sms_sender: Optional[pulumi.Input['UserPoolCustomSMSSenderArgs']] = None,
                 define_auth_challenge: Optional[pulumi.Input[str]] = None,
                 k_ms_key_id: Optional[pulumi.Input[str]] = None,
                 post_authentication: Optional[pulumi.Input[str]] = None,
                 post_confirmation: Optional[pulumi.Input[str]] = None,
                 pre_authentication: Optional[pulumi.Input[str]] = None,
                 pre_sign_up: Optional[pulumi.Input[str]] = None,
                 pre_token_generation: Optional[pulumi.Input[str]] = None,
                 user_migration: Optional[pulumi.Input[str]] = None,
                 verify_auth_challenge_response: Optional[pulumi.Input[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[pulumi.Input[str]]:
        return pulumi.get(self, "create_auth_challenge")

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class UserPoolNumberAttributeConstraintsArgs:
    def __init__(__self__, *,
                 max_value: Optional[pulumi.Input[str]] = None,
                 min_value: Optional[pulumi.Input[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[pulumi.Input[str]]:
        return pulumi.get(self, "max_value")

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

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

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


@pulumi.input_type
class UserPoolPasswordPolicyArgs:
    def __init__(__self__, *,
                 minimum_length: Optional[pulumi.Input[int]] = None,
                 require_lowercase: Optional[pulumi.Input[bool]] = None,
                 require_numbers: Optional[pulumi.Input[bool]] = None,
                 require_symbols: Optional[pulumi.Input[bool]] = None,
                 require_uppercase: Optional[pulumi.Input[bool]] = None,
                 temporary_password_validity_days: Optional[pulumi.Input[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[pulumi.Input[int]]:
        return pulumi.get(self, "minimum_length")

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

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

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

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

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

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

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

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

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

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

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


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

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

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


@pulumi.input_type
class UserPoolRecoveryOptionArgs:
    def __init__(__self__, *,
                 name: Optional[pulumi.Input[str]] = None,
                 priority: Optional[pulumi.Input[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[pulumi.Input[str]]:
        return pulumi.get(self, "name")

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

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

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


@pulumi.input_type
class UserPoolResourceServerResourceServerScopeTypeArgs:
    def __init__(__self__, *,
                 scope_description: pulumi.Input[str],
                 scope_name: pulumi.Input[str]):
        pulumi.set(__self__, "scope_description", scope_description)
        pulumi.set(__self__, "scope_name", scope_name)

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

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

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

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


@pulumi.input_type
class UserPoolRiskConfigurationAttachmentAccountTakeoverActionTypeArgs:
    def __init__(__self__, *,
                 event_action: pulumi.Input[str],
                 notify: pulumi.Input[bool]):
        pulumi.set(__self__, "event_action", event_action)
        pulumi.set(__self__, "notify", notify)

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

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

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

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


@pulumi.input_type
class UserPoolRiskConfigurationAttachmentAccountTakeoverActionsTypeArgs:
    def __init__(__self__, *,
                 high_action: Optional[pulumi.Input['UserPoolRiskConfigurationAttachmentAccountTakeoverActionTypeArgs']] = None,
                 low_action: Optional[pulumi.Input['UserPoolRiskConfigurationAttachmentAccountTakeoverActionTypeArgs']] = None,
                 medium_action: Optional[pulumi.Input['UserPoolRiskConfigurationAttachmentAccountTakeoverActionTypeArgs']] = 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[pulumi.Input['UserPoolRiskConfigurationAttachmentAccountTakeoverActionTypeArgs']]:
        return pulumi.get(self, "high_action")

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

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

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

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

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


@pulumi.input_type
class UserPoolRiskConfigurationAttachmentAccountTakeoverRiskConfigurationTypeArgs:
    def __init__(__self__, *,
                 actions: pulumi.Input['UserPoolRiskConfigurationAttachmentAccountTakeoverActionsTypeArgs'],
                 notify_configuration: Optional[pulumi.Input['UserPoolRiskConfigurationAttachmentNotifyConfigurationTypeArgs']] = 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) -> pulumi.Input['UserPoolRiskConfigurationAttachmentAccountTakeoverActionsTypeArgs']:
        return pulumi.get(self, "actions")

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

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

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


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

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

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


@pulumi.input_type
class UserPoolRiskConfigurationAttachmentCompromisedCredentialsRiskConfigurationTypeArgs:
    def __init__(__self__, *,
                 actions: pulumi.Input['UserPoolRiskConfigurationAttachmentCompromisedCredentialsActionsTypeArgs'],
                 event_filter: Optional[pulumi.Input[Sequence[pulumi.Input[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) -> pulumi.Input['UserPoolRiskConfigurationAttachmentCompromisedCredentialsActionsTypeArgs']:
        return pulumi.get(self, "actions")

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

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

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


@pulumi.input_type
class UserPoolRiskConfigurationAttachmentNotifyConfigurationTypeArgs:
    def __init__(__self__, *,
                 source_arn: pulumi.Input[str],
                 block_email: Optional[pulumi.Input['UserPoolRiskConfigurationAttachmentNotifyEmailTypeArgs']] = None,
                 from_: Optional[pulumi.Input[str]] = None,
                 mfa_email: Optional[pulumi.Input['UserPoolRiskConfigurationAttachmentNotifyEmailTypeArgs']] = None,
                 no_action_email: Optional[pulumi.Input['UserPoolRiskConfigurationAttachmentNotifyEmailTypeArgs']] = None,
                 reply_to: Optional[pulumi.Input[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) -> pulumi.Input[str]:
        return pulumi.get(self, "source_arn")

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

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

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class UserPoolRiskConfigurationAttachmentNotifyEmailTypeArgs:
    def __init__(__self__, *,
                 subject: pulumi.Input[str],
                 html_body: Optional[pulumi.Input[str]] = None,
                 text_body: Optional[pulumi.Input[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) -> pulumi.Input[str]:
        return pulumi.get(self, "subject")

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

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

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

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

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


@pulumi.input_type
class UserPoolRiskConfigurationAttachmentRiskExceptionConfigurationTypeArgs:
    def __init__(__self__, *,
                 blocked_ip_range_list: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 skipped_ip_range_list: Optional[pulumi.Input[Sequence[pulumi.Input[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[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        return pulumi.get(self, "blocked_ip_range_list")

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

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

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


@pulumi.input_type
class UserPoolSchemaAttributeArgs:
    def __init__(__self__, *,
                 attribute_data_type: Optional[pulumi.Input[str]] = None,
                 developer_only_attribute: Optional[pulumi.Input[bool]] = None,
                 mutable: Optional[pulumi.Input[bool]] = None,
                 name: Optional[pulumi.Input[str]] = None,
                 number_attribute_constraints: Optional[pulumi.Input['UserPoolNumberAttributeConstraintsArgs']] = None,
                 required: Optional[pulumi.Input[bool]] = None,
                 string_attribute_constraints: Optional[pulumi.Input['UserPoolStringAttributeConstraintsArgs']] = 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[pulumi.Input[str]]:
        return pulumi.get(self, "attribute_data_type")

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

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

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

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

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

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

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

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

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

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

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

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

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


@pulumi.input_type
class UserPoolSmsConfigurationArgs:
    def __init__(__self__, *,
                 external_id: Optional[pulumi.Input[str]] = None,
                 sns_caller_arn: Optional[pulumi.Input[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[pulumi.Input[str]]:
        return pulumi.get(self, "external_id")

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

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

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


@pulumi.input_type
class UserPoolStringAttributeConstraintsArgs:
    def __init__(__self__, *,
                 max_length: Optional[pulumi.Input[str]] = None,
                 min_length: Optional[pulumi.Input[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[pulumi.Input[str]]:
        return pulumi.get(self, "max_length")

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

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

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


@pulumi.input_type
class UserPoolUserAttributeTypeArgs:
    def __init__(__self__, *,
                 name: Optional[pulumi.Input[str]] = None,
                 value: Optional[pulumi.Input[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[pulumi.Input[str]]:
        return pulumi.get(self, "name")

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

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

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


@pulumi.input_type
class UserPoolUserPoolAddOnsArgs:
    def __init__(__self__, *,
                 advanced_security_mode: Optional[pulumi.Input[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[pulumi.Input[str]]:
        return pulumi.get(self, "advanced_security_mode")

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


@pulumi.input_type
class UserPoolUsernameConfigurationArgs:
    def __init__(__self__, *,
                 case_sensitive: Optional[pulumi.Input[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[pulumi.Input[bool]]:
        return pulumi.get(self, "case_sensitive")

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


@pulumi.input_type
class UserPoolVerificationMessageTemplateArgs:
    def __init__(__self__, *,
                 default_email_option: Optional[pulumi.Input[str]] = None,
                 email_message: Optional[pulumi.Input[str]] = None,
                 email_message_by_link: Optional[pulumi.Input[str]] = None,
                 email_subject: Optional[pulumi.Input[str]] = None,
                 email_subject_by_link: Optional[pulumi.Input[str]] = None,
                 sms_message: Optional[pulumi.Input[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[pulumi.Input[str]]:
        return pulumi.get(self, "default_email_option")

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

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

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

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

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

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

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

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

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

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

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


