VaporShell.Cognito

3.0.0-beta20220119r1

VaporShell.Cognito.Classes.ps1

using namespace System
using namespace System.Collections
using namespace System.Collections.Generic
using namespace System.IO
using namespace System.Management.Automation
[CmdletBinding()]
Param()

Write-Verbose "Importing class 'CognitoUserPoolPasswordPolicy'"

class CognitoUserPoolPasswordPolicy : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSCognitoUserPoolPasswordPolicy'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-cognito-userpool-passwordpolicy.html'

    hidden [object] $_requireNumbers
    hidden [object] $_minimumLength
    hidden [object] $_temporaryPasswordValidityDays
    hidden [object] $_requireUppercase
    hidden [object] $_requireLowercase
    hidden [object] $_requireSymbols

    [bool] $RequireNumbers
    [int] $MinimumLength
    [int] $TemporaryPasswordValidityDays
    [bool] $RequireUppercase
    [bool] $RequireLowercase
    [bool] $RequireSymbols

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name RequireNumbers -Value {
            $this._requireNumbers
        } -SecondValue {
            param([ValidateType(([bool], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._requireNumbers = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name MinimumLength -Value {
            $this._minimumLength
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._minimumLength = if ($cast = $value -as [int]) {
                $cast
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name TemporaryPasswordValidityDays -Value {
            $this._temporaryPasswordValidityDays
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._temporaryPasswordValidityDays = if ($cast = $value -as [int]) {
                $cast
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name RequireUppercase -Value {
            $this._requireUppercase
        } -SecondValue {
            param([ValidateType(([bool], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._requireUppercase = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name RequireLowercase -Value {
            $this._requireLowercase
        } -SecondValue {
            param([ValidateType(([bool], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._requireLowercase = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name RequireSymbols -Value {
            $this._requireSymbols
        } -SecondValue {
            param([ValidateType(([bool], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._requireSymbols = $value
        }
    }

    CognitoUserPoolPasswordPolicy() : base() {}
    CognitoUserPoolPasswordPolicy([IDictionary] $props) : base($props) {}
    CognitoUserPoolPasswordPolicy([psobject] $props) : base($props) {}
}

Write-Verbose "Importing class 'CognitoUserPoolRecoveryOption'"

class CognitoUserPoolRecoveryOption : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSCognitoUserPoolRecoveryOption'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-cognito-userpool-recoveryoption.html'

    hidden [object] $_priority
    hidden [object] $_name

    [int] $Priority
    [string] $Name

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name Priority -Value {
            $this._priority
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._priority = if ($cast = $value -as [int]) {
                $cast
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Name -Value {
            $this._name
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._name = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
    }

    CognitoUserPoolRecoveryOption() : base() {}
    CognitoUserPoolRecoveryOption([IDictionary] $props) : base($props) {}
    CognitoUserPoolRecoveryOption([psobject] $props) : base($props) {}
}

Write-Verbose "Importing class 'CognitoUserPoolResourceServerResourceServerScopeType'"

class CognitoUserPoolResourceServerResourceServerScopeType : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSCognitoUserPoolResourceServerResourceServerScopeType'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-cognito-userpoolresourceserver-resourceserverscopetype.html'

    hidden [object] $_scopeName
    hidden [object] $_scopeDescription

    [string] $ScopeName
    [string] $ScopeDescription

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name ScopeName -Value {
            $this._scopeName
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._scopeName = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name ScopeDescription -Value {
            $this._scopeDescription
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._scopeDescription = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
    }

    CognitoUserPoolResourceServerResourceServerScopeType() : base() {}
    CognitoUserPoolResourceServerResourceServerScopeType([IDictionary] $props) : base($props) {}
    CognitoUserPoolResourceServerResourceServerScopeType([psobject] $props) : base($props) {}
}

Write-Verbose "Importing class 'CognitoUserPoolRiskConfigurationAttachmentAccountTakeoverActionsType'"

class CognitoUserPoolRiskConfigurationAttachmentAccountTakeoverActionsType : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSCognitoUserPoolRiskConfigurationAttachmentAccountTakeoverActionsType'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-cognito-userpoolriskconfigurationattachment-accounttakeoveractionstype.html'

    hidden [object] $_highAction
    hidden [object] $_lowAction
    hidden [object] $_mediumAction

    [CognitoUserPoolRiskConfigurationAttachmentAccountTakeoverActionType] $HighAction
    [CognitoUserPoolRiskConfigurationAttachmentAccountTakeoverActionType] $LowAction
    [CognitoUserPoolRiskConfigurationAttachmentAccountTakeoverActionType] $MediumAction

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name HighAction -Value {
            $this._highAction
        } -SecondValue {
            param([ValidateType(([CognitoUserPoolRiskConfigurationAttachmentAccountTakeoverActionType], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._highAction = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name LowAction -Value {
            $this._lowAction
        } -SecondValue {
            param([ValidateType(([CognitoUserPoolRiskConfigurationAttachmentAccountTakeoverActionType], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._lowAction = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name MediumAction -Value {
            $this._mediumAction
        } -SecondValue {
            param([ValidateType(([CognitoUserPoolRiskConfigurationAttachmentAccountTakeoverActionType], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._mediumAction = $value
        }
    }

    CognitoUserPoolRiskConfigurationAttachmentAccountTakeoverActionsType() : base() {}
    CognitoUserPoolRiskConfigurationAttachmentAccountTakeoverActionsType([IDictionary] $props) : base($props) {}
    CognitoUserPoolRiskConfigurationAttachmentAccountTakeoverActionsType([psobject] $props) : base($props) {}
}

Write-Verbose "Importing class 'CognitoUserPoolRiskConfigurationAttachmentRiskExceptionConfigurationType'"

class CognitoUserPoolRiskConfigurationAttachmentRiskExceptionConfigurationType : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSCognitoUserPoolRiskConfigurationAttachmentRiskExceptionConfigurationType'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-cognito-userpoolriskconfigurationattachment-riskexceptionconfigurationtype.html'

    hidden [object] $_blockedIPRangeList
    hidden [object] $_skippedIPRangeList

    [string[]] $BlockedIPRangeList
    [string[]] $SkippedIPRangeList

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name BlockedIPRangeList -Value {
            $this._blockedIPRangeList
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this._blockedIPRangeList = @($value)
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name SkippedIPRangeList -Value {
            $this._skippedIPRangeList
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this._skippedIPRangeList = @($value)
        }
    }

    CognitoUserPoolRiskConfigurationAttachmentRiskExceptionConfigurationType() : base() {}
    CognitoUserPoolRiskConfigurationAttachmentRiskExceptionConfigurationType([IDictionary] $props) : base($props) {}
    CognitoUserPoolRiskConfigurationAttachmentRiskExceptionConfigurationType([psobject] $props) : base($props) {}
}

Write-Verbose "Importing class 'CognitoUserPoolAdminCreateUserConfig'"

class CognitoUserPoolAdminCreateUserConfig : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSCognitoUserPoolAdminCreateUserConfig'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-cognito-userpool-admincreateuserconfig.html'

    hidden [object] $_inviteMessageTemplate
    hidden [object] $_unusedAccountValidityDays
    hidden [object] $_allowAdminCreateUserOnly

    [CognitoUserPoolInviteMessageTemplate] $InviteMessageTemplate
    [int] $UnusedAccountValidityDays
    [bool] $AllowAdminCreateUserOnly

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name InviteMessageTemplate -Value {
            $this._inviteMessageTemplate
        } -SecondValue {
            param([ValidateType(([CognitoUserPoolInviteMessageTemplate], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._inviteMessageTemplate = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name UnusedAccountValidityDays -Value {
            $this._unusedAccountValidityDays
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._unusedAccountValidityDays = if ($cast = $value -as [int]) {
                $cast
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name AllowAdminCreateUserOnly -Value {
            $this._allowAdminCreateUserOnly
        } -SecondValue {
            param([ValidateType(([bool], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._allowAdminCreateUserOnly = $value
        }
    }

    CognitoUserPoolAdminCreateUserConfig() : base() {}
    CognitoUserPoolAdminCreateUserConfig([IDictionary] $props) : base($props) {}
    CognitoUserPoolAdminCreateUserConfig([psobject] $props) : base($props) {}
}

Write-Verbose "Importing class 'CognitoUserPoolSmsConfiguration'"

class CognitoUserPoolSmsConfiguration : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSCognitoUserPoolSmsConfiguration'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-cognito-userpool-smsconfiguration.html'

    hidden [object] $_externalId
    hidden [object] $_snsCallerArn

    [string] $ExternalId
    [string] $SnsCallerArn

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name ExternalId -Value {
            $this._externalId
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._externalId = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name SnsCallerArn -Value {
            $this._snsCallerArn
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._snsCallerArn = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
    }

    CognitoUserPoolSmsConfiguration() : base() {}
    CognitoUserPoolSmsConfiguration([IDictionary] $props) : base($props) {}
    CognitoUserPoolSmsConfiguration([psobject] $props) : base($props) {}
}

Write-Verbose "Importing class 'CognitoUserPoolRiskConfigurationAttachmentAccountTakeoverActionType'"

class CognitoUserPoolRiskConfigurationAttachmentAccountTakeoverActionType : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSCognitoUserPoolRiskConfigurationAttachmentAccountTakeoverActionType'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-cognito-userpoolriskconfigurationattachment-accounttakeoveractiontype.html'

    hidden [object] $_notify
    hidden [object] $_eventAction

    [bool] $Notify
    [string] $EventAction

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name Notify -Value {
            $this._notify
        } -SecondValue {
            param([ValidateType(([bool], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._notify = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name EventAction -Value {
            $this._eventAction
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._eventAction = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
    }

    CognitoUserPoolRiskConfigurationAttachmentAccountTakeoverActionType() : base() {}
    CognitoUserPoolRiskConfigurationAttachmentAccountTakeoverActionType([IDictionary] $props) : base($props) {}
    CognitoUserPoolRiskConfigurationAttachmentAccountTakeoverActionType([psobject] $props) : base($props) {}
}

Write-Verbose "Importing class 'CognitoIdentityPoolRoleAttachmentRoleMapping'"

class CognitoIdentityPoolRoleAttachmentRoleMapping : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSCognitoIdentityPoolRoleAttachmentRoleMapping'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-cognito-identitypoolroleattachment-rolemapping.html'

    hidden [object] $_type
    hidden [object] $_ambiguousRoleResolution
    hidden [object] $_rulesConfiguration
    hidden [object] $_identityProvider

    [string] $Type
    [string] $AmbiguousRoleResolution
    [CognitoIdentityPoolRoleAttachmentRulesConfigurationType] $RulesConfiguration
    [string] $IdentityProvider

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name Type -Value {
            $this._type
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._type = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name AmbiguousRoleResolution -Value {
            $this._ambiguousRoleResolution
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._ambiguousRoleResolution = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name RulesConfiguration -Value {
            $this._rulesConfiguration
        } -SecondValue {
            param([ValidateType(([CognitoIdentityPoolRoleAttachmentRulesConfigurationType], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._rulesConfiguration = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name IdentityProvider -Value {
            $this._identityProvider
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._identityProvider = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
    }

    CognitoIdentityPoolRoleAttachmentRoleMapping() : base() {}
    CognitoIdentityPoolRoleAttachmentRoleMapping([IDictionary] $props) : base($props) {}
    CognitoIdentityPoolRoleAttachmentRoleMapping([psobject] $props) : base($props) {}
}

Write-Verbose "Importing class 'CognitoIdentityPoolRoleAttachmentMappingRule'"

class CognitoIdentityPoolRoleAttachmentMappingRule : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSCognitoIdentityPoolRoleAttachmentMappingRule'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-cognito-identitypoolroleattachment-mappingrule.html'

    hidden [object] $_matchType
    hidden [object] $_value
    hidden [object] $_claim
    hidden [object] $_roleARN

    [string] $MatchType
    [string] $Value
    [string] $Claim
    [string] $RoleARN

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name MatchType -Value {
            $this._matchType
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._matchType = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Value -Value {
            $this._value
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._value = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Claim -Value {
            $this._claim
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._claim = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name RoleARN -Value {
            $this._roleARN
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._roleARN = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
    }

    CognitoIdentityPoolRoleAttachmentMappingRule() : base() {}
    CognitoIdentityPoolRoleAttachmentMappingRule([IDictionary] $props) : base($props) {}
    CognitoIdentityPoolRoleAttachmentMappingRule([psobject] $props) : base($props) {}
}

Write-Verbose "Importing class 'CognitoIdentityPoolCognitoStreams'"

class CognitoIdentityPoolCognitoStreams : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSCognitoIdentityPoolCognitoStreams'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-cognito-identitypool-cognitostreams.html'

    hidden [object] $_streamingStatus
    hidden [object] $_streamName
    hidden [object] $_roleArn

    [string] $StreamingStatus
    [string] $StreamName
    [string] $RoleArn

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name StreamingStatus -Value {
            $this._streamingStatus
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._streamingStatus = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name StreamName -Value {
            $this._streamName
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._streamName = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name RoleArn -Value {
            $this._roleArn
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._roleArn = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
    }

    CognitoIdentityPoolCognitoStreams() : base() {}
    CognitoIdentityPoolCognitoStreams([IDictionary] $props) : base($props) {}
    CognitoIdentityPoolCognitoStreams([psobject] $props) : base($props) {}
}

Write-Verbose "Importing class 'CognitoUserPoolStringAttributeConstraints'"

class CognitoUserPoolStringAttributeConstraints : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSCognitoUserPoolStringAttributeConstraints'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-cognito-userpool-stringattributeconstraints.html'

    hidden [object] $_minLength
    hidden [object] $_maxLength

    [string] $MinLength
    [string] $MaxLength

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name MinLength -Value {
            $this._minLength
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._minLength = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name MaxLength -Value {
            $this._maxLength
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._maxLength = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
    }

    CognitoUserPoolStringAttributeConstraints() : base() {}
    CognitoUserPoolStringAttributeConstraints([IDictionary] $props) : base($props) {}
    CognitoUserPoolStringAttributeConstraints([psobject] $props) : base($props) {}
}

Write-Verbose "Importing class 'CognitoUserPoolVerificationMessageTemplate'"

class CognitoUserPoolVerificationMessageTemplate : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSCognitoUserPoolVerificationMessageTemplate'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-cognito-userpool-verificationmessagetemplate.html'

    hidden [object] $_emailMessageByLink
    hidden [object] $_emailMessage
    hidden [object] $_smsMessage
    hidden [object] $_emailSubject
    hidden [object] $_defaultEmailOption
    hidden [object] $_emailSubjectByLink

    [string] $EmailMessageByLink
    [string] $EmailMessage
    [string] $SmsMessage
    [string] $EmailSubject
    [string] $DefaultEmailOption
    [string] $EmailSubjectByLink

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name EmailMessageByLink -Value {
            $this._emailMessageByLink
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._emailMessageByLink = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name EmailMessage -Value {
            $this._emailMessage
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._emailMessage = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name SmsMessage -Value {
            $this._smsMessage
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._smsMessage = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name EmailSubject -Value {
            $this._emailSubject
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._emailSubject = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name DefaultEmailOption -Value {
            $this._defaultEmailOption
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._defaultEmailOption = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name EmailSubjectByLink -Value {
            $this._emailSubjectByLink
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._emailSubjectByLink = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
    }

    CognitoUserPoolVerificationMessageTemplate() : base() {}
    CognitoUserPoolVerificationMessageTemplate([IDictionary] $props) : base($props) {}
    CognitoUserPoolVerificationMessageTemplate([psobject] $props) : base($props) {}
}

Write-Verbose "Importing class 'CognitoUserPoolRiskConfigurationAttachmentCompromisedCredentialsRiskConfigurationType'"

class CognitoUserPoolRiskConfigurationAttachmentCompromisedCredentialsRiskConfigurationType : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSCognitoUserPoolRiskConfigurationAttachmentCompromisedCredentialsRiskConfigurationType'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-cognito-userpoolriskconfigurationattachment-compromisedcredentialsriskconfigurationtype.html'

    hidden [object] $_actions
    hidden [object] $_eventFilter

    [CognitoUserPoolRiskConfigurationAttachmentCompromisedCredentialsActionsType] $Actions
    [string[]] $EventFilter

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name Actions -Value {
            $this._actions
        } -SecondValue {
            param([ValidateType(([CognitoUserPoolRiskConfigurationAttachmentCompromisedCredentialsActionsType], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._actions = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name EventFilter -Value {
            $this._eventFilter
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this._eventFilter = @($value)
        }
    }

    CognitoUserPoolRiskConfigurationAttachmentCompromisedCredentialsRiskConfigurationType() : base() {}
    CognitoUserPoolRiskConfigurationAttachmentCompromisedCredentialsRiskConfigurationType([IDictionary] $props) : base($props) {}
    CognitoUserPoolRiskConfigurationAttachmentCompromisedCredentialsRiskConfigurationType([psobject] $props) : base($props) {}
}

Write-Verbose "Importing class 'CognitoUserPoolUserAttributeType'"

class CognitoUserPoolUserAttributeType : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSCognitoUserPoolUserAttributeType'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-cognito-userpooluser-attributetype.html'

    hidden [object] $_value
    hidden [object] $_name

    [string] $Value
    [string] $Name

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name Value -Value {
            $this._value
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._value = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Name -Value {
            $this._name
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._name = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
    }

    CognitoUserPoolUserAttributeType() : base() {}
    CognitoUserPoolUserAttributeType([IDictionary] $props) : base($props) {}
    CognitoUserPoolUserAttributeType([psobject] $props) : base($props) {}
}

Write-Verbose "Importing class 'CognitoUserPoolLambdaConfig'"

class CognitoUserPoolLambdaConfig : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSCognitoUserPoolLambdaConfig'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-cognito-userpool-lambdaconfig.html'

    hidden [object] $_createAuthChallenge
    hidden [object] $_preSignUp
    hidden [object] $_kMSKeyID
    hidden [object] $_userMigration
    hidden [object] $_postAuthentication
    hidden [object] $_verifyAuthChallengeResponse
    hidden [object] $_preAuthentication
    hidden [object] $_defineAuthChallenge
    hidden [object] $_preTokenGeneration
    hidden [object] $_customSMSSender
    hidden [object] $_postConfirmation
    hidden [object] $_customMessage
    hidden [object] $_customEmailSender

    [string] $CreateAuthChallenge
    [string] $PreSignUp
    [string] $KMSKeyID
    [string] $UserMigration
    [string] $PostAuthentication
    [string] $VerifyAuthChallengeResponse
    [string] $PreAuthentication
    [string] $DefineAuthChallenge
    [string] $PreTokenGeneration
    [CognitoUserPoolCustomSMSSender] $CustomSMSSender
    [string] $PostConfirmation
    [string] $CustomMessage
    [CognitoUserPoolCustomEmailSender] $CustomEmailSender

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name CreateAuthChallenge -Value {
            $this._createAuthChallenge
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._createAuthChallenge = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name PreSignUp -Value {
            $this._preSignUp
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._preSignUp = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name KMSKeyID -Value {
            $this._kMSKeyID
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._kMSKeyID = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name UserMigration -Value {
            $this._userMigration
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._userMigration = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name PostAuthentication -Value {
            $this._postAuthentication
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._postAuthentication = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name VerifyAuthChallengeResponse -Value {
            $this._verifyAuthChallengeResponse
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._verifyAuthChallengeResponse = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name PreAuthentication -Value {
            $this._preAuthentication
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._preAuthentication = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name DefineAuthChallenge -Value {
            $this._defineAuthChallenge
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._defineAuthChallenge = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name PreTokenGeneration -Value {
            $this._preTokenGeneration
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._preTokenGeneration = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name CustomSMSSender -Value {
            $this._customSMSSender
        } -SecondValue {
            param([ValidateType(([CognitoUserPoolCustomSMSSender], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._customSMSSender = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name PostConfirmation -Value {
            $this._postConfirmation
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._postConfirmation = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name CustomMessage -Value {
            $this._customMessage
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._customMessage = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name CustomEmailSender -Value {
            $this._customEmailSender
        } -SecondValue {
            param([ValidateType(([CognitoUserPoolCustomEmailSender], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._customEmailSender = $value
        }
    }

    CognitoUserPoolLambdaConfig() : base() {}
    CognitoUserPoolLambdaConfig([IDictionary] $props) : base($props) {}
    CognitoUserPoolLambdaConfig([psobject] $props) : base($props) {}
}

Write-Verbose "Importing class 'CognitoUserPoolInviteMessageTemplate'"

class CognitoUserPoolInviteMessageTemplate : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSCognitoUserPoolInviteMessageTemplate'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-cognito-userpool-invitemessagetemplate.html'

    hidden [object] $_emailMessage
    hidden [object] $_sMSMessage
    hidden [object] $_emailSubject

    [string] $EmailMessage
    [string] $SMSMessage
    [string] $EmailSubject

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name EmailMessage -Value {
            $this._emailMessage
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._emailMessage = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name SMSMessage -Value {
            $this._sMSMessage
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._sMSMessage = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name EmailSubject -Value {
            $this._emailSubject
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._emailSubject = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
    }

    CognitoUserPoolInviteMessageTemplate() : base() {}
    CognitoUserPoolInviteMessageTemplate([IDictionary] $props) : base($props) {}
    CognitoUserPoolInviteMessageTemplate([psobject] $props) : base($props) {}
}

Write-Verbose "Importing class 'CognitoUserPoolClientTokenValidityUnits'"

class CognitoUserPoolClientTokenValidityUnits : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSCognitoUserPoolClientTokenValidityUnits'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-cognito-userpoolclient-tokenvalidityunits.html'

    hidden [object] $_idToken
    hidden [object] $_refreshToken
    hidden [object] $_accessToken

    [string] $IdToken
    [string] $RefreshToken
    [string] $AccessToken

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name IdToken -Value {
            $this._idToken
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._idToken = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name RefreshToken -Value {
            $this._refreshToken
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._refreshToken = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name AccessToken -Value {
            $this._accessToken
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._accessToken = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
    }

    CognitoUserPoolClientTokenValidityUnits() : base() {}
    CognitoUserPoolClientTokenValidityUnits([IDictionary] $props) : base($props) {}
    CognitoUserPoolClientTokenValidityUnits([psobject] $props) : base($props) {}
}

Write-Verbose "Importing class 'CognitoUserPoolClientAnalyticsConfiguration'"

class CognitoUserPoolClientAnalyticsConfiguration : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSCognitoUserPoolClientAnalyticsConfiguration'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-cognito-userpoolclient-analyticsconfiguration.html'

    hidden [object] $_applicationArn
    hidden [object] $_userDataShared
    hidden [object] $_externalId
    hidden [object] $_applicationId
    hidden [object] $_roleArn

    [string] $ApplicationArn
    [bool] $UserDataShared
    [string] $ExternalId
    [string] $ApplicationId
    [string] $RoleArn

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name ApplicationArn -Value {
            $this._applicationArn
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._applicationArn = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name UserDataShared -Value {
            $this._userDataShared
        } -SecondValue {
            param([ValidateType(([bool], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._userDataShared = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name ExternalId -Value {
            $this._externalId
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._externalId = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name ApplicationId -Value {
            $this._applicationId
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._applicationId = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name RoleArn -Value {
            $this._roleArn
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._roleArn = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
    }

    CognitoUserPoolClientAnalyticsConfiguration() : base() {}
    CognitoUserPoolClientAnalyticsConfiguration([IDictionary] $props) : base($props) {}
    CognitoUserPoolClientAnalyticsConfiguration([psobject] $props) : base($props) {}
}

Write-Verbose "Importing class 'CognitoUserPoolEmailConfiguration'"

class CognitoUserPoolEmailConfiguration : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSCognitoUserPoolEmailConfiguration'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-cognito-userpool-emailconfiguration.html'

    hidden [object] $_replyToEmailAddress
    hidden [object] $_configurationSet
    hidden [object] $_emailSendingAccount
    hidden [object] $_sourceArn
    hidden [object] $_from

    [string] $ReplyToEmailAddress
    [string] $ConfigurationSet
    [string] $EmailSendingAccount
    [string] $SourceArn
    [string] $From

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name ReplyToEmailAddress -Value {
            $this._replyToEmailAddress
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._replyToEmailAddress = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name ConfigurationSet -Value {
            $this._configurationSet
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._configurationSet = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name EmailSendingAccount -Value {
            $this._emailSendingAccount
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._emailSendingAccount = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name SourceArn -Value {
            $this._sourceArn
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._sourceArn = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name From -Value {
            $this._from
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._from = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
    }

    CognitoUserPoolEmailConfiguration() : base() {}
    CognitoUserPoolEmailConfiguration([IDictionary] $props) : base($props) {}
    CognitoUserPoolEmailConfiguration([psobject] $props) : base($props) {}
}

Write-Verbose "Importing class 'CognitoUserPoolSchemaAttribute'"

class CognitoUserPoolSchemaAttribute : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSCognitoUserPoolSchemaAttribute'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-cognito-userpool-schemaattribute.html'

    hidden [object] $_developerOnlyAttribute
    hidden [object] $_mutable
    hidden [object] $_attributeDataType
    hidden [object] $_stringAttributeConstraints
    hidden [object] $_required
    hidden [object] $_numberAttributeConstraints
    hidden [object] $_name

    [bool] $DeveloperOnlyAttribute
    [bool] $Mutable
    [string] $AttributeDataType
    [CognitoUserPoolStringAttributeConstraints] $StringAttributeConstraints
    [bool] $Required
    [CognitoUserPoolNumberAttributeConstraints] $NumberAttributeConstraints
    [string] $Name

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name DeveloperOnlyAttribute -Value {
            $this._developerOnlyAttribute
        } -SecondValue {
            param([ValidateType(([bool], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._developerOnlyAttribute = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Mutable -Value {
            $this._mutable
        } -SecondValue {
            param([ValidateType(([bool], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._mutable = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name AttributeDataType -Value {
            $this._attributeDataType
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._attributeDataType = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name StringAttributeConstraints -Value {
            $this._stringAttributeConstraints
        } -SecondValue {
            param([ValidateType(([CognitoUserPoolStringAttributeConstraints], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._stringAttributeConstraints = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Required -Value {
            $this._required
        } -SecondValue {
            param([ValidateType(([bool], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._required = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name NumberAttributeConstraints -Value {
            $this._numberAttributeConstraints
        } -SecondValue {
            param([ValidateType(([CognitoUserPoolNumberAttributeConstraints], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._numberAttributeConstraints = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Name -Value {
            $this._name
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._name = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
    }

    CognitoUserPoolSchemaAttribute() : base() {}
    CognitoUserPoolSchemaAttribute([IDictionary] $props) : base($props) {}
    CognitoUserPoolSchemaAttribute([psobject] $props) : base($props) {}
}

Write-Verbose "Importing class 'CognitoUserPoolNumberAttributeConstraints'"

class CognitoUserPoolNumberAttributeConstraints : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSCognitoUserPoolNumberAttributeConstraints'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-cognito-userpool-numberattributeconstraints.html'

    hidden [object] $_minValue
    hidden [object] $_maxValue

    [string] $MinValue
    [string] $MaxValue

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name MinValue -Value {
            $this._minValue
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._minValue = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name MaxValue -Value {
            $this._maxValue
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._maxValue = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
    }

    CognitoUserPoolNumberAttributeConstraints() : base() {}
    CognitoUserPoolNumberAttributeConstraints([IDictionary] $props) : base($props) {}
    CognitoUserPoolNumberAttributeConstraints([psobject] $props) : base($props) {}
}

Write-Verbose "Importing class 'CognitoUserPoolCustomSMSSender'"

class CognitoUserPoolCustomSMSSender : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSCognitoUserPoolCustomSMSSender'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-cognito-userpool-customsmssender.html'

    hidden [object] $_lambdaArn
    hidden [object] $_lambdaVersion

    [string] $LambdaArn
    [string] $LambdaVersion

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name LambdaArn -Value {
            $this._lambdaArn
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._lambdaArn = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name LambdaVersion -Value {
            $this._lambdaVersion
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._lambdaVersion = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
    }

    CognitoUserPoolCustomSMSSender() : base() {}
    CognitoUserPoolCustomSMSSender([IDictionary] $props) : base($props) {}
    CognitoUserPoolCustomSMSSender([psobject] $props) : base($props) {}
}

Write-Verbose "Importing class 'CognitoUserPoolRiskConfigurationAttachmentNotifyEmailType'"

class CognitoUserPoolRiskConfigurationAttachmentNotifyEmailType : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSCognitoUserPoolRiskConfigurationAttachmentNotifyEmailType'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-cognito-userpoolriskconfigurationattachment-notifyemailtype.html'

    hidden [object] $_textBody
    hidden [object] $_htmlBody
    hidden [object] $_subject

    [string] $TextBody
    [string] $HtmlBody
    [string] $Subject

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name TextBody -Value {
            $this._textBody
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._textBody = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name HtmlBody -Value {
            $this._htmlBody
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._htmlBody = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Subject -Value {
            $this._subject
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._subject = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
    }

    CognitoUserPoolRiskConfigurationAttachmentNotifyEmailType() : base() {}
    CognitoUserPoolRiskConfigurationAttachmentNotifyEmailType([IDictionary] $props) : base($props) {}
    CognitoUserPoolRiskConfigurationAttachmentNotifyEmailType([psobject] $props) : base($props) {}
}

Write-Verbose "Importing class 'CognitoUserPoolAccountRecoverySetting'"

class CognitoUserPoolAccountRecoverySetting : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSCognitoUserPoolAccountRecoverySetting'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-cognito-userpool-accountrecoverysetting.html'

    hidden [object] $_recoveryMechanisms

    [CognitoUserPoolRecoveryOption[]] $RecoveryMechanisms

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name RecoveryMechanisms -Value {
            $this._recoveryMechanisms
        } -SecondValue {
            param([ValidateType(([CognitoUserPoolRecoveryOption], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this._recoveryMechanisms = $value
        }
    }

    CognitoUserPoolAccountRecoverySetting() : base() {}
    CognitoUserPoolAccountRecoverySetting([IDictionary] $props) : base($props) {}
    CognitoUserPoolAccountRecoverySetting([psobject] $props) : base($props) {}
}

Write-Verbose "Importing class 'CognitoUserPoolUserPoolAddOns'"

class CognitoUserPoolUserPoolAddOns : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSCognitoUserPoolUserPoolAddOns'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-cognito-userpool-userpooladdons.html'

    hidden [object] $_advancedSecurityMode

    [string] $AdvancedSecurityMode

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name AdvancedSecurityMode -Value {
            $this._advancedSecurityMode
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._advancedSecurityMode = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
    }

    CognitoUserPoolUserPoolAddOns() : base() {}
    CognitoUserPoolUserPoolAddOns([IDictionary] $props) : base($props) {}
    CognitoUserPoolUserPoolAddOns([psobject] $props) : base($props) {}
}

Write-Verbose "Importing class 'CognitoUserPoolRiskConfigurationAttachmentCompromisedCredentialsActionsType'"

class CognitoUserPoolRiskConfigurationAttachmentCompromisedCredentialsActionsType : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSCognitoUserPoolRiskConfigurationAttachmentCompromisedCredentialsActionsType'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-cognito-userpoolriskconfigurationattachment-compromisedcredentialsactionstype.html'

    hidden [object] $_eventAction

    [string] $EventAction

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name EventAction -Value {
            $this._eventAction
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._eventAction = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
    }

    CognitoUserPoolRiskConfigurationAttachmentCompromisedCredentialsActionsType() : base() {}
    CognitoUserPoolRiskConfigurationAttachmentCompromisedCredentialsActionsType([IDictionary] $props) : base($props) {}
    CognitoUserPoolRiskConfigurationAttachmentCompromisedCredentialsActionsType([psobject] $props) : base($props) {}
}

Write-Verbose "Importing class 'CognitoUserPoolRiskConfigurationAttachmentNotifyConfigurationType'"

class CognitoUserPoolRiskConfigurationAttachmentNotifyConfigurationType : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSCognitoUserPoolRiskConfigurationAttachmentNotifyConfigurationType'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-cognito-userpoolriskconfigurationattachment-notifyconfigurationtype.html'

    hidden [object] $_blockEmail
    hidden [object] $_replyTo
    hidden [object] $_sourceArn
    hidden [object] $_noActionEmail
    hidden [object] $_from
    hidden [object] $_mfaEmail

    [CognitoUserPoolRiskConfigurationAttachmentNotifyEmailType] $BlockEmail
    [string] $ReplyTo
    [string] $SourceArn
    [CognitoUserPoolRiskConfigurationAttachmentNotifyEmailType] $NoActionEmail
    [string] $From
    [CognitoUserPoolRiskConfigurationAttachmentNotifyEmailType] $MfaEmail

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name BlockEmail -Value {
            $this._blockEmail
        } -SecondValue {
            param([ValidateType(([CognitoUserPoolRiskConfigurationAttachmentNotifyEmailType], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._blockEmail = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name ReplyTo -Value {
            $this._replyTo
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._replyTo = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name SourceArn -Value {
            $this._sourceArn
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._sourceArn = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name NoActionEmail -Value {
            $this._noActionEmail
        } -SecondValue {
            param([ValidateType(([CognitoUserPoolRiskConfigurationAttachmentNotifyEmailType], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._noActionEmail = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name From -Value {
            $this._from
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._from = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name MfaEmail -Value {
            $this._mfaEmail
        } -SecondValue {
            param([ValidateType(([CognitoUserPoolRiskConfigurationAttachmentNotifyEmailType], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._mfaEmail = $value
        }
    }

    CognitoUserPoolRiskConfigurationAttachmentNotifyConfigurationType() : base() {}
    CognitoUserPoolRiskConfigurationAttachmentNotifyConfigurationType([IDictionary] $props) : base($props) {}
    CognitoUserPoolRiskConfigurationAttachmentNotifyConfigurationType([psobject] $props) : base($props) {}
}

Write-Verbose "Importing class 'CognitoIdentityPoolPushSync'"

class CognitoIdentityPoolPushSync : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSCognitoIdentityPoolPushSync'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-cognito-identitypool-pushsync.html'

    hidden [object] $_applicationArns
    hidden [object] $_roleArn

    [string[]] $ApplicationArns
    [string] $RoleArn

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name ApplicationArns -Value {
            $this._applicationArns
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this._applicationArns = @($value)
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name RoleArn -Value {
            $this._roleArn
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._roleArn = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
    }

    CognitoIdentityPoolPushSync() : base() {}
    CognitoIdentityPoolPushSync([IDictionary] $props) : base($props) {}
    CognitoIdentityPoolPushSync([psobject] $props) : base($props) {}
}

Write-Verbose "Importing class 'CognitoIdentityPoolCognitoIdentityProvider'"

class CognitoIdentityPoolCognitoIdentityProvider : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSCognitoIdentityPoolCognitoIdentityProvider'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-cognito-identitypool-cognitoidentityprovider.html'

    hidden [object] $_serverSideTokenCheck
    hidden [object] $_providerName
    hidden [object] $_clientId

    [bool] $ServerSideTokenCheck
    [string] $ProviderName
    [string] $ClientId

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name ServerSideTokenCheck -Value {
            $this._serverSideTokenCheck
        } -SecondValue {
            param([ValidateType(([bool], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._serverSideTokenCheck = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name ProviderName -Value {
            $this._providerName
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._providerName = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name ClientId -Value {
            $this._clientId
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._clientId = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
    }

    CognitoIdentityPoolCognitoIdentityProvider() : base() {}
    CognitoIdentityPoolCognitoIdentityProvider([IDictionary] $props) : base($props) {}
    CognitoIdentityPoolCognitoIdentityProvider([psobject] $props) : base($props) {}
}

Write-Verbose "Importing class 'CognitoUserPoolPolicies'"

class CognitoUserPoolPolicies : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSCognitoUserPoolPolicies'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-cognito-userpool-policies.html'

    hidden [object] $_passwordPolicy

    [CognitoUserPoolPasswordPolicy] $PasswordPolicy

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name PasswordPolicy -Value {
            $this._passwordPolicy
        } -SecondValue {
            param([ValidateType(([CognitoUserPoolPasswordPolicy], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._passwordPolicy = $value
        }
    }

    CognitoUserPoolPolicies() : base() {}
    CognitoUserPoolPolicies([IDictionary] $props) : base($props) {}
    CognitoUserPoolPolicies([psobject] $props) : base($props) {}
}

Write-Verbose "Importing class 'CognitoUserPoolRiskConfigurationAttachmentAccountTakeoverRiskConfigurationType'"

class CognitoUserPoolRiskConfigurationAttachmentAccountTakeoverRiskConfigurationType : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSCognitoUserPoolRiskConfigurationAttachmentAccountTakeoverRiskConfigurationType'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-cognito-userpoolriskconfigurationattachment-accounttakeoverriskconfigurationtype.html'

    hidden [object] $_actions
    hidden [object] $_notifyConfiguration

    [CognitoUserPoolRiskConfigurationAttachmentAccountTakeoverActionsType] $Actions
    [CognitoUserPoolRiskConfigurationAttachmentNotifyConfigurationType] $NotifyConfiguration

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name Actions -Value {
            $this._actions
        } -SecondValue {
            param([ValidateType(([CognitoUserPoolRiskConfigurationAttachmentAccountTakeoverActionsType], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._actions = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name NotifyConfiguration -Value {
            $this._notifyConfiguration
        } -SecondValue {
            param([ValidateType(([CognitoUserPoolRiskConfigurationAttachmentNotifyConfigurationType], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._notifyConfiguration = $value
        }
    }

    CognitoUserPoolRiskConfigurationAttachmentAccountTakeoverRiskConfigurationType() : base() {}
    CognitoUserPoolRiskConfigurationAttachmentAccountTakeoverRiskConfigurationType([IDictionary] $props) : base($props) {}
    CognitoUserPoolRiskConfigurationAttachmentAccountTakeoverRiskConfigurationType([psobject] $props) : base($props) {}
}

Write-Verbose "Importing class 'CognitoUserPoolCustomEmailSender'"

class CognitoUserPoolCustomEmailSender : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSCognitoUserPoolCustomEmailSender'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-cognito-userpool-customemailsender.html'

    hidden [object] $_lambdaArn
    hidden [object] $_lambdaVersion

    [string] $LambdaArn
    [string] $LambdaVersion

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name LambdaArn -Value {
            $this._lambdaArn
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._lambdaArn = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name LambdaVersion -Value {
            $this._lambdaVersion
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._lambdaVersion = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
    }

    CognitoUserPoolCustomEmailSender() : base() {}
    CognitoUserPoolCustomEmailSender([IDictionary] $props) : base($props) {}
    CognitoUserPoolCustomEmailSender([psobject] $props) : base($props) {}
}

Write-Verbose "Importing class 'CognitoUserPoolDomainCustomDomainConfigType'"

class CognitoUserPoolDomainCustomDomainConfigType : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSCognitoUserPoolDomainCustomDomainConfigType'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-cognito-userpooldomain-customdomainconfigtype.html'

    hidden [object] $_certificateArn

    [string] $CertificateArn

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name CertificateArn -Value {
            $this._certificateArn
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._certificateArn = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
    }

    CognitoUserPoolDomainCustomDomainConfigType() : base() {}
    CognitoUserPoolDomainCustomDomainConfigType([IDictionary] $props) : base($props) {}
    CognitoUserPoolDomainCustomDomainConfigType([psobject] $props) : base($props) {}
}

Write-Verbose "Importing class 'CognitoIdentityPoolRoleAttachmentRulesConfigurationType'"

class CognitoIdentityPoolRoleAttachmentRulesConfigurationType : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSCognitoIdentityPoolRoleAttachmentRulesConfigurationType'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-cognito-identitypoolroleattachment-rulesconfigurationtype.html'

    hidden [object] $_rules

    [CognitoIdentityPoolRoleAttachmentMappingRule[]] $Rules

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name Rules -Value {
            $this._rules
        } -SecondValue {
            param([ValidateType(([CognitoIdentityPoolRoleAttachmentMappingRule], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this._rules = $value
        }
    }

    CognitoIdentityPoolRoleAttachmentRulesConfigurationType() : base() {}
    CognitoIdentityPoolRoleAttachmentRulesConfigurationType([IDictionary] $props) : base($props) {}
    CognitoIdentityPoolRoleAttachmentRulesConfigurationType([psobject] $props) : base($props) {}
}

Write-Verbose "Importing class 'CognitoUserPoolDeviceConfiguration'"

class CognitoUserPoolDeviceConfiguration : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSCognitoUserPoolDeviceConfiguration'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-cognito-userpool-deviceconfiguration.html'

    hidden [object] $_deviceOnlyRememberedOnUserPrompt
    hidden [object] $_challengeRequiredOnNewDevice

    [bool] $DeviceOnlyRememberedOnUserPrompt
    [bool] $ChallengeRequiredOnNewDevice

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name DeviceOnlyRememberedOnUserPrompt -Value {
            $this._deviceOnlyRememberedOnUserPrompt
        } -SecondValue {
            param([ValidateType(([bool], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._deviceOnlyRememberedOnUserPrompt = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name ChallengeRequiredOnNewDevice -Value {
            $this._challengeRequiredOnNewDevice
        } -SecondValue {
            param([ValidateType(([bool], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._challengeRequiredOnNewDevice = $value
        }
    }

    CognitoUserPoolDeviceConfiguration() : base() {}
    CognitoUserPoolDeviceConfiguration([IDictionary] $props) : base($props) {}
    CognitoUserPoolDeviceConfiguration([psobject] $props) : base($props) {}
}

Write-Verbose "Importing class 'CognitoUserPoolUsernameConfiguration'"

class CognitoUserPoolUsernameConfiguration : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSCognitoUserPoolUsernameConfiguration'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-cognito-userpool-usernameconfiguration.html'

    hidden [object] $_caseSensitive

    [bool] $CaseSensitive

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name CaseSensitive -Value {
            $this._caseSensitive
        } -SecondValue {
            param([ValidateType(([bool], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._caseSensitive = $value
        }
    }

    CognitoUserPoolUsernameConfiguration() : base() {}
    CognitoUserPoolUsernameConfiguration([IDictionary] $props) : base($props) {}
    CognitoUserPoolUsernameConfiguration([psobject] $props) : base($props) {}
}

Write-Verbose "Importing class 'CognitoUserPoolRiskConfigurationAttachment'"

class CognitoUserPoolRiskConfigurationAttachment : VSResource {
    hidden [string] $_vsFunctionName = 'New-VSCognitoUserPoolRiskConfigurationAttachment'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cognito-userpoolriskconfigurationattachment.html'

    hidden [object] $_condition

    [string] $Type = 'AWS::Cognito::UserPoolRiskConfigurationAttachment'
    [CognitoUserPoolRiskConfigurationAttachmentCompromisedCredentialsRiskConfigurationType] $CompromisedCredentialsRiskConfiguration
    [string] $UserPoolId
    [string] $ClientId
    [CognitoUserPoolRiskConfigurationAttachmentAccountTakeoverRiskConfigurationType] $AccountTakeoverRiskConfiguration
    [CognitoUserPoolRiskConfigurationAttachmentRiskExceptionConfigurationType] $RiskExceptionConfiguration
    [VSJson] $Metadata
    [UpdatePolicy] $UpdatePolicy
    [string] $Condition

    hidden [void] _addAccessors() {
        $this._addBaseAccessors()
        $this | Add-Member -Force -MemberType ScriptProperty -Name CompromisedCredentialsRiskConfiguration -Value {
            $this.Properties['CompromisedCredentialsRiskConfiguration']
        } -SecondValue {
            param([ValidateType(([CognitoUserPoolRiskConfigurationAttachmentCompromisedCredentialsRiskConfigurationType], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['CompromisedCredentialsRiskConfiguration'] = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name UserPoolId -Value {
            $this.Properties['UserPoolId']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['UserPoolId'] = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name ClientId -Value {
            $this.Properties['ClientId']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['ClientId'] = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name AccountTakeoverRiskConfiguration -Value {
            $this.Properties['AccountTakeoverRiskConfiguration']
        } -SecondValue {
            param([ValidateType(([CognitoUserPoolRiskConfigurationAttachmentAccountTakeoverRiskConfigurationType], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['AccountTakeoverRiskConfiguration'] = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name RiskExceptionConfiguration -Value {
            $this.Properties['RiskExceptionConfiguration']
        } -SecondValue {
            param([ValidateType(([CognitoUserPoolRiskConfigurationAttachmentRiskExceptionConfigurationType], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['RiskExceptionConfiguration'] = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Condition -Value {
            $this._condition
        } -SecondValue {
            param(
                [ValidateType(([string], [IntrinsicFunction], [ConditionFunction]))] [object]
                $value
            )
            $this._condition = $value
        }
    }

    CognitoUserPoolRiskConfigurationAttachment() : base() {}
    CognitoUserPoolRiskConfigurationAttachment([IDictionary] $props) : base($props) {}
    CognitoUserPoolRiskConfigurationAttachment([psobject] $props) : base($props) {}
}

Write-Verbose "Importing class 'CognitoUserPoolIdentityProvider'"

class CognitoUserPoolIdentityProvider : VSResource {
    hidden [string] $_vsFunctionName = 'New-VSCognitoUserPoolIdentityProvider'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cognito-userpoolidentityprovider.html'

    hidden [object] $_condition

    [string] $Type = 'AWS::Cognito::UserPoolIdentityProvider'
    [string] $ProviderName
    [string] $UserPoolId
    [VSJson] $AttributeMapping
    [VSJson] $ProviderDetails
    [string] $ProviderType
    [string[]] $IdpIdentifiers
    [VSJson] $Metadata
    [UpdatePolicy] $UpdatePolicy
    [string] $Condition

    hidden [void] _addAccessors() {
        $this._addBaseAccessors()
        $this | Add-Member -Force -MemberType ScriptProperty -Name ProviderName -Value {
            $this.Properties['ProviderName']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['ProviderName'] = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name UserPoolId -Value {
            $this.Properties['UserPoolId']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['UserPoolId'] = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name AttributeMapping -Value {
            $this.Properties['AttributeMapping']
        } -SecondValue {
            param([ValidateType(([string], [VSJson], [VSYaml], [psobject], [IDictionary]))][object] $value)
            $this.Properties['AttributeMapping'] = [VSJson]::Transform($value)
            Write-Debug $this.Properties['AttributeMapping']
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name ProviderDetails -Value {
            $this.Properties['ProviderDetails']
        } -SecondValue {
            param([ValidateType(([string], [VSJson], [VSYaml], [psobject], [IDictionary]))][object] $value)
            $this.Properties['ProviderDetails'] = [VSJson]::Transform($value)
            Write-Debug $this.Properties['ProviderDetails']
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name ProviderType -Value {
            $this.Properties['ProviderType']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['ProviderType'] = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name IdpIdentifiers -Value {
            $this.Properties['IdpIdentifiers']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this.Properties['IdpIdentifiers'] = @($value)
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Condition -Value {
            $this._condition
        } -SecondValue {
            param(
                [ValidateType(([string], [IntrinsicFunction], [ConditionFunction]))] [object]
                $value
            )
            $this._condition = $value
        }
    }

    CognitoUserPoolIdentityProvider() : base() {}
    CognitoUserPoolIdentityProvider([IDictionary] $props) : base($props) {}
    CognitoUserPoolIdentityProvider([psobject] $props) : base($props) {}
}

Write-Verbose "Importing class 'CognitoIdentityPool'"

class CognitoIdentityPool : VSResource {
    hidden [string] $_vsFunctionName = 'New-VSCognitoIdentityPool'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cognito-identitypool.html'

    hidden [string[]] $_attributes = @('Name')
    hidden [object] $_condition

    [string] $Type = 'AWS::Cognito::IdentityPool'
    [CognitoIdentityPoolPushSync] $PushSync
    [CognitoIdentityPoolCognitoIdentityProvider[]] $CognitoIdentityProviders
    [VSJson] $CognitoEvents
    [string] $DeveloperProviderName
    [CognitoIdentityPoolCognitoStreams] $CognitoStreams
    [string] $IdentityPoolName
    [bool] $AllowUnauthenticatedIdentities
    [VSJson] $SupportedLoginProviders
    [string[]] $SamlProviderARNs
    [string[]] $OpenIdConnectProviderARNs
    [bool] $AllowClassicFlow
    [VSJson] $Metadata
    [UpdatePolicy] $UpdatePolicy
    [string] $Condition

    hidden [void] _addAccessors() {
        $this._addBaseAccessors()
        $this | Add-Member -Force -MemberType ScriptProperty -Name PushSync -Value {
            $this.Properties['PushSync']
        } -SecondValue {
            param([ValidateType(([CognitoIdentityPoolPushSync], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['PushSync'] = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name CognitoIdentityProviders -Value {
            $this.Properties['CognitoIdentityProviders']
        } -SecondValue {
            param([ValidateType(([CognitoIdentityPoolCognitoIdentityProvider], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this.Properties['CognitoIdentityProviders'] = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name CognitoEvents -Value {
            $this.Properties['CognitoEvents']
        } -SecondValue {
            param([ValidateType(([string], [VSJson], [VSYaml], [psobject], [IDictionary]))][object] $value)
            $this.Properties['CognitoEvents'] = [VSJson]::Transform($value)
            Write-Debug $this.Properties['CognitoEvents']
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name DeveloperProviderName -Value {
            $this.Properties['DeveloperProviderName']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['DeveloperProviderName'] = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name CognitoStreams -Value {
            $this.Properties['CognitoStreams']
        } -SecondValue {
            param([ValidateType(([CognitoIdentityPoolCognitoStreams], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['CognitoStreams'] = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name IdentityPoolName -Value {
            $this.Properties['IdentityPoolName']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['IdentityPoolName'] = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name AllowUnauthenticatedIdentities -Value {
            $this.Properties['AllowUnauthenticatedIdentities']
        } -SecondValue {
            param([ValidateType(([bool], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['AllowUnauthenticatedIdentities'] = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name SupportedLoginProviders -Value {
            $this.Properties['SupportedLoginProviders']
        } -SecondValue {
            param([ValidateType(([string], [VSJson], [VSYaml], [psobject], [IDictionary]))][object] $value)
            $this.Properties['SupportedLoginProviders'] = [VSJson]::Transform($value)
            Write-Debug $this.Properties['SupportedLoginProviders']
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name SamlProviderARNs -Value {
            $this.Properties['SamlProviderARNs']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this.Properties['SamlProviderARNs'] = @($value)
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name OpenIdConnectProviderARNs -Value {
            $this.Properties['OpenIdConnectProviderARNs']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this.Properties['OpenIdConnectProviderARNs'] = @($value)
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name AllowClassicFlow -Value {
            $this.Properties['AllowClassicFlow']
        } -SecondValue {
            param([ValidateType(([bool], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['AllowClassicFlow'] = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Condition -Value {
            $this._condition
        } -SecondValue {
            param(
                [ValidateType(([string], [IntrinsicFunction], [ConditionFunction]))] [object]
                $value
            )
            $this._condition = $value
        }
    }

    CognitoIdentityPool() : base() {}
    CognitoIdentityPool([IDictionary] $props) : base($props) {}
    CognitoIdentityPool([psobject] $props) : base($props) {}
}

Write-Verbose "Importing class 'CognitoUserPool'"

class CognitoUserPool : VSResource {
    hidden [string] $_vsFunctionName = 'New-VSCognitoUserPool'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cognito-userpool.html'

    hidden [string[]] $_attributes = @('ProviderName','ProviderURL','Arn')
    hidden [object] $_condition

    [string] $Type = 'AWS::Cognito::UserPool'
    [VSJson] $UserPoolTags
    [CognitoUserPoolPolicies] $Policies
    [CognitoUserPoolVerificationMessageTemplate] $VerificationMessageTemplate
    [string] $MfaConfiguration
    [CognitoUserPoolSchemaAttribute[]] $Schema
    [CognitoUserPoolAdminCreateUserConfig] $AdminCreateUserConfig
    [string] $SmsAuthenticationMessage
    [CognitoUserPoolUsernameConfiguration] $UsernameConfiguration
    [string] $UserPoolName
    [string] $SmsVerificationMessage
    [CognitoUserPoolUserPoolAddOns] $UserPoolAddOns
    [CognitoUserPoolEmailConfiguration] $EmailConfiguration
    [CognitoUserPoolSmsConfiguration] $SmsConfiguration
    [string[]] $AliasAttributes
    [string[]] $EnabledMfas
    [string] $EmailVerificationSubject
    [CognitoUserPoolLambdaConfig] $LambdaConfig
    [string[]] $UsernameAttributes
    [string[]] $AutoVerifiedAttributes
    [CognitoUserPoolDeviceConfiguration] $DeviceConfiguration
    [string] $EmailVerificationMessage
    [CognitoUserPoolAccountRecoverySetting] $AccountRecoverySetting
    [VSJson] $Metadata
    [UpdatePolicy] $UpdatePolicy
    [string] $Condition

    hidden [void] _addAccessors() {
        $this._addBaseAccessors()
        $this | Add-Member -Force -MemberType ScriptProperty -Name UserPoolTags -Value {
            $this.Properties['UserPoolTags']
        } -SecondValue {
            param([ValidateType(([string], [VSJson], [VSYaml], [psobject], [IDictionary]))][object] $value)
            $this.Properties['UserPoolTags'] = [VSJson]::Transform($value)
            Write-Debug $this.Properties['UserPoolTags']
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Policies -Value {
            $this.Properties['Policies']
        } -SecondValue {
            param([ValidateType(([CognitoUserPoolPolicies], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['Policies'] = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name VerificationMessageTemplate -Value {
            $this.Properties['VerificationMessageTemplate']
        } -SecondValue {
            param([ValidateType(([CognitoUserPoolVerificationMessageTemplate], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['VerificationMessageTemplate'] = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name MfaConfiguration -Value {
            $this.Properties['MfaConfiguration']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['MfaConfiguration'] = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Schema -Value {
            $this.Properties['Schema']
        } -SecondValue {
            param([ValidateType(([CognitoUserPoolSchemaAttribute], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this.Properties['Schema'] = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name AdminCreateUserConfig -Value {
            $this.Properties['AdminCreateUserConfig']
        } -SecondValue {
            param([ValidateType(([CognitoUserPoolAdminCreateUserConfig], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['AdminCreateUserConfig'] = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name SmsAuthenticationMessage -Value {
            $this.Properties['SmsAuthenticationMessage']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['SmsAuthenticationMessage'] = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name UsernameConfiguration -Value {
            $this.Properties['UsernameConfiguration']
        } -SecondValue {
            param([ValidateType(([CognitoUserPoolUsernameConfiguration], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['UsernameConfiguration'] = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name UserPoolName -Value {
            $this.Properties['UserPoolName']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['UserPoolName'] = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name SmsVerificationMessage -Value {
            $this.Properties['SmsVerificationMessage']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['SmsVerificationMessage'] = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name UserPoolAddOns -Value {
            $this.Properties['UserPoolAddOns']
        } -SecondValue {
            param([ValidateType(([CognitoUserPoolUserPoolAddOns], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['UserPoolAddOns'] = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name EmailConfiguration -Value {
            $this.Properties['EmailConfiguration']
        } -SecondValue {
            param([ValidateType(([CognitoUserPoolEmailConfiguration], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['EmailConfiguration'] = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name SmsConfiguration -Value {
            $this.Properties['SmsConfiguration']
        } -SecondValue {
            param([ValidateType(([CognitoUserPoolSmsConfiguration], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['SmsConfiguration'] = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name AliasAttributes -Value {
            $this.Properties['AliasAttributes']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this.Properties['AliasAttributes'] = @($value)
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name EnabledMfas -Value {
            $this.Properties['EnabledMfas']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this.Properties['EnabledMfas'] = @($value)
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name EmailVerificationSubject -Value {
            $this.Properties['EmailVerificationSubject']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['EmailVerificationSubject'] = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name LambdaConfig -Value {
            $this.Properties['LambdaConfig']
        } -SecondValue {
            param([ValidateType(([CognitoUserPoolLambdaConfig], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['LambdaConfig'] = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name UsernameAttributes -Value {
            $this.Properties['UsernameAttributes']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this.Properties['UsernameAttributes'] = @($value)
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name AutoVerifiedAttributes -Value {
            $this.Properties['AutoVerifiedAttributes']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this.Properties['AutoVerifiedAttributes'] = @($value)
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name DeviceConfiguration -Value {
            $this.Properties['DeviceConfiguration']
        } -SecondValue {
            param([ValidateType(([CognitoUserPoolDeviceConfiguration], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['DeviceConfiguration'] = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name EmailVerificationMessage -Value {
            $this.Properties['EmailVerificationMessage']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['EmailVerificationMessage'] = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name AccountRecoverySetting -Value {
            $this.Properties['AccountRecoverySetting']
        } -SecondValue {
            param([ValidateType(([CognitoUserPoolAccountRecoverySetting], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['AccountRecoverySetting'] = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Condition -Value {
            $this._condition
        } -SecondValue {
            param(
                [ValidateType(([string], [IntrinsicFunction], [ConditionFunction]))] [object]
                $value
            )
            $this._condition = $value
        }
    }

    CognitoUserPool() : base() {}
    CognitoUserPool([IDictionary] $props) : base($props) {}
    CognitoUserPool([psobject] $props) : base($props) {}
}

Write-Verbose "Importing class 'CognitoUserPoolUserToGroupAttachment'"

class CognitoUserPoolUserToGroupAttachment : VSResource {
    hidden [string] $_vsFunctionName = 'New-VSCognitoUserPoolUserToGroupAttachment'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cognito-userpoolusertogroupattachment.html'

    hidden [object] $_condition

    [string] $Type = 'AWS::Cognito::UserPoolUserToGroupAttachment'
    [string] $GroupName
    [string] $UserPoolId
    [string] $Username
    [VSJson] $Metadata
    [UpdatePolicy] $UpdatePolicy
    [string] $Condition

    hidden [void] _addAccessors() {
        $this._addBaseAccessors()
        $this | Add-Member -Force -MemberType ScriptProperty -Name GroupName -Value {
            $this.Properties['GroupName']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['GroupName'] = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name UserPoolId -Value {
            $this.Properties['UserPoolId']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['UserPoolId'] = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Username -Value {
            $this.Properties['Username']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['Username'] = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Condition -Value {
            $this._condition
        } -SecondValue {
            param(
                [ValidateType(([string], [IntrinsicFunction], [ConditionFunction]))] [object]
                $value
            )
            $this._condition = $value
        }
    }

    CognitoUserPoolUserToGroupAttachment() : base() {}
    CognitoUserPoolUserToGroupAttachment([IDictionary] $props) : base($props) {}
    CognitoUserPoolUserToGroupAttachment([psobject] $props) : base($props) {}
}

Write-Verbose "Importing class 'CognitoUserPoolUser'"

class CognitoUserPoolUser : VSResource {
    hidden [string] $_vsFunctionName = 'New-VSCognitoUserPoolUser'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cognito-userpooluser.html'

    hidden [object] $_condition

    [string] $Type = 'AWS::Cognito::UserPoolUser'
    [CognitoUserPoolUserAttributeType[]] $ValidationData
    [string] $UserPoolId
    [string] $Username
    [string] $MessageAction
    [VSJson] $ClientMetadata
    [string[]] $DesiredDeliveryMediums
    [bool] $ForceAliasCreation
    [CognitoUserPoolUserAttributeType[]] $UserAttributes
    [VSJson] $Metadata
    [UpdatePolicy] $UpdatePolicy
    [string] $Condition

    hidden [void] _addAccessors() {
        $this._addBaseAccessors()
        $this | Add-Member -Force -MemberType ScriptProperty -Name ValidationData -Value {
            $this.Properties['ValidationData']
        } -SecondValue {
            param([ValidateType(([CognitoUserPoolUserAttributeType], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this.Properties['ValidationData'] = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name UserPoolId -Value {
            $this.Properties['UserPoolId']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['UserPoolId'] = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Username -Value {
            $this.Properties['Username']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['Username'] = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name MessageAction -Value {
            $this.Properties['MessageAction']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['MessageAction'] = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name ClientMetadata -Value {
            $this.Properties['ClientMetadata']
        } -SecondValue {
            param([ValidateType(([string], [VSJson], [VSYaml], [psobject], [IDictionary]))][object] $value)
            $this.Properties['ClientMetadata'] = [VSJson]::Transform($value)
            Write-Debug $this.Properties['ClientMetadata']
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name DesiredDeliveryMediums -Value {
            $this.Properties['DesiredDeliveryMediums']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this.Properties['DesiredDeliveryMediums'] = @($value)
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name ForceAliasCreation -Value {
            $this.Properties['ForceAliasCreation']
        } -SecondValue {
            param([ValidateType(([bool], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['ForceAliasCreation'] = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name UserAttributes -Value {
            $this.Properties['UserAttributes']
        } -SecondValue {
            param([ValidateType(([CognitoUserPoolUserAttributeType], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this.Properties['UserAttributes'] = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Condition -Value {
            $this._condition
        } -SecondValue {
            param(
                [ValidateType(([string], [IntrinsicFunction], [ConditionFunction]))] [object]
                $value
            )
            $this._condition = $value
        }
    }

    CognitoUserPoolUser() : base() {}
    CognitoUserPoolUser([IDictionary] $props) : base($props) {}
    CognitoUserPoolUser([psobject] $props) : base($props) {}
}

Write-Verbose "Importing class 'CognitoUserPoolUICustomizationAttachment'"

class CognitoUserPoolUICustomizationAttachment : VSResource {
    hidden [string] $_vsFunctionName = 'New-VSCognitoUserPoolUICustomizationAttachment'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cognito-userpooluicustomizationattachment.html'

    hidden [object] $_condition

    [string] $Type = 'AWS::Cognito::UserPoolUICustomizationAttachment'
    [string] $CSS
    [string] $UserPoolId
    [string] $ClientId
    [VSJson] $Metadata
    [UpdatePolicy] $UpdatePolicy
    [string] $Condition

    hidden [void] _addAccessors() {
        $this._addBaseAccessors()
        $this | Add-Member -Force -MemberType ScriptProperty -Name CSS -Value {
            $this.Properties['CSS']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['CSS'] = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name UserPoolId -Value {
            $this.Properties['UserPoolId']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['UserPoolId'] = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name ClientId -Value {
            $this.Properties['ClientId']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['ClientId'] = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Condition -Value {
            $this._condition
        } -SecondValue {
            param(
                [ValidateType(([string], [IntrinsicFunction], [ConditionFunction]))] [object]
                $value
            )
            $this._condition = $value
        }
    }

    CognitoUserPoolUICustomizationAttachment() : base() {}
    CognitoUserPoolUICustomizationAttachment([IDictionary] $props) : base($props) {}
    CognitoUserPoolUICustomizationAttachment([psobject] $props) : base($props) {}
}

Write-Verbose "Importing class 'CognitoUserPoolGroup'"

class CognitoUserPoolGroup : VSResource {
    hidden [string] $_vsFunctionName = 'New-VSCognitoUserPoolGroup'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cognito-userpoolgroup.html'

    hidden [object] $_condition

    [string] $Type = 'AWS::Cognito::UserPoolGroup'
    [string] $GroupName
    [string] $Description
    [string] $UserPoolId
    [double] $Precedence
    [string] $RoleArn
    [VSJson] $Metadata
    [UpdatePolicy] $UpdatePolicy
    [string] $Condition

    hidden [void] _addAccessors() {
        $this._addBaseAccessors()
        $this | Add-Member -Force -MemberType ScriptProperty -Name GroupName -Value {
            $this.Properties['GroupName']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['GroupName'] = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Description -Value {
            $this.Properties['Description']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['Description'] = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name UserPoolId -Value {
            $this.Properties['UserPoolId']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['UserPoolId'] = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Precedence -Value {
            $this.Properties['Precedence']
        } -SecondValue {
            param([ValidateType(([double], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['Precedence'] = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name RoleArn -Value {
            $this.Properties['RoleArn']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['RoleArn'] = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Condition -Value {
            $this._condition
        } -SecondValue {
            param(
                [ValidateType(([string], [IntrinsicFunction], [ConditionFunction]))] [object]
                $value
            )
            $this._condition = $value
        }
    }

    CognitoUserPoolGroup() : base() {}
    CognitoUserPoolGroup([IDictionary] $props) : base($props) {}
    CognitoUserPoolGroup([psobject] $props) : base($props) {}
}

Write-Verbose "Importing class 'CognitoUserPoolResourceServer'"

class CognitoUserPoolResourceServer : VSResource {
    hidden [string] $_vsFunctionName = 'New-VSCognitoUserPoolResourceServer'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cognito-userpoolresourceserver.html'

    hidden [object] $_condition

    [string] $Type = 'AWS::Cognito::UserPoolResourceServer'
    [string] $UserPoolId
    [string] $Identifier
    [CognitoUserPoolResourceServerResourceServerScopeType[]] $Scopes
    [string] $Name
    [VSJson] $Metadata
    [UpdatePolicy] $UpdatePolicy
    [string] $Condition

    hidden [void] _addAccessors() {
        $this._addBaseAccessors()
        $this | Add-Member -Force -MemberType ScriptProperty -Name UserPoolId -Value {
            $this.Properties['UserPoolId']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['UserPoolId'] = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Identifier -Value {
            $this.Properties['Identifier']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['Identifier'] = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Scopes -Value {
            $this.Properties['Scopes']
        } -SecondValue {
            param([ValidateType(([CognitoUserPoolResourceServerResourceServerScopeType], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this.Properties['Scopes'] = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Name -Value {
            $this.Properties['Name']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['Name'] = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Condition -Value {
            $this._condition
        } -SecondValue {
            param(
                [ValidateType(([string], [IntrinsicFunction], [ConditionFunction]))] [object]
                $value
            )
            $this._condition = $value
        }
    }

    CognitoUserPoolResourceServer() : base() {}
    CognitoUserPoolResourceServer([IDictionary] $props) : base($props) {}
    CognitoUserPoolResourceServer([psobject] $props) : base($props) {}
}

Write-Verbose "Importing class 'CognitoUserPoolClient'"

class CognitoUserPoolClient : VSResource {
    hidden [string] $_vsFunctionName = 'New-VSCognitoUserPoolClient'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cognito-userpoolclient.html'

    hidden [string[]] $_attributes = @('ClientSecret','Name')
    hidden [object] $_condition

    [string] $Type = 'AWS::Cognito::UserPoolClient'
    [CognitoUserPoolClientAnalyticsConfiguration] $AnalyticsConfiguration
    [bool] $GenerateSecret
    [string[]] $CallbackURLs
    [int] $IdTokenValidity
    [string[]] $AllowedOAuthScopes
    [CognitoUserPoolClientTokenValidityUnits] $TokenValidityUnits
    [string[]] $ReadAttributes
    [bool] $AllowedOAuthFlowsUserPoolClient
    [string] $DefaultRedirectURI
    [string[]] $SupportedIdentityProviders
    [string] $ClientName
    [string] $UserPoolId
    [string[]] $AllowedOAuthFlows
    [string[]] $ExplicitAuthFlows
    [string[]] $LogoutURLs
    [int] $AccessTokenValidity
    [int] $RefreshTokenValidity
    [string[]] $WriteAttributes
    [string] $PreventUserExistenceErrors
    [bool] $EnableTokenRevocation
    [VSJson] $Metadata
    [UpdatePolicy] $UpdatePolicy
    [string] $Condition

    hidden [void] _addAccessors() {
        $this._addBaseAccessors()
        $this | Add-Member -Force -MemberType ScriptProperty -Name AnalyticsConfiguration -Value {
            $this.Properties['AnalyticsConfiguration']
        } -SecondValue {
            param([ValidateType(([CognitoUserPoolClientAnalyticsConfiguration], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['AnalyticsConfiguration'] = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name GenerateSecret -Value {
            $this.Properties['GenerateSecret']
        } -SecondValue {
            param([ValidateType(([bool], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['GenerateSecret'] = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name CallbackURLs -Value {
            $this.Properties['CallbackURLs']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this.Properties['CallbackURLs'] = @($value)
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name IdTokenValidity -Value {
            $this.Properties['IdTokenValidity']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['IdTokenValidity'] = if ($cast = $value -as [int]) {
                $cast
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name AllowedOAuthScopes -Value {
            $this.Properties['AllowedOAuthScopes']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this.Properties['AllowedOAuthScopes'] = @($value)
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name TokenValidityUnits -Value {
            $this.Properties['TokenValidityUnits']
        } -SecondValue {
            param([ValidateType(([CognitoUserPoolClientTokenValidityUnits], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['TokenValidityUnits'] = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name ReadAttributes -Value {
            $this.Properties['ReadAttributes']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this.Properties['ReadAttributes'] = @($value)
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name AllowedOAuthFlowsUserPoolClient -Value {
            $this.Properties['AllowedOAuthFlowsUserPoolClient']
        } -SecondValue {
            param([ValidateType(([bool], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['AllowedOAuthFlowsUserPoolClient'] = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name DefaultRedirectURI -Value {
            $this.Properties['DefaultRedirectURI']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['DefaultRedirectURI'] = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name SupportedIdentityProviders -Value {
            $this.Properties['SupportedIdentityProviders']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this.Properties['SupportedIdentityProviders'] = @($value)
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name ClientName -Value {
            $this.Properties['ClientName']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['ClientName'] = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name UserPoolId -Value {
            $this.Properties['UserPoolId']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['UserPoolId'] = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name AllowedOAuthFlows -Value {
            $this.Properties['AllowedOAuthFlows']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this.Properties['AllowedOAuthFlows'] = @($value)
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name ExplicitAuthFlows -Value {
            $this.Properties['ExplicitAuthFlows']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this.Properties['ExplicitAuthFlows'] = @($value)
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name LogoutURLs -Value {
            $this.Properties['LogoutURLs']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this.Properties['LogoutURLs'] = @($value)
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name AccessTokenValidity -Value {
            $this.Properties['AccessTokenValidity']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['AccessTokenValidity'] = if ($cast = $value -as [int]) {
                $cast
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name RefreshTokenValidity -Value {
            $this.Properties['RefreshTokenValidity']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['RefreshTokenValidity'] = if ($cast = $value -as [int]) {
                $cast
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name WriteAttributes -Value {
            $this.Properties['WriteAttributes']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this.Properties['WriteAttributes'] = @($value)
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name PreventUserExistenceErrors -Value {
            $this.Properties['PreventUserExistenceErrors']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['PreventUserExistenceErrors'] = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name EnableTokenRevocation -Value {
            $this.Properties['EnableTokenRevocation']
        } -SecondValue {
            param([ValidateType(([bool], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['EnableTokenRevocation'] = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Condition -Value {
            $this._condition
        } -SecondValue {
            param(
                [ValidateType(([string], [IntrinsicFunction], [ConditionFunction]))] [object]
                $value
            )
            $this._condition = $value
        }
    }

    CognitoUserPoolClient() : base() {}
    CognitoUserPoolClient([IDictionary] $props) : base($props) {}
    CognitoUserPoolClient([psobject] $props) : base($props) {}
}

Write-Verbose "Importing class 'CognitoIdentityPoolRoleAttachment'"

class CognitoIdentityPoolRoleAttachment : VSResource {
    hidden [string] $_vsFunctionName = 'New-VSCognitoIdentityPoolRoleAttachment'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cognito-identitypoolroleattachment.html'

    hidden [object] $_condition

    [string] $Type = 'AWS::Cognito::IdentityPoolRoleAttachment'
    [VSJson] $RoleMappings
    [string] $IdentityPoolId
    [VSJson] $Roles
    [VSJson] $Metadata
    [UpdatePolicy] $UpdatePolicy
    [string] $Condition

    hidden [void] _addAccessors() {
        $this._addBaseAccessors()
        $this | Add-Member -Force -MemberType ScriptProperty -Name RoleMappings -Value {
            $this.Properties['RoleMappings']
        } -SecondValue {
            param([ValidateType(([string], [VSJson], [VSYaml], [psobject], [IDictionary]))][object] $value)
            $this.Properties['RoleMappings'] = [VSJson]::Transform($value)
            Write-Debug $this.Properties['RoleMappings']
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name IdentityPoolId -Value {
            $this.Properties['IdentityPoolId']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['IdentityPoolId'] = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Roles -Value {
            $this.Properties['Roles']
        } -SecondValue {
            param([ValidateType(([string], [VSJson], [VSYaml], [psobject], [IDictionary]))][object] $value)
            $this.Properties['Roles'] = [VSJson]::Transform($value)
            Write-Debug $this.Properties['Roles']
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Condition -Value {
            $this._condition
        } -SecondValue {
            param(
                [ValidateType(([string], [IntrinsicFunction], [ConditionFunction]))] [object]
                $value
            )
            $this._condition = $value
        }
    }

    CognitoIdentityPoolRoleAttachment() : base() {}
    CognitoIdentityPoolRoleAttachment([IDictionary] $props) : base($props) {}
    CognitoIdentityPoolRoleAttachment([psobject] $props) : base($props) {}
}

Write-Verbose "Importing class 'CognitoUserPoolDomain'"

class CognitoUserPoolDomain : VSResource {
    hidden [string] $_vsFunctionName = 'New-VSCognitoUserPoolDomain'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cognito-userpooldomain.html'

    hidden [object] $_condition

    [string] $Type = 'AWS::Cognito::UserPoolDomain'
    [string] $UserPoolId
    [CognitoUserPoolDomainCustomDomainConfigType] $CustomDomainConfig
    [string] $Domain
    [VSJson] $Metadata
    [UpdatePolicy] $UpdatePolicy
    [string] $Condition

    hidden [void] _addAccessors() {
        $this._addBaseAccessors()
        $this | Add-Member -Force -MemberType ScriptProperty -Name UserPoolId -Value {
            $this.Properties['UserPoolId']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['UserPoolId'] = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name CustomDomainConfig -Value {
            $this.Properties['CustomDomainConfig']
        } -SecondValue {
            param([ValidateType(([CognitoUserPoolDomainCustomDomainConfigType], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['CustomDomainConfig'] = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Domain -Value {
            $this.Properties['Domain']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['Domain'] = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Condition -Value {
            $this._condition
        } -SecondValue {
            param(
                [ValidateType(([string], [IntrinsicFunction], [ConditionFunction]))] [object]
                $value
            )
            $this._condition = $value
        }
    }

    CognitoUserPoolDomain() : base() {}
    CognitoUserPoolDomain([IDictionary] $props) : base($props) {}
    CognitoUserPoolDomain([psobject] $props) : base($props) {}
}