VaporShell.Lex

3.0.0-beta20211222r1

VaporShell.Lex.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 'LexBotSlotValueRegexFilter'"

class LexBotSlotValueRegexFilter : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSLexBotSlotValueRegexFilter'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-lex-bot-slotvalueregexfilter.html'

    hidden [object] $_pattern

    [string] $Pattern

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

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

Write-Verbose "Importing class 'LexBotAliasCodeHookSpecification'"

class LexBotAliasCodeHookSpecification : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSLexBotAliasCodeHookSpecification'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-lex-botalias-codehookspecification.html'

    hidden [object] $_lambdaCodeHook

    [LexBotAliasLambdaCodeHook] $LambdaCodeHook

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

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

Write-Verbose "Importing class 'LexBotAliasBotAliasLocaleSettings'"

class LexBotAliasBotAliasLocaleSettings : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSLexBotAliasBotAliasLocaleSettings'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-lex-botalias-botaliaslocalesettings.html'

    hidden [object] $_codeHookSpecification
    hidden [object] $_enabled

    [LexBotAliasCodeHookSpecification] $CodeHookSpecification
    [bool] $Enabled

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name CodeHookSpecification -Value {
            $this._codeHookSpecification
        } -SecondValue {
            param([ValidateType(([LexBotAliasCodeHookSpecification], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._codeHookSpecification = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Enabled -Value {
            $this._enabled
        } -SecondValue {
            param([ValidateType(([bool], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._enabled = $value
        }
    }

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

Write-Verbose "Importing class 'LexBotAliasAudioLogDestination'"

class LexBotAliasAudioLogDestination : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSLexBotAliasAudioLogDestination'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-lex-botalias-audiologdestination.html'

    hidden [object] $_s3Bucket

    [LexBotAliasS3BucketLogDestination] $S3Bucket

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

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

Write-Verbose "Importing class 'LexBotFulfillmentUpdatesSpecification'"

class LexBotFulfillmentUpdatesSpecification : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSLexBotFulfillmentUpdatesSpecification'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-lex-bot-fulfillmentupdatesspecification.html'

    hidden [object] $_startResponse
    hidden [object] $_updateResponse
    hidden [object] $_timeoutInSeconds
    hidden [object] $_active

    [LexBotFulfillmentStartResponseSpecification] $StartResponse
    [LexBotFulfillmentUpdateResponseSpecification] $UpdateResponse
    [int] $TimeoutInSeconds
    [bool] $Active

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name StartResponse -Value {
            $this._startResponse
        } -SecondValue {
            param([ValidateType(([LexBotFulfillmentStartResponseSpecification], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._startResponse = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name UpdateResponse -Value {
            $this._updateResponse
        } -SecondValue {
            param([ValidateType(([LexBotFulfillmentUpdateResponseSpecification], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._updateResponse = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name TimeoutInSeconds -Value {
            $this._timeoutInSeconds
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._timeoutInSeconds = if ($cast = $value -as [int]) {
                $cast
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Active -Value {
            $this._active
        } -SecondValue {
            param([ValidateType(([bool], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._active = $value
        }
    }

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

Write-Verbose "Importing class 'LexBotSlotType'"

class LexBotSlotType : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSLexBotSlotType'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-lex-bot-slottype.html'

    hidden [object] $_name
    hidden [object] $_description
    hidden [object] $_parentSlotTypeSignature
    hidden [object] $_slotTypeValues
    hidden [object] $_valueSelectionSetting
    hidden [object] $_externalSourceSetting

    [string] $Name
    [string] $Description
    [string] $ParentSlotTypeSignature
    [LexBotSlotTypeValue[]] $SlotTypeValues
    [LexBotSlotValueSelectionSetting] $ValueSelectionSetting
    [LexBotExternalSourceSetting] $ExternalSourceSetting

    hidden [void] _addAccessors() {
        $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
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Description -Value {
            $this._description
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._description = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name ParentSlotTypeSignature -Value {
            $this._parentSlotTypeSignature
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._parentSlotTypeSignature = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name SlotTypeValues -Value {
            $this._slotTypeValues
        } -SecondValue {
            param([ValidateType(([LexBotSlotTypeValue], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this._slotTypeValues = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name ValueSelectionSetting -Value {
            $this._valueSelectionSetting
        } -SecondValue {
            param([ValidateType(([LexBotSlotValueSelectionSetting], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._valueSelectionSetting = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name ExternalSourceSetting -Value {
            $this._externalSourceSetting
        } -SecondValue {
            param([ValidateType(([LexBotExternalSourceSetting], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._externalSourceSetting = $value
        }
    }

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

Write-Verbose "Importing class 'LexBotInputContext'"

class LexBotInputContext : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSLexBotInputContext'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-lex-bot-inputcontext.html'

    hidden [object] $_name

    [string] $Name

    hidden [void] _addAccessors() {
        $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
            }
        }
    }

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

Write-Verbose "Importing class 'LexBotPromptSpecification'"

class LexBotPromptSpecification : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSLexBotPromptSpecification'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-lex-bot-promptspecification.html'

    hidden [object] $_messageGroupsList
    hidden [object] $_maxRetries
    hidden [object] $_allowInterrupt

    [LexBotMessageGroup[]] $MessageGroupsList
    [int] $MaxRetries
    [bool] $AllowInterrupt

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name MessageGroupsList -Value {
            $this._messageGroupsList
        } -SecondValue {
            param([ValidateType(([LexBotMessageGroup], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this._messageGroupsList = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name MaxRetries -Value {
            $this._maxRetries
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._maxRetries = if ($cast = $value -as [int]) {
                $cast
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name AllowInterrupt -Value {
            $this._allowInterrupt
        } -SecondValue {
            param([ValidateType(([bool], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._allowInterrupt = $value
        }
    }

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

Write-Verbose "Importing class 'LexBotVoiceSettings'"

class LexBotVoiceSettings : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSLexBotVoiceSettings'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-lex-bot-voicesettings.html'

    hidden [object] $_voiceId

    [string] $VoiceId

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

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

Write-Verbose "Importing class 'LexBotIntentConfirmationSetting'"

class LexBotIntentConfirmationSetting : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSLexBotIntentConfirmationSetting'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-lex-bot-intentconfirmationsetting.html'

    hidden [object] $_promptSpecification
    hidden [object] $_declinationResponse
    hidden [object] $_isActive

    [LexBotPromptSpecification] $PromptSpecification
    [LexBotResponseSpecification] $DeclinationResponse
    [bool] $IsActive

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name PromptSpecification -Value {
            $this._promptSpecification
        } -SecondValue {
            param([ValidateType(([LexBotPromptSpecification], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._promptSpecification = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name DeclinationResponse -Value {
            $this._declinationResponse
        } -SecondValue {
            param([ValidateType(([LexBotResponseSpecification], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._declinationResponse = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name IsActive -Value {
            $this._isActive
        } -SecondValue {
            param([ValidateType(([bool], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._isActive = $value
        }
    }

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

Write-Verbose "Importing class 'LexBotMessage'"

class LexBotMessage : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSLexBotMessage'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-lex-bot-message.html'

    hidden [object] $_plainTextMessage
    hidden [object] $_customPayload
    hidden [object] $_sSMLMessage
    hidden [object] $_imageResponseCard

    [LexBotPlainTextMessage] $PlainTextMessage
    [LexBotCustomPayload] $CustomPayload
    [LexBotSSMLMessage] $SSMLMessage
    [LexBotImageResponseCard] $ImageResponseCard

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name PlainTextMessage -Value {
            $this._plainTextMessage
        } -SecondValue {
            param([ValidateType(([LexBotPlainTextMessage], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._plainTextMessage = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name CustomPayload -Value {
            $this._customPayload
        } -SecondValue {
            param([ValidateType(([LexBotCustomPayload], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._customPayload = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name SSMLMessage -Value {
            $this._sSMLMessage
        } -SecondValue {
            param([ValidateType(([LexBotSSMLMessage], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._sSMLMessage = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name ImageResponseCard -Value {
            $this._imageResponseCard
        } -SecondValue {
            param([ValidateType(([LexBotImageResponseCard], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._imageResponseCard = $value
        }
    }

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

Write-Verbose "Importing class 'LexBotAliasConversationLogSettings'"

class LexBotAliasConversationLogSettings : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSLexBotAliasConversationLogSettings'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-lex-botalias-conversationlogsettings.html'

    hidden [object] $_audioLogSettings
    hidden [object] $_textLogSettings

    [LexBotAliasAudioLogSetting[]] $AudioLogSettings
    [LexBotAliasTextLogSetting[]] $TextLogSettings

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name AudioLogSettings -Value {
            $this._audioLogSettings
        } -SecondValue {
            param([ValidateType(([LexBotAliasAudioLogSetting], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this._audioLogSettings = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name TextLogSettings -Value {
            $this._textLogSettings
        } -SecondValue {
            param([ValidateType(([LexBotAliasTextLogSetting], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this._textLogSettings = $value
        }
    }

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

Write-Verbose "Importing class 'LexBotVersionBotVersionLocaleDetails'"

class LexBotVersionBotVersionLocaleDetails : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSLexBotVersionBotVersionLocaleDetails'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-lex-botversion-botversionlocaledetails.html'

    hidden [object] $_sourceBotVersion

    [string] $SourceBotVersion

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

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

Write-Verbose "Importing class 'LexBotWaitAndContinueSpecification'"

class LexBotWaitAndContinueSpecification : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSLexBotWaitAndContinueSpecification'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-lex-bot-waitandcontinuespecification.html'

    hidden [object] $_waitingResponse
    hidden [object] $_continueResponse
    hidden [object] $_stillWaitingResponse
    hidden [object] $_isActive

    [LexBotResponseSpecification] $WaitingResponse
    [LexBotResponseSpecification] $ContinueResponse
    [LexBotStillWaitingResponseSpecification] $StillWaitingResponse
    [bool] $IsActive

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name WaitingResponse -Value {
            $this._waitingResponse
        } -SecondValue {
            param([ValidateType(([LexBotResponseSpecification], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._waitingResponse = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name ContinueResponse -Value {
            $this._continueResponse
        } -SecondValue {
            param([ValidateType(([LexBotResponseSpecification], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._continueResponse = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name StillWaitingResponse -Value {
            $this._stillWaitingResponse
        } -SecondValue {
            param([ValidateType(([LexBotStillWaitingResponseSpecification], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._stillWaitingResponse = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name IsActive -Value {
            $this._isActive
        } -SecondValue {
            param([ValidateType(([bool], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._isActive = $value
        }
    }

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

Write-Verbose "Importing class 'LexBotSlotValueElicitationSetting'"

class LexBotSlotValueElicitationSetting : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSLexBotSlotValueElicitationSetting'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-lex-bot-slotvalueelicitationsetting.html'

    hidden [object] $_defaultValueSpecification
    hidden [object] $_slotConstraint
    hidden [object] $_promptSpecification
    hidden [object] $_sampleUtterances
    hidden [object] $_waitAndContinueSpecification

    [LexBotSlotDefaultValueSpecification] $DefaultValueSpecification
    [string] $SlotConstraint
    [LexBotPromptSpecification] $PromptSpecification
    [LexBotSampleUtterance[]] $SampleUtterances
    [LexBotWaitAndContinueSpecification] $WaitAndContinueSpecification

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name DefaultValueSpecification -Value {
            $this._defaultValueSpecification
        } -SecondValue {
            param([ValidateType(([LexBotSlotDefaultValueSpecification], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._defaultValueSpecification = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name SlotConstraint -Value {
            $this._slotConstraint
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._slotConstraint = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name PromptSpecification -Value {
            $this._promptSpecification
        } -SecondValue {
            param([ValidateType(([LexBotPromptSpecification], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._promptSpecification = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name SampleUtterances -Value {
            $this._sampleUtterances
        } -SecondValue {
            param([ValidateType(([LexBotSampleUtterance], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this._sampleUtterances = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name WaitAndContinueSpecification -Value {
            $this._waitAndContinueSpecification
        } -SecondValue {
            param([ValidateType(([LexBotWaitAndContinueSpecification], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._waitAndContinueSpecification = $value
        }
    }

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

Write-Verbose "Importing class 'LexBotMultipleValuesSetting'"

class LexBotMultipleValuesSetting : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSLexBotMultipleValuesSetting'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-lex-bot-multiplevaluessetting.html'

    hidden [object] $_allowMultipleValues

    [bool] $AllowMultipleValues

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

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

Write-Verbose "Importing class 'LexBotSlotDefaultValueSpecification'"

class LexBotSlotDefaultValueSpecification : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSLexBotSlotDefaultValueSpecification'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-lex-bot-slotdefaultvaluespecification.html'

    hidden [object] $_defaultValueList

    [LexBotSlotDefaultValue[]] $DefaultValueList

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

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

Write-Verbose "Importing class 'LexBotExternalSourceSetting'"

class LexBotExternalSourceSetting : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSLexBotExternalSourceSetting'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-lex-bot-externalsourcesetting.html'

    hidden [object] $_grammarSlotTypeSetting

    [LexBotGrammarSlotTypeSetting] $GrammarSlotTypeSetting

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

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

Write-Verbose "Importing class 'LexBotDialogCodeHookSetting'"

class LexBotDialogCodeHookSetting : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSLexBotDialogCodeHookSetting'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-lex-bot-dialogcodehooksetting.html'

    hidden [object] $_enabled

    [bool] $Enabled

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

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

Write-Verbose "Importing class 'LexBotObfuscationSetting'"

class LexBotObfuscationSetting : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSLexBotObfuscationSetting'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-lex-bot-obfuscationsetting.html'

    hidden [object] $_obfuscationSettingType

    [string] $ObfuscationSettingType

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

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

Write-Verbose "Importing class 'LexBotFulfillmentStartResponseSpecification'"

class LexBotFulfillmentStartResponseSpecification : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSLexBotFulfillmentStartResponseSpecification'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-lex-bot-fulfillmentstartresponsespecification.html'

    hidden [object] $_messageGroups
    hidden [object] $_delayInSeconds
    hidden [object] $_allowInterrupt

    [LexBotMessageGroup[]] $MessageGroups
    [int] $DelayInSeconds
    [bool] $AllowInterrupt

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name MessageGroups -Value {
            $this._messageGroups
        } -SecondValue {
            param([ValidateType(([LexBotMessageGroup], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this._messageGroups = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name DelayInSeconds -Value {
            $this._delayInSeconds
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._delayInSeconds = if ($cast = $value -as [int]) {
                $cast
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name AllowInterrupt -Value {
            $this._allowInterrupt
        } -SecondValue {
            param([ValidateType(([bool], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._allowInterrupt = $value
        }
    }

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

Write-Verbose "Importing class 'LexBotIntent'"

class LexBotIntent : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSLexBotIntent'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-lex-bot-intent.html'

    hidden [object] $_name
    hidden [object] $_description
    hidden [object] $_parentIntentSignature
    hidden [object] $_sampleUtterances
    hidden [object] $_dialogCodeHook
    hidden [object] $_fulfillmentCodeHook
    hidden [object] $_intentConfirmationSetting
    hidden [object] $_intentClosingSetting
    hidden [object] $_inputContexts
    hidden [object] $_outputContexts
    hidden [object] $_kendraConfiguration
    hidden [object] $_slotPriorities
    hidden [object] $_slots

    [string] $Name
    [string] $Description
    [string] $ParentIntentSignature
    [LexBotSampleUtterance[]] $SampleUtterances
    [LexBotDialogCodeHookSetting] $DialogCodeHook
    [LexBotFulfillmentCodeHookSetting] $FulfillmentCodeHook
    [LexBotIntentConfirmationSetting] $IntentConfirmationSetting
    [LexBotIntentClosingSetting] $IntentClosingSetting
    [LexBotInputContext[]] $InputContexts
    [LexBotOutputContext[]] $OutputContexts
    [LexBotKendraConfiguration] $KendraConfiguration
    [LexBotSlotPriority[]] $SlotPriorities
    [LexBotSlot[]] $Slots

    hidden [void] _addAccessors() {
        $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
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Description -Value {
            $this._description
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._description = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name ParentIntentSignature -Value {
            $this._parentIntentSignature
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._parentIntentSignature = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name SampleUtterances -Value {
            $this._sampleUtterances
        } -SecondValue {
            param([ValidateType(([LexBotSampleUtterance], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this._sampleUtterances = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name DialogCodeHook -Value {
            $this._dialogCodeHook
        } -SecondValue {
            param([ValidateType(([LexBotDialogCodeHookSetting], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._dialogCodeHook = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name FulfillmentCodeHook -Value {
            $this._fulfillmentCodeHook
        } -SecondValue {
            param([ValidateType(([LexBotFulfillmentCodeHookSetting], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._fulfillmentCodeHook = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name IntentConfirmationSetting -Value {
            $this._intentConfirmationSetting
        } -SecondValue {
            param([ValidateType(([LexBotIntentConfirmationSetting], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._intentConfirmationSetting = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name IntentClosingSetting -Value {
            $this._intentClosingSetting
        } -SecondValue {
            param([ValidateType(([LexBotIntentClosingSetting], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._intentClosingSetting = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name InputContexts -Value {
            $this._inputContexts
        } -SecondValue {
            param([ValidateType(([LexBotInputContext], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this._inputContexts = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name OutputContexts -Value {
            $this._outputContexts
        } -SecondValue {
            param([ValidateType(([LexBotOutputContext], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this._outputContexts = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name KendraConfiguration -Value {
            $this._kendraConfiguration
        } -SecondValue {
            param([ValidateType(([LexBotKendraConfiguration], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._kendraConfiguration = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name SlotPriorities -Value {
            $this._slotPriorities
        } -SecondValue {
            param([ValidateType(([LexBotSlotPriority], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this._slotPriorities = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Slots -Value {
            $this._slots
        } -SecondValue {
            param([ValidateType(([LexBotSlot], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this._slots = $value
        }
    }

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

Write-Verbose "Importing class 'LexBotResponseSpecification'"

class LexBotResponseSpecification : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSLexBotResponseSpecification'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-lex-bot-responsespecification.html'

    hidden [object] $_messageGroupsList
    hidden [object] $_allowInterrupt

    [LexBotMessageGroup[]] $MessageGroupsList
    [bool] $AllowInterrupt

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

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

Write-Verbose "Importing class 'LexBotBotLocale'"

class LexBotBotLocale : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSLexBotBotLocale'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-lex-bot-botlocale.html'

    hidden [object] $_localeId
    hidden [object] $_description
    hidden [object] $_voiceSettings
    hidden [object] $_nluConfidenceThreshold
    hidden [object] $_intents
    hidden [object] $_slotTypes

    [string] $LocaleId
    [string] $Description
    [LexBotVoiceSettings] $VoiceSettings
    [double] $NluConfidenceThreshold
    [LexBotIntent[]] $Intents
    [LexBotSlotType[]] $SlotTypes

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name LocaleId -Value {
            $this._localeId
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._localeId = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Description -Value {
            $this._description
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._description = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name VoiceSettings -Value {
            $this._voiceSettings
        } -SecondValue {
            param([ValidateType(([LexBotVoiceSettings], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._voiceSettings = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name NluConfidenceThreshold -Value {
            $this._nluConfidenceThreshold
        } -SecondValue {
            param([ValidateType(([double], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._nluConfidenceThreshold = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Intents -Value {
            $this._intents
        } -SecondValue {
            param([ValidateType(([LexBotIntent], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this._intents = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name SlotTypes -Value {
            $this._slotTypes
        } -SecondValue {
            param([ValidateType(([LexBotSlotType], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this._slotTypes = $value
        }
    }

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

Write-Verbose "Importing class 'LexBotAliasCloudWatchLogGroupLogDestination'"

class LexBotAliasCloudWatchLogGroupLogDestination : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSLexBotAliasCloudWatchLogGroupLogDestination'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-lex-botalias-cloudwatchloggrouplogdestination.html'

    hidden [object] $_cloudWatchLogGroupArn
    hidden [object] $_logPrefix

    [string] $CloudWatchLogGroupArn
    [string] $LogPrefix

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

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

Write-Verbose "Importing class 'LexBotS3Location'"

class LexBotS3Location : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSLexBotS3Location'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-lex-bot-s3location.html'

    hidden [object] $_s3Bucket
    hidden [object] $_s3ObjectKey
    hidden [object] $_s3ObjectVersion

    [string] $S3Bucket
    [string] $S3ObjectKey
    [string] $S3ObjectVersion

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

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

Write-Verbose "Importing class 'LexBotSlotDefaultValue'"

class LexBotSlotDefaultValue : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSLexBotSlotDefaultValue'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-lex-bot-slotdefaultvalue.html'

    hidden [object] $_defaultValue

    [string] $DefaultValue

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

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

Write-Verbose "Importing class 'LexBotSlotPriority'"

class LexBotSlotPriority : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSLexBotSlotPriority'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-lex-bot-slotpriority.html'

    hidden [object] $_priority
    hidden [object] $_slotName

    [int] $Priority
    [string] $SlotName

    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 SlotName -Value {
            $this._slotName
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._slotName = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
    }

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

Write-Verbose "Importing class 'LexBotAliasLambdaCodeHook'"

class LexBotAliasLambdaCodeHook : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSLexBotAliasLambdaCodeHook'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-lex-botalias-lambdacodehook.html'

    hidden [object] $_codeHookInterfaceVersion
    hidden [object] $_lambdaArn

    [string] $CodeHookInterfaceVersion
    [string] $LambdaArn

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name CodeHookInterfaceVersion -Value {
            $this._codeHookInterfaceVersion
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._codeHookInterfaceVersion = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $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
            }
        }
    }

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

Write-Verbose "Importing class 'LexBotVersionBotVersionLocaleSpecification'"

class LexBotVersionBotVersionLocaleSpecification : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSLexBotVersionBotVersionLocaleSpecification'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-lex-botversion-botversionlocalespecification.html'

    hidden [object] $_localeId
    hidden [object] $_botVersionLocaleDetails

    [string] $LocaleId
    [LexBotVersionBotVersionLocaleDetails] $BotVersionLocaleDetails

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

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

Write-Verbose "Importing class 'LexBotSlotValueSelectionSetting'"

class LexBotSlotValueSelectionSetting : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSLexBotSlotValueSelectionSetting'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-lex-bot-slotvalueselectionsetting.html'

    hidden [object] $_resolutionStrategy
    hidden [object] $_regexFilter

    [string] $ResolutionStrategy
    [LexBotSlotValueRegexFilter] $RegexFilter

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

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

Write-Verbose "Importing class 'LexBotImageResponseCard'"

class LexBotImageResponseCard : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSLexBotImageResponseCard'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-lex-bot-imageresponsecard.html'

    hidden [object] $_title
    hidden [object] $_subtitle
    hidden [object] $_imageUrl
    hidden [object] $_buttons

    [string] $Title
    [string] $Subtitle
    [string] $ImageUrl
    [LexBotButton[]] $Buttons

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name Title -Value {
            $this._title
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._title = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Subtitle -Value {
            $this._subtitle
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._subtitle = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name ImageUrl -Value {
            $this._imageUrl
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._imageUrl = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Buttons -Value {
            $this._buttons
        } -SecondValue {
            param([ValidateType(([LexBotButton], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this._buttons = $value
        }
    }

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

Write-Verbose "Importing class 'LexResourcePolicyPolicy'"

class LexResourcePolicyPolicy : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSLexResourcePolicyPolicy'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-lex-resourcepolicy-policy.html'



    hidden [void] _addAccessors() {
    }

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

Write-Verbose "Importing class 'LexBotAliasAudioLogSetting'"

class LexBotAliasAudioLogSetting : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSLexBotAliasAudioLogSetting'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-lex-botalias-audiologsetting.html'

    hidden [object] $_destination
    hidden [object] $_enabled

    [LexBotAliasAudioLogDestination] $Destination
    [bool] $Enabled

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name Destination -Value {
            $this._destination
        } -SecondValue {
            param([ValidateType(([LexBotAliasAudioLogDestination], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._destination = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Enabled -Value {
            $this._enabled
        } -SecondValue {
            param([ValidateType(([bool], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._enabled = $value
        }
    }

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

Write-Verbose "Importing class 'LexBotSlotTypeValue'"

class LexBotSlotTypeValue : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSLexBotSlotTypeValue'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-lex-bot-slottypevalue.html'

    hidden [object] $_sampleValue
    hidden [object] $_synonyms

    [LexBotSampleValue] $SampleValue
    [LexBotSampleValue[]] $Synonyms

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name SampleValue -Value {
            $this._sampleValue
        } -SecondValue {
            param([ValidateType(([LexBotSampleValue], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._sampleValue = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Synonyms -Value {
            $this._synonyms
        } -SecondValue {
            param([ValidateType(([LexBotSampleValue], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this._synonyms = $value
        }
    }

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

Write-Verbose "Importing class 'LexBotAliasTextLogSetting'"

class LexBotAliasTextLogSetting : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSLexBotAliasTextLogSetting'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-lex-botalias-textlogsetting.html'

    hidden [object] $_destination
    hidden [object] $_enabled

    [LexBotAliasTextLogDestination] $Destination
    [bool] $Enabled

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name Destination -Value {
            $this._destination
        } -SecondValue {
            param([ValidateType(([LexBotAliasTextLogDestination], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._destination = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Enabled -Value {
            $this._enabled
        } -SecondValue {
            param([ValidateType(([bool], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._enabled = $value
        }
    }

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

Write-Verbose "Importing class 'LexBotButton'"

class LexBotButton : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSLexBotButton'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-lex-bot-button.html'

    hidden [object] $_text
    hidden [object] $_value

    [string] $Text
    [string] $Value

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name Text -Value {
            $this._text
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._text = 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
            }
        }
    }

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

Write-Verbose "Importing class 'LexBotPlainTextMessage'"

class LexBotPlainTextMessage : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSLexBotPlainTextMessage'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-lex-bot-plaintextmessage.html'

    hidden [object] $_value

    [string] $Value

    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
            }
        }
    }

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

Write-Verbose "Importing class 'LexBotSSMLMessage'"

class LexBotSSMLMessage : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSLexBotSSMLMessage'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-lex-bot-ssmlmessage.html'

    hidden [object] $_value

    [string] $Value

    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
            }
        }
    }

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

Write-Verbose "Importing class 'LexBotKendraConfiguration'"

class LexBotKendraConfiguration : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSLexBotKendraConfiguration'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-lex-bot-kendraconfiguration.html'

    hidden [object] $_kendraIndex
    hidden [object] $_queryFilterStringEnabled
    hidden [object] $_queryFilterString

    [string] $KendraIndex
    [bool] $QueryFilterStringEnabled
    [string] $QueryFilterString

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

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

Write-Verbose "Importing class 'LexBotGrammarSlotTypeSource'"

class LexBotGrammarSlotTypeSource : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSLexBotGrammarSlotTypeSource'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-lex-bot-grammarslottypesource.html'

    hidden [object] $_s3BucketName
    hidden [object] $_s3ObjectKey
    hidden [object] $_kmsKeyArn

    [string] $S3BucketName
    [string] $S3ObjectKey
    [string] $KmsKeyArn

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

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

Write-Verbose "Importing class 'LexBotMessageGroup'"

class LexBotMessageGroup : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSLexBotMessageGroup'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-lex-bot-messagegroup.html'

    hidden [object] $_message
    hidden [object] $_variations

    [LexBotMessage] $Message
    [LexBotMessage[]] $Variations

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name Message -Value {
            $this._message
        } -SecondValue {
            param([ValidateType(([LexBotMessage], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._message = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Variations -Value {
            $this._variations
        } -SecondValue {
            param([ValidateType(([LexBotMessage], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this._variations = $value
        }
    }

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

Write-Verbose "Importing class 'LexBotAliasTextLogDestination'"

class LexBotAliasTextLogDestination : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSLexBotAliasTextLogDestination'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-lex-botalias-textlogdestination.html'

    hidden [object] $_cloudWatch

    [object] $CloudWatch

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

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

Write-Verbose "Importing class 'LexBotPostFulfillmentStatusSpecification'"

class LexBotPostFulfillmentStatusSpecification : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSLexBotPostFulfillmentStatusSpecification'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-lex-bot-postfulfillmentstatusspecification.html'

    hidden [object] $_successResponse
    hidden [object] $_failureResponse
    hidden [object] $_timeoutResponse

    [LexBotResponseSpecification] $SuccessResponse
    [LexBotResponseSpecification] $FailureResponse
    [LexBotResponseSpecification] $TimeoutResponse

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name SuccessResponse -Value {
            $this._successResponse
        } -SecondValue {
            param([ValidateType(([LexBotResponseSpecification], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._successResponse = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name FailureResponse -Value {
            $this._failureResponse
        } -SecondValue {
            param([ValidateType(([LexBotResponseSpecification], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._failureResponse = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name TimeoutResponse -Value {
            $this._timeoutResponse
        } -SecondValue {
            param([ValidateType(([LexBotResponseSpecification], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._timeoutResponse = $value
        }
    }

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

Write-Verbose "Importing class 'LexBotSlot'"

class LexBotSlot : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSLexBotSlot'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-lex-bot-slot.html'

    hidden [object] $_name
    hidden [object] $_description
    hidden [object] $_slotTypeName
    hidden [object] $_valueElicitationSetting
    hidden [object] $_obfuscationSetting
    hidden [object] $_multipleValuesSetting

    [string] $Name
    [string] $Description
    [string] $SlotTypeName
    [LexBotSlotValueElicitationSetting] $ValueElicitationSetting
    [LexBotObfuscationSetting] $ObfuscationSetting
    [LexBotMultipleValuesSetting] $MultipleValuesSetting

    hidden [void] _addAccessors() {
        $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
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Description -Value {
            $this._description
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._description = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name SlotTypeName -Value {
            $this._slotTypeName
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._slotTypeName = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name ValueElicitationSetting -Value {
            $this._valueElicitationSetting
        } -SecondValue {
            param([ValidateType(([LexBotSlotValueElicitationSetting], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._valueElicitationSetting = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name ObfuscationSetting -Value {
            $this._obfuscationSetting
        } -SecondValue {
            param([ValidateType(([LexBotObfuscationSetting], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._obfuscationSetting = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name MultipleValuesSetting -Value {
            $this._multipleValuesSetting
        } -SecondValue {
            param([ValidateType(([LexBotMultipleValuesSetting], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._multipleValuesSetting = $value
        }
    }

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

Write-Verbose "Importing class 'LexBotAliasBotAliasLocaleSettingsItem'"

class LexBotAliasBotAliasLocaleSettingsItem : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSLexBotAliasBotAliasLocaleSettingsItem'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-lex-botalias-botaliaslocalesettingsitem.html'

    hidden [object] $_localeId
    hidden [object] $_botAliasLocaleSetting

    [string] $LocaleId
    [LexBotAliasBotAliasLocaleSettings] $BotAliasLocaleSetting

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

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

Write-Verbose "Importing class 'LexBotSampleUtterance'"

class LexBotSampleUtterance : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSLexBotSampleUtterance'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-lex-bot-sampleutterance.html'

    hidden [object] $_utterance

    [string] $Utterance

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

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

Write-Verbose "Importing class 'LexBotFulfillmentUpdateResponseSpecification'"

class LexBotFulfillmentUpdateResponseSpecification : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSLexBotFulfillmentUpdateResponseSpecification'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-lex-bot-fulfillmentupdateresponsespecification.html'

    hidden [object] $_messageGroups
    hidden [object] $_frequencyInSeconds
    hidden [object] $_allowInterrupt

    [LexBotMessageGroup[]] $MessageGroups
    [int] $FrequencyInSeconds
    [bool] $AllowInterrupt

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name MessageGroups -Value {
            $this._messageGroups
        } -SecondValue {
            param([ValidateType(([LexBotMessageGroup], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this._messageGroups = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name FrequencyInSeconds -Value {
            $this._frequencyInSeconds
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._frequencyInSeconds = if ($cast = $value -as [int]) {
                $cast
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name AllowInterrupt -Value {
            $this._allowInterrupt
        } -SecondValue {
            param([ValidateType(([bool], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._allowInterrupt = $value
        }
    }

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

Write-Verbose "Importing class 'LexBotGrammarSlotTypeSetting'"

class LexBotGrammarSlotTypeSetting : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSLexBotGrammarSlotTypeSetting'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-lex-bot-grammarslottypesetting.html'

    hidden [object] $_source

    [LexBotGrammarSlotTypeSource] $Source

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

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

Write-Verbose "Importing class 'LexBotAliasS3BucketLogDestination'"

class LexBotAliasS3BucketLogDestination : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSLexBotAliasS3BucketLogDestination'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-lex-botalias-s3bucketlogdestination.html'

    hidden [object] $_s3BucketArn
    hidden [object] $_logPrefix
    hidden [object] $_kmsKeyArn

    [string] $S3BucketArn
    [string] $LogPrefix
    [string] $KmsKeyArn

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

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

Write-Verbose "Importing class 'LexBotIntentClosingSetting'"

class LexBotIntentClosingSetting : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSLexBotIntentClosingSetting'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-lex-bot-intentclosingsetting.html'

    hidden [object] $_closingResponse
    hidden [object] $_isActive

    [LexBotResponseSpecification] $ClosingResponse
    [bool] $IsActive

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name ClosingResponse -Value {
            $this._closingResponse
        } -SecondValue {
            param([ValidateType(([LexBotResponseSpecification], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._closingResponse = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name IsActive -Value {
            $this._isActive
        } -SecondValue {
            param([ValidateType(([bool], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._isActive = $value
        }
    }

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

Write-Verbose "Importing class 'LexBotStillWaitingResponseSpecification'"

class LexBotStillWaitingResponseSpecification : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSLexBotStillWaitingResponseSpecification'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-lex-bot-stillwaitingresponsespecification.html'

    hidden [object] $_messageGroupsList
    hidden [object] $_frequencyInSeconds
    hidden [object] $_timeoutInSeconds
    hidden [object] $_allowInterrupt

    [LexBotMessageGroup[]] $MessageGroupsList
    [int] $FrequencyInSeconds
    [int] $TimeoutInSeconds
    [bool] $AllowInterrupt

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name MessageGroupsList -Value {
            $this._messageGroupsList
        } -SecondValue {
            param([ValidateType(([LexBotMessageGroup], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this._messageGroupsList = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name FrequencyInSeconds -Value {
            $this._frequencyInSeconds
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._frequencyInSeconds = if ($cast = $value -as [int]) {
                $cast
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name TimeoutInSeconds -Value {
            $this._timeoutInSeconds
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._timeoutInSeconds = if ($cast = $value -as [int]) {
                $cast
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name AllowInterrupt -Value {
            $this._allowInterrupt
        } -SecondValue {
            param([ValidateType(([bool], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._allowInterrupt = $value
        }
    }

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

Write-Verbose "Importing class 'LexBotOutputContext'"

class LexBotOutputContext : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSLexBotOutputContext'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-lex-bot-outputcontext.html'

    hidden [object] $_name
    hidden [object] $_timeToLiveInSeconds
    hidden [object] $_turnsToLive

    [string] $Name
    [int] $TimeToLiveInSeconds
    [int] $TurnsToLive

    hidden [void] _addAccessors() {
        $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
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name TimeToLiveInSeconds -Value {
            $this._timeToLiveInSeconds
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._timeToLiveInSeconds = if ($cast = $value -as [int]) {
                $cast
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name TurnsToLive -Value {
            $this._turnsToLive
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._turnsToLive = if ($cast = $value -as [int]) {
                $cast
            }
            else {
                $value
            }
        }
    }

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

Write-Verbose "Importing class 'LexBotFulfillmentCodeHookSetting'"

class LexBotFulfillmentCodeHookSetting : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSLexBotFulfillmentCodeHookSetting'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-lex-bot-fulfillmentcodehooksetting.html'

    hidden [object] $_fulfillmentUpdatesSpecification
    hidden [object] $_postFulfillmentStatusSpecification
    hidden [object] $_enabled

    [LexBotFulfillmentUpdatesSpecification] $FulfillmentUpdatesSpecification
    [LexBotPostFulfillmentStatusSpecification] $PostFulfillmentStatusSpecification
    [bool] $Enabled

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name FulfillmentUpdatesSpecification -Value {
            $this._fulfillmentUpdatesSpecification
        } -SecondValue {
            param([ValidateType(([LexBotFulfillmentUpdatesSpecification], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._fulfillmentUpdatesSpecification = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name PostFulfillmentStatusSpecification -Value {
            $this._postFulfillmentStatusSpecification
        } -SecondValue {
            param([ValidateType(([LexBotPostFulfillmentStatusSpecification], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._postFulfillmentStatusSpecification = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Enabled -Value {
            $this._enabled
        } -SecondValue {
            param([ValidateType(([bool], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._enabled = $value
        }
    }

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

Write-Verbose "Importing class 'LexBotCustomPayload'"

class LexBotCustomPayload : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSLexBotCustomPayload'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-lex-bot-custompayload.html'

    hidden [object] $_value

    [string] $Value

    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
            }
        }
    }

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

Write-Verbose "Importing class 'LexBotSampleValue'"

class LexBotSampleValue : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSLexBotSampleValue'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-lex-bot-samplevalue.html'

    hidden [object] $_value

    [string] $Value

    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
            }
        }
    }

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

Write-Verbose "Importing class 'LexBot'"

class LexBot : VSResource {
    hidden [string] $_vsFunctionName = 'New-VSLexBot'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lex-bot.html'

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

    [string] $Type = 'AWS::Lex::Bot'
    [string] $Name
    [string] $Description
    [string] $RoleArn
    [VSJson] $DataPrivacy
    [int] $IdleSessionTTLInSeconds
    [LexBotBotLocale[]] $BotLocales
    [LexBotS3Location] $BotFileS3Location
    [VSTag[]] $BotTags
    [VSTag[]] $TestBotAliasTags
    [bool] $AutoBuildBotLocales
    [VSJson] $Metadata
    [UpdatePolicy] $UpdatePolicy
    [string] $Condition

    hidden [void] _addAccessors() {
        $this._addBaseAccessors()
        $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 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 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 DataPrivacy -Value {
            $this.Properties['DataPrivacy']
        } -SecondValue {
            param([ValidateType(([string], [VSJson], [VSYaml], [psobject], [IDictionary]))][object] $value)
            $this.Properties['DataPrivacy'] = [VSJson]::Transform($value)
            Write-Debug $this.Properties['DataPrivacy']
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name IdleSessionTTLInSeconds -Value {
            $this.Properties['IdleSessionTTLInSeconds']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['IdleSessionTTLInSeconds'] = if ($cast = $value -as [int]) {
                $cast
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name BotLocales -Value {
            $this.Properties['BotLocales']
        } -SecondValue {
            param([ValidateType(([LexBotBotLocale], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this.Properties['BotLocales'] = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name BotFileS3Location -Value {
            $this.Properties['BotFileS3Location']
        } -SecondValue {
            param([ValidateType(([LexBotS3Location], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['BotFileS3Location'] = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name BotTags -Value {
            $this.Properties['BotTags']
        } -SecondValue {
            param([TransformTag()] [ValidateType(([IDictionary], [psobject], [VSTag]))] [object] $value)
            $this.Properties['BotTags'] = [VSTag]::TransformTag($value)
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name TestBotAliasTags -Value {
            $this.Properties['TestBotAliasTags']
        } -SecondValue {
            param([TransformTag()] [ValidateType(([IDictionary], [psobject], [VSTag]))] [object] $value)
            $this.Properties['TestBotAliasTags'] = [VSTag]::TransformTag($value)
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name AutoBuildBotLocales -Value {
            $this.Properties['AutoBuildBotLocales']
        } -SecondValue {
            param([ValidateType(([bool], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['AutoBuildBotLocales'] = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Condition -Value {
            $this._condition
        } -SecondValue {
            param(
                [ValidateType(([string], [IntrinsicFunction], [ConditionFunction]))] [object]
                $value
            )
            $this._condition = $value
        }
    }

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

Write-Verbose "Importing class 'LexBotAlias'"

class LexBotAlias : VSResource {
    hidden [string] $_vsFunctionName = 'New-VSLexBotAlias'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lex-botalias.html'

    hidden [string[]] $_attributes = @('BotAliasId','Arn','BotAliasStatus')
    hidden [object] $_condition

    [string] $Type = 'AWS::Lex::BotAlias'
    [string] $BotId
    [LexBotAliasBotAliasLocaleSettingsItem[]] $BotAliasLocaleSettings
    [string] $BotAliasName
    [string] $BotVersion
    [LexBotAliasConversationLogSettings] $ConversationLogSettings
    [string] $Description
    [VSJson] $SentimentAnalysisSettings
    [VSTag[]] $BotAliasTags
    [VSJson] $Metadata
    [UpdatePolicy] $UpdatePolicy
    [string] $Condition

    hidden [void] _addAccessors() {
        $this._addBaseAccessors()
        $this | Add-Member -Force -MemberType ScriptProperty -Name BotId -Value {
            $this.Properties['BotId']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['BotId'] = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name BotAliasLocaleSettings -Value {
            $this.Properties['BotAliasLocaleSettings']
        } -SecondValue {
            param([ValidateType(([LexBotAliasBotAliasLocaleSettingsItem], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this.Properties['BotAliasLocaleSettings'] = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name BotAliasName -Value {
            $this.Properties['BotAliasName']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['BotAliasName'] = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name BotVersion -Value {
            $this.Properties['BotVersion']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['BotVersion'] = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name ConversationLogSettings -Value {
            $this.Properties['ConversationLogSettings']
        } -SecondValue {
            param([ValidateType(([LexBotAliasConversationLogSettings], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['ConversationLogSettings'] = $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 SentimentAnalysisSettings -Value {
            $this.Properties['SentimentAnalysisSettings']
        } -SecondValue {
            param([ValidateType(([string], [VSJson], [VSYaml], [psobject], [IDictionary]))][object] $value)
            $this.Properties['SentimentAnalysisSettings'] = [VSJson]::Transform($value)
            Write-Debug $this.Properties['SentimentAnalysisSettings']
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name BotAliasTags -Value {
            $this.Properties['BotAliasTags']
        } -SecondValue {
            param([TransformTag()] [ValidateType(([IDictionary], [psobject], [VSTag]))] [object] $value)
            $this.Properties['BotAliasTags'] = [VSTag]::TransformTag($value)
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Condition -Value {
            $this._condition
        } -SecondValue {
            param(
                [ValidateType(([string], [IntrinsicFunction], [ConditionFunction]))] [object]
                $value
            )
            $this._condition = $value
        }
    }

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

Write-Verbose "Importing class 'LexResourcePolicy'"

class LexResourcePolicy : VSResource {
    hidden [string] $_vsFunctionName = 'New-VSLexResourcePolicy'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lex-resourcepolicy.html'

    hidden [string[]] $_attributes = @('RevisionId','Id')
    hidden [object] $_condition

    [string] $Type = 'AWS::Lex::ResourcePolicy'
    [string] $ResourceArn
    [LexResourcePolicyPolicy] $Policy
    [VSJson] $Metadata
    [UpdatePolicy] $UpdatePolicy
    [string] $Condition

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

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

Write-Verbose "Importing class 'LexBotVersion'"

class LexBotVersion : VSResource {
    hidden [string] $_vsFunctionName = 'New-VSLexBotVersion'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lex-botversion.html'

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

    [string] $Type = 'AWS::Lex::BotVersion'
    [string] $BotId
    [string] $Description
    [LexBotVersionBotVersionLocaleSpecification[]] $BotVersionLocaleSpecification
    [VSJson] $Metadata
    [UpdatePolicy] $UpdatePolicy
    [string] $Condition

    hidden [void] _addAccessors() {
        $this._addBaseAccessors()
        $this | Add-Member -Force -MemberType ScriptProperty -Name BotId -Value {
            $this.Properties['BotId']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['BotId'] = 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 BotVersionLocaleSpecification -Value {
            $this.Properties['BotVersionLocaleSpecification']
        } -SecondValue {
            param([ValidateType(([LexBotVersionBotVersionLocaleSpecification], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this.Properties['BotVersionLocaleSpecification'] = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Condition -Value {
            $this._condition
        } -SecondValue {
            param(
                [ValidateType(([string], [IntrinsicFunction], [ConditionFunction]))] [object]
                $value
            )
            $this._condition = $value
        }
    }

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