VaporShell.Events

3.0.0-beta20220420r1

VaporShell.Events.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 'EventsRuleSageMakerPipelineParameter'"

class EventsRuleSageMakerPipelineParameter : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSEventsRuleSageMakerPipelineParameter'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-events-rule-sagemakerpipelineparameter.html'

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

    [string] $Name
    [string] $Value

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

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

Write-Verbose "Importing class 'EventsEndpointSecondary'"

class EventsEndpointSecondary : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSEventsEndpointSecondary'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-events-endpoint-secondary.html'

    hidden [object] $_route

    [string] $Route

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

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

Write-Verbose "Importing class 'EventsEndpointReplicationConfig'"

class EventsEndpointReplicationConfig : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSEventsEndpointReplicationConfig'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-events-endpoint-replicationconfig.html'

    hidden [object] $_state

    [string] $State

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

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

Write-Verbose "Importing class 'EventsRuleBatchRetryStrategy'"

class EventsRuleBatchRetryStrategy : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSEventsRuleBatchRetryStrategy'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-events-rule-batchretrystrategy.html'

    hidden [object] $_attempts

    [int] $Attempts

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

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

Write-Verbose "Importing class 'EventsEndpointRoutingConfig'"

class EventsEndpointRoutingConfig : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSEventsEndpointRoutingConfig'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-events-endpoint-routingconfig.html'

    hidden [object] $_failoverConfig

    [EventsEndpointFailoverConfig] $FailoverConfig

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

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

Write-Verbose "Importing class 'EventsConnectionAuthParameters'"

class EventsConnectionAuthParameters : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSEventsConnectionAuthParameters'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-events-connection-authparameters.html'

    hidden [object] $_apiKeyAuthParameters
    hidden [object] $_basicAuthParameters
    hidden [object] $_oAuthParameters
    hidden [object] $_invocationHttpParameters

    [EventsConnectionApiKeyAuthParameters] $ApiKeyAuthParameters
    [EventsConnectionBasicAuthParameters] $BasicAuthParameters
    [EventsConnectionOAuthParameters] $OAuthParameters
    [EventsConnectionConnectionHttpParameters] $InvocationHttpParameters

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name ApiKeyAuthParameters -Value {
            $this._apiKeyAuthParameters
        } -SecondValue {
            param([ValidateType(([EventsConnectionApiKeyAuthParameters], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._apiKeyAuthParameters = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name BasicAuthParameters -Value {
            $this._basicAuthParameters
        } -SecondValue {
            param([ValidateType(([EventsConnectionBasicAuthParameters], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._basicAuthParameters = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name OAuthParameters -Value {
            $this._oAuthParameters
        } -SecondValue {
            param([ValidateType(([EventsConnectionOAuthParameters], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._oAuthParameters = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name InvocationHttpParameters -Value {
            $this._invocationHttpParameters
        } -SecondValue {
            param([ValidateType(([EventsConnectionConnectionHttpParameters], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._invocationHttpParameters = $value
        }
    }

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

Write-Verbose "Importing class 'EventsRuleHttpParameters'"

class EventsRuleHttpParameters : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSEventsRuleHttpParameters'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-events-rule-httpparameters.html'

    hidden [object] $_headerParameters
    hidden [object] $_pathParameterValues
    hidden [object] $_queryStringParameters

    [string] $HeaderParameters
    [string[]] $PathParameterValues
    [string] $QueryStringParameters

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name HeaderParameters -Value {
            $this._headerParameters
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._headerParameters = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name PathParameterValues -Value {
            $this._pathParameterValues
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this._pathParameterValues = @($value)
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name QueryStringParameters -Value {
            $this._queryStringParameters
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._queryStringParameters = $value
        }
    }

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

Write-Verbose "Importing class 'EventsConnectionBasicAuthParameters'"

class EventsConnectionBasicAuthParameters : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSEventsConnectionBasicAuthParameters'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-events-connection-basicauthparameters.html'

    hidden [object] $_username
    hidden [object] $_password

    [string] $Username
    [string] $Password

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

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

Write-Verbose "Importing class 'EventsConnectionParameter'"

class EventsConnectionParameter : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSEventsConnectionParameter'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-events-connection-parameter.html'

    hidden [object] $_key
    hidden [object] $_value
    hidden [object] $_isValueSecret

    [string] $Key
    [string] $Value
    [bool] $IsValueSecret

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

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

Write-Verbose "Importing class 'EventsRuleBatchArrayProperties'"

class EventsRuleBatchArrayProperties : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSEventsRuleBatchArrayProperties'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-events-rule-batcharrayproperties.html'

    hidden [object] $_size

    [int] $Size

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

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

Write-Verbose "Importing class 'EventsRuleBatchParameters'"

class EventsRuleBatchParameters : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSEventsRuleBatchParameters'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-events-rule-batchparameters.html'

    hidden [object] $_arrayProperties
    hidden [object] $_jobDefinition
    hidden [object] $_jobName
    hidden [object] $_retryStrategy

    [EventsRuleBatchArrayProperties] $ArrayProperties
    [string] $JobDefinition
    [string] $JobName
    [EventsRuleBatchRetryStrategy] $RetryStrategy

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name ArrayProperties -Value {
            $this._arrayProperties
        } -SecondValue {
            param([ValidateType(([EventsRuleBatchArrayProperties], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._arrayProperties = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name JobDefinition -Value {
            $this._jobDefinition
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._jobDefinition = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name JobName -Value {
            $this._jobName
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._jobName = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name RetryStrategy -Value {
            $this._retryStrategy
        } -SecondValue {
            param([ValidateType(([EventsRuleBatchRetryStrategy], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._retryStrategy = $value
        }
    }

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

Write-Verbose "Importing class 'EventsRuleRunCommandParameters'"

class EventsRuleRunCommandParameters : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSEventsRuleRunCommandParameters'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-events-rule-runcommandparameters.html'

    hidden [object] $_runCommandTargets

    [EventsRuleRunCommandTarget[]] $RunCommandTargets

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

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

Write-Verbose "Importing class 'EventsRuleNetworkConfiguration'"

class EventsRuleNetworkConfiguration : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSEventsRuleNetworkConfiguration'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-events-rule-networkconfiguration.html'

    hidden [object] $_awsVpcConfiguration

    [EventsRuleAwsVpcConfiguration] $AwsVpcConfiguration

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

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

Write-Verbose "Importing class 'EventsRuleCapacityProviderStrategyItem'"

class EventsRuleCapacityProviderStrategyItem : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSEventsRuleCapacityProviderStrategyItem'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-events-rule-capacityproviderstrategyitem.html'

    hidden [object] $_base
    hidden [object] $_capacityProvider
    hidden [object] $_weight

    [int] $Base
    [string] $CapacityProvider
    [int] $Weight

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

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

Write-Verbose "Importing class 'EventsRuleSqsParameters'"

class EventsRuleSqsParameters : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSEventsRuleSqsParameters'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-events-rule-sqsparameters.html'

    hidden [object] $_messageGroupId

    [string] $MessageGroupId

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

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

Write-Verbose "Importing class 'EventsRulePlacementStrategy'"

class EventsRulePlacementStrategy : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSEventsRulePlacementStrategy'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-events-rule-placementstrategy.html'

    hidden [object] $_field
    hidden [object] $_type

    [string] $Field
    [string] $Type

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

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

Write-Verbose "Importing class 'EventsConnectionOAuthParameters'"

class EventsConnectionOAuthParameters : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSEventsConnectionOAuthParameters'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-events-connection-oauthparameters.html'

    hidden [object] $_clientParameters
    hidden [object] $_authorizationEndpoint
    hidden [object] $_httpMethod
    hidden [object] $_oAuthHttpParameters

    [EventsConnectionClientParameters] $ClientParameters
    [string] $AuthorizationEndpoint
    [string] $HttpMethod
    [EventsConnectionConnectionHttpParameters] $OAuthHttpParameters

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name ClientParameters -Value {
            $this._clientParameters
        } -SecondValue {
            param([ValidateType(([EventsConnectionClientParameters], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._clientParameters = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name AuthorizationEndpoint -Value {
            $this._authorizationEndpoint
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._authorizationEndpoint = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name HttpMethod -Value {
            $this._httpMethod
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._httpMethod = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name OAuthHttpParameters -Value {
            $this._oAuthHttpParameters
        } -SecondValue {
            param([ValidateType(([EventsConnectionConnectionHttpParameters], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._oAuthHttpParameters = $value
        }
    }

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

Write-Verbose "Importing class 'EventsRuleTarget'"

class EventsRuleTarget : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSEventsRuleTarget'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-events-rule-target.html'

    hidden [object] $_arn
    hidden [object] $_batchParameters
    hidden [object] $_deadLetterConfig
    hidden [object] $_ecsParameters
    hidden [object] $_httpParameters
    hidden [object] $_id
    hidden [object] $_input
    hidden [object] $_inputPath
    hidden [object] $_inputTransformer
    hidden [object] $_kinesisParameters
    hidden [object] $_redshiftDataParameters
    hidden [object] $_retryPolicy
    hidden [object] $_roleArn
    hidden [object] $_runCommandParameters
    hidden [object] $_sageMakerPipelineParameters
    hidden [object] $_sqsParameters

    [string] $Arn
    [EventsRuleBatchParameters] $BatchParameters
    [EventsRuleDeadLetterConfig] $DeadLetterConfig
    [EventsRuleEcsParameters] $EcsParameters
    [EventsRuleHttpParameters] $HttpParameters
    [string] $Id
    [string] $Input
    [string] $InputPath
    [EventsRuleInputTransformer] $InputTransformer
    [EventsRuleKinesisParameters] $KinesisParameters
    [EventsRuleRedshiftDataParameters] $RedshiftDataParameters
    [EventsRuleRetryPolicy] $RetryPolicy
    [string] $RoleArn
    [EventsRuleRunCommandParameters] $RunCommandParameters
    [EventsRuleSageMakerPipelineParameters] $SageMakerPipelineParameters
    [EventsRuleSqsParameters] $SqsParameters

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name Arn -Value {
            $this._arn
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._arn = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name BatchParameters -Value {
            $this._batchParameters
        } -SecondValue {
            param([ValidateType(([EventsRuleBatchParameters], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._batchParameters = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name DeadLetterConfig -Value {
            $this._deadLetterConfig
        } -SecondValue {
            param([ValidateType(([EventsRuleDeadLetterConfig], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._deadLetterConfig = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name EcsParameters -Value {
            $this._ecsParameters
        } -SecondValue {
            param([ValidateType(([EventsRuleEcsParameters], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._ecsParameters = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name HttpParameters -Value {
            $this._httpParameters
        } -SecondValue {
            param([ValidateType(([EventsRuleHttpParameters], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._httpParameters = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Id -Value {
            $this._id
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._id = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Input -Value {
            $this._input
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._input = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name InputPath -Value {
            $this._inputPath
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._inputPath = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name InputTransformer -Value {
            $this._inputTransformer
        } -SecondValue {
            param([ValidateType(([EventsRuleInputTransformer], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._inputTransformer = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name KinesisParameters -Value {
            $this._kinesisParameters
        } -SecondValue {
            param([ValidateType(([EventsRuleKinesisParameters], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._kinesisParameters = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name RedshiftDataParameters -Value {
            $this._redshiftDataParameters
        } -SecondValue {
            param([ValidateType(([EventsRuleRedshiftDataParameters], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._redshiftDataParameters = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name RetryPolicy -Value {
            $this._retryPolicy
        } -SecondValue {
            param([ValidateType(([EventsRuleRetryPolicy], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._retryPolicy = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name RoleArn -Value {
            $this._roleArn
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._roleArn = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name RunCommandParameters -Value {
            $this._runCommandParameters
        } -SecondValue {
            param([ValidateType(([EventsRuleRunCommandParameters], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._runCommandParameters = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name SageMakerPipelineParameters -Value {
            $this._sageMakerPipelineParameters
        } -SecondValue {
            param([ValidateType(([EventsRuleSageMakerPipelineParameters], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._sageMakerPipelineParameters = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name SqsParameters -Value {
            $this._sqsParameters
        } -SecondValue {
            param([ValidateType(([EventsRuleSqsParameters], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._sqsParameters = $value
        }
    }

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

Write-Verbose "Importing class 'EventsConnectionClientParameters'"

class EventsConnectionClientParameters : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSEventsConnectionClientParameters'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-events-connection-clientparameters.html'

    hidden [object] $_clientID
    hidden [object] $_clientSecret

    [string] $ClientID
    [string] $ClientSecret

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

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

Write-Verbose "Importing class 'EventsRuleTag'"

class EventsRuleTag : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSEventsRuleTag'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-events-rule-tag.html'

    hidden [object] $_key
    hidden [object] $_value

    [string] $Key
    [string] $Value

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

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

Write-Verbose "Importing class 'EventsRuleEcsParameters'"

class EventsRuleEcsParameters : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSEventsRuleEcsParameters'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-events-rule-ecsparameters.html'

    hidden [object] $_capacityProviderStrategy
    hidden [object] $_enableECSManagedTags
    hidden [object] $_enableExecuteCommand
    hidden [object] $_group
    hidden [object] $_launchType
    hidden [object] $_networkConfiguration
    hidden [object] $_placementConstraints
    hidden [object] $_placementStrategies
    hidden [object] $_platformVersion
    hidden [object] $_propagateTags
    hidden [object] $_referenceId
    hidden [object] $_tagList
    hidden [object] $_taskCount
    hidden [object] $_taskDefinitionArn

    [EventsRuleCapacityProviderStrategyItem[]] $CapacityProviderStrategy
    [bool] $EnableECSManagedTags
    [bool] $EnableExecuteCommand
    [string] $Group
    [string] $LaunchType
    [EventsRuleNetworkConfiguration] $NetworkConfiguration
    [EventsRulePlacementConstraint[]] $PlacementConstraints
    [EventsRulePlacementStrategy[]] $PlacementStrategies
    [string] $PlatformVersion
    [string] $PropagateTags
    [string] $ReferenceId
    [VSTag[]] $TagList
    [int] $TaskCount
    [string] $TaskDefinitionArn

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name CapacityProviderStrategy -Value {
            $this._capacityProviderStrategy
        } -SecondValue {
            param([ValidateType(([EventsRuleCapacityProviderStrategyItem], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this._capacityProviderStrategy = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name EnableECSManagedTags -Value {
            $this._enableECSManagedTags
        } -SecondValue {
            param([ValidateType(([bool], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._enableECSManagedTags = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name EnableExecuteCommand -Value {
            $this._enableExecuteCommand
        } -SecondValue {
            param([ValidateType(([bool], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._enableExecuteCommand = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Group -Value {
            $this._group
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._group = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name LaunchType -Value {
            $this._launchType
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._launchType = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name NetworkConfiguration -Value {
            $this._networkConfiguration
        } -SecondValue {
            param([ValidateType(([EventsRuleNetworkConfiguration], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._networkConfiguration = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name PlacementConstraints -Value {
            $this._placementConstraints
        } -SecondValue {
            param([ValidateType(([EventsRulePlacementConstraint], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this._placementConstraints = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name PlacementStrategies -Value {
            $this._placementStrategies
        } -SecondValue {
            param([ValidateType(([EventsRulePlacementStrategy], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this._placementStrategies = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name PlatformVersion -Value {
            $this._platformVersion
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._platformVersion = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name PropagateTags -Value {
            $this._propagateTags
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._propagateTags = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name ReferenceId -Value {
            $this._referenceId
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._referenceId = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name TagList -Value {
            $this._tagList
        } -SecondValue {
            param([TransformTag()] [ValidateType(([IDictionary], [psobject], [VSTag]))] [object] $value)
            $this._tagList = [VSTag]::TransformTag($value)
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name TaskCount -Value {
            $this._taskCount
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._taskCount = if ($cast = $value -as [int]) {
                $cast
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name TaskDefinitionArn -Value {
            $this._taskDefinitionArn
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._taskDefinitionArn = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
    }

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

Write-Verbose "Importing class 'EventsConnectionConnectionHttpParameters'"

class EventsConnectionConnectionHttpParameters : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSEventsConnectionConnectionHttpParameters'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-events-connection-connectionhttpparameters.html'

    hidden [object] $_headerParameters
    hidden [object] $_queryStringParameters
    hidden [object] $_bodyParameters

    [EventsConnectionParameter[]] $HeaderParameters
    [EventsConnectionParameter[]] $QueryStringParameters
    [EventsConnectionParameter[]] $BodyParameters

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name HeaderParameters -Value {
            $this._headerParameters
        } -SecondValue {
            param([ValidateType(([EventsConnectionParameter], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this._headerParameters = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name QueryStringParameters -Value {
            $this._queryStringParameters
        } -SecondValue {
            param([ValidateType(([EventsConnectionParameter], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this._queryStringParameters = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name BodyParameters -Value {
            $this._bodyParameters
        } -SecondValue {
            param([ValidateType(([EventsConnectionParameter], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this._bodyParameters = $value
        }
    }

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

Write-Verbose "Importing class 'EventsConnectionApiKeyAuthParameters'"

class EventsConnectionApiKeyAuthParameters : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSEventsConnectionApiKeyAuthParameters'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-events-connection-apikeyauthparameters.html'

    hidden [object] $_apiKeyName
    hidden [object] $_apiKeyValue

    [string] $ApiKeyName
    [string] $ApiKeyValue

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

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

Write-Verbose "Importing class 'EventsEventBusTagEntry'"

class EventsEventBusTagEntry : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSEventsEventBusTagEntry'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-events-eventbus-tagentry.html'

    hidden [object] $_value
    hidden [object] $_key

    [string] $Value
    [string] $Key

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

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

Write-Verbose "Importing class 'EventsEndpointEndpointEventBus'"

class EventsEndpointEndpointEventBus : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSEventsEndpointEndpointEventBus'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-events-endpoint-endpointeventbus.html'

    hidden [object] $_eventBusArn

    [string] $EventBusArn

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

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

Write-Verbose "Importing class 'EventsRulePlacementConstraint'"

class EventsRulePlacementConstraint : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSEventsRulePlacementConstraint'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-events-rule-placementconstraint.html'

    hidden [object] $_expression
    hidden [object] $_type

    [string] $Expression
    [string] $Type

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

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

Write-Verbose "Importing class 'EventsEventBusPolicyCondition'"

class EventsEventBusPolicyCondition : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSEventsEventBusPolicyCondition'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-events-eventbuspolicy-condition.html'

    hidden [object] $_type
    hidden [object] $_value
    hidden [object] $_key

    [string] $Type
    [string] $Value
    [string] $Key

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

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

Write-Verbose "Importing class 'EventsEndpointFailoverConfig'"

class EventsEndpointFailoverConfig : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSEventsEndpointFailoverConfig'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-events-endpoint-failoverconfig.html'

    hidden [object] $_primary
    hidden [object] $_secondary

    [EventsEndpointPrimary] $Primary
    [EventsEndpointSecondary] $Secondary

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name Primary -Value {
            $this._primary
        } -SecondValue {
            param([ValidateType(([EventsEndpointPrimary], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._primary = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Secondary -Value {
            $this._secondary
        } -SecondValue {
            param([ValidateType(([EventsEndpointSecondary], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._secondary = $value
        }
    }

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

Write-Verbose "Importing class 'EventsEndpointPrimary'"

class EventsEndpointPrimary : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSEventsEndpointPrimary'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-events-endpoint-primary.html'

    hidden [object] $_healthCheck

    [string] $HealthCheck

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

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

Write-Verbose "Importing class 'EventsRuleDeadLetterConfig'"

class EventsRuleDeadLetterConfig : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSEventsRuleDeadLetterConfig'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-events-rule-deadletterconfig.html'

    hidden [object] $_arn

    [string] $Arn

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

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

Write-Verbose "Importing class 'EventsRuleRunCommandTarget'"

class EventsRuleRunCommandTarget : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSEventsRuleRunCommandTarget'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-events-rule-runcommandtarget.html'

    hidden [object] $_key
    hidden [object] $_values

    [string] $Key
    [string[]] $Values

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

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

Write-Verbose "Importing class 'EventsRuleInputTransformer'"

class EventsRuleInputTransformer : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSEventsRuleInputTransformer'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-events-rule-inputtransformer.html'

    hidden [object] $_inputPathsMap
    hidden [object] $_inputTemplate

    [string] $InputPathsMap
    [string] $InputTemplate

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

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

Write-Verbose "Importing class 'EventsRuleRetryPolicy'"

class EventsRuleRetryPolicy : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSEventsRuleRetryPolicy'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-events-rule-retrypolicy.html'

    hidden [object] $_maximumEventAgeInSeconds
    hidden [object] $_maximumRetryAttempts

    [int] $MaximumEventAgeInSeconds
    [int] $MaximumRetryAttempts

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

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

Write-Verbose "Importing class 'EventsRuleKinesisParameters'"

class EventsRuleKinesisParameters : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSEventsRuleKinesisParameters'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-events-rule-kinesisparameters.html'

    hidden [object] $_partitionKeyPath

    [string] $PartitionKeyPath

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

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

Write-Verbose "Importing class 'EventsRuleSageMakerPipelineParameters'"

class EventsRuleSageMakerPipelineParameters : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSEventsRuleSageMakerPipelineParameters'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-events-rule-sagemakerpipelineparameters.html'

    hidden [object] $_pipelineParameterList

    [EventsRuleSageMakerPipelineParameter[]] $PipelineParameterList

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

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

Write-Verbose "Importing class 'EventsRuleRedshiftDataParameters'"

class EventsRuleRedshiftDataParameters : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSEventsRuleRedshiftDataParameters'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-events-rule-redshiftdataparameters.html'

    hidden [object] $_database
    hidden [object] $_dbUser
    hidden [object] $_secretManagerArn
    hidden [object] $_sql
    hidden [object] $_statementName
    hidden [object] $_withEvent

    [string] $Database
    [string] $DbUser
    [string] $SecretManagerArn
    [string] $Sql
    [string] $StatementName
    [bool] $WithEvent

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name Database -Value {
            $this._database
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._database = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name DbUser -Value {
            $this._dbUser
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._dbUser = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name SecretManagerArn -Value {
            $this._secretManagerArn
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._secretManagerArn = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Sql -Value {
            $this._sql
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._sql = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name StatementName -Value {
            $this._statementName
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._statementName = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name WithEvent -Value {
            $this._withEvent
        } -SecondValue {
            param([ValidateType(([bool], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._withEvent = $value
        }
    }

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

Write-Verbose "Importing class 'EventsRuleAwsVpcConfiguration'"

class EventsRuleAwsVpcConfiguration : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSEventsRuleAwsVpcConfiguration'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-events-rule-awsvpcconfiguration.html'

    hidden [object] $_assignPublicIp
    hidden [object] $_securityGroups
    hidden [object] $_subnets

    [string] $AssignPublicIp
    [string[]] $SecurityGroups
    [string[]] $Subnets

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

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

Write-Verbose "Importing class 'EventsEndpoint'"

class EventsEndpoint : VSResource {
    hidden [string] $_vsFunctionName = 'New-VSEventsEndpoint'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-events-endpoint.html'

    hidden [string[]] $_attributes = @('Arn','EndpointId','EndpointUrl','State','StateReason')
    hidden [object] $_condition

    [string] $Type = 'AWS::Events::Endpoint'
    [string] $Name
    [string] $RoleArn
    [string] $Description
    [EventsEndpointRoutingConfig] $RoutingConfig
    [EventsEndpointReplicationConfig] $ReplicationConfig
    [EventsEndpointEndpointEventBus[]] $EventBuses
    [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 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 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 RoutingConfig -Value {
            $this.Properties['RoutingConfig']
        } -SecondValue {
            param([ValidateType(([EventsEndpointRoutingConfig], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['RoutingConfig'] = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name ReplicationConfig -Value {
            $this.Properties['ReplicationConfig']
        } -SecondValue {
            param([ValidateType(([EventsEndpointReplicationConfig], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['ReplicationConfig'] = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name EventBuses -Value {
            $this.Properties['EventBuses']
        } -SecondValue {
            param([ValidateType(([EventsEndpointEndpointEventBus], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this.Properties['EventBuses'] = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Condition -Value {
            $this._condition
        } -SecondValue {
            param(
                [ValidateType(([string], [IntrinsicFunction], [ConditionFunction]))] [object]
                $value
            )
            $this._condition = $value
        }
    }

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

Write-Verbose "Importing class 'EventsApiDestination'"

class EventsApiDestination : VSResource {
    hidden [string] $_vsFunctionName = 'New-VSEventsApiDestination'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-events-apidestination.html'

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

    [string] $Type = 'AWS::Events::ApiDestination'
    [string] $Name
    [string] $Description
    [string] $ConnectionArn
    [int] $InvocationRateLimitPerSecond
    [string] $InvocationEndpoint
    [string] $HttpMethod
    [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 ConnectionArn -Value {
            $this.Properties['ConnectionArn']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['ConnectionArn'] = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name InvocationRateLimitPerSecond -Value {
            $this.Properties['InvocationRateLimitPerSecond']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['InvocationRateLimitPerSecond'] = if ($cast = $value -as [int]) {
                $cast
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name InvocationEndpoint -Value {
            $this.Properties['InvocationEndpoint']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['InvocationEndpoint'] = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name HttpMethod -Value {
            $this.Properties['HttpMethod']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['HttpMethod'] = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Condition -Value {
            $this._condition
        } -SecondValue {
            param(
                [ValidateType(([string], [IntrinsicFunction], [ConditionFunction]))] [object]
                $value
            )
            $this._condition = $value
        }
    }

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

Write-Verbose "Importing class 'EventsRule'"

class EventsRule : VSResource {
    hidden [string] $_vsFunctionName = 'New-VSEventsRule'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-events-rule.html'

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

    [string] $Type = 'AWS::Events::Rule'
    [string] $Description
    [string] $EventBusName
    [VSJson] $EventPattern
    [string] $Name
    [string] $RoleArn
    [string] $ScheduleExpression
    [string] $State
    [EventsRuleTarget[]] $Targets
    [VSJson] $Metadata
    [UpdatePolicy] $UpdatePolicy
    [string] $Condition

    hidden [void] _addAccessors() {
        $this._addBaseAccessors()
        $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 EventBusName -Value {
            $this.Properties['EventBusName']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['EventBusName'] = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name EventPattern -Value {
            $this.Properties['EventPattern']
        } -SecondValue {
            param([ValidateType(([string], [VSJson], [VSYaml], [psobject], [IDictionary]))][object] $value)
            $this.Properties['EventPattern'] = [VSJson]::Transform($value)
            Write-Debug $this.Properties['EventPattern']
        }
        $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 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 ScheduleExpression -Value {
            $this.Properties['ScheduleExpression']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['ScheduleExpression'] = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name State -Value {
            $this.Properties['State']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['State'] = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Targets -Value {
            $this.Properties['Targets']
        } -SecondValue {
            param([ValidateType(([EventsRuleTarget], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this.Properties['Targets'] = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Condition -Value {
            $this._condition
        } -SecondValue {
            param(
                [ValidateType(([string], [IntrinsicFunction], [ConditionFunction]))] [object]
                $value
            )
            $this._condition = $value
        }
    }

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

Write-Verbose "Importing class 'EventsArchive'"

class EventsArchive : VSResource {
    hidden [string] $_vsFunctionName = 'New-VSEventsArchive'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-events-archive.html'

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

    [string] $Type = 'AWS::Events::Archive'
    [string] $ArchiveName
    [string] $SourceArn
    [string] $Description
    [VSJson] $EventPattern
    [int] $RetentionDays
    [VSJson] $Metadata
    [UpdatePolicy] $UpdatePolicy
    [string] $Condition

    hidden [void] _addAccessors() {
        $this._addBaseAccessors()
        $this | Add-Member -Force -MemberType ScriptProperty -Name ArchiveName -Value {
            $this.Properties['ArchiveName']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['ArchiveName'] = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name SourceArn -Value {
            $this.Properties['SourceArn']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['SourceArn'] = 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 EventPattern -Value {
            $this.Properties['EventPattern']
        } -SecondValue {
            param([ValidateType(([string], [VSJson], [VSYaml], [psobject], [IDictionary]))][object] $value)
            $this.Properties['EventPattern'] = [VSJson]::Transform($value)
            Write-Debug $this.Properties['EventPattern']
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name RetentionDays -Value {
            $this.Properties['RetentionDays']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['RetentionDays'] = if ($cast = $value -as [int]) {
                $cast
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Condition -Value {
            $this._condition
        } -SecondValue {
            param(
                [ValidateType(([string], [IntrinsicFunction], [ConditionFunction]))] [object]
                $value
            )
            $this._condition = $value
        }
    }

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

Write-Verbose "Importing class 'EventsConnection'"

class EventsConnection : VSResource {
    hidden [string] $_vsFunctionName = 'New-VSEventsConnection'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-events-connection.html'

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

    [string] $Type = 'AWS::Events::Connection'
    [string] $Name
    [string] $Description
    [string] $AuthorizationType
    [EventsConnectionAuthParameters] $AuthParameters
    [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 AuthorizationType -Value {
            $this.Properties['AuthorizationType']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['AuthorizationType'] = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name AuthParameters -Value {
            $this.Properties['AuthParameters']
        } -SecondValue {
            param([ValidateType(([EventsConnectionAuthParameters], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['AuthParameters'] = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Condition -Value {
            $this._condition
        } -SecondValue {
            param(
                [ValidateType(([string], [IntrinsicFunction], [ConditionFunction]))] [object]
                $value
            )
            $this._condition = $value
        }
    }

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

Write-Verbose "Importing class 'EventsEventBusPolicy'"

class EventsEventBusPolicy : VSResource {
    hidden [string] $_vsFunctionName = 'New-VSEventsEventBusPolicy'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-events-eventbuspolicy.html'


    [string] $Type = 'AWS::Events::EventBusPolicy'
    [string] $EventBusName
    [EventsEventBusPolicyCondition] $Condition
    [string] $Action
    [string] $StatementId
    [VSJson] $Statement
    [string] $Principal
    [VSJson] $Metadata

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

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

Write-Verbose "Importing class 'EventsEventBus'"

class EventsEventBus : VSResource {
    hidden [string] $_vsFunctionName = 'New-VSEventsEventBus'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-events-eventbus.html'

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

    [string] $Type = 'AWS::Events::EventBus'
    [string] $EventSourceName
    [EventsEventBusTagEntry[]] $Tags
    [string] $Name
    [VSJson] $Metadata
    [UpdatePolicy] $UpdatePolicy
    [string] $Condition

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

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