VaporShell.Glue

3.0.0-beta20211124r1

VaporShell.Glue.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 'GlueMLTransformFindMatchesParameters'"

class GlueMLTransformFindMatchesParameters : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSGlueMLTransformFindMatchesParameters'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-mltransform-transformparameters-findmatchesparameters.html'

    hidden [object] $_precisionRecallTradeoff
    hidden [object] $_enforceProvidedLabels
    hidden [object] $_primaryKeyColumnName
    hidden [object] $_accuracyCostTradeoff

    [double] $PrecisionRecallTradeoff
    [bool] $EnforceProvidedLabels
    [string] $PrimaryKeyColumnName
    [double] $AccuracyCostTradeoff

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name PrecisionRecallTradeoff -Value {
            $this._precisionRecallTradeoff
        } -SecondValue {
            param([ValidateType(([double], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._precisionRecallTradeoff = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name EnforceProvidedLabels -Value {
            $this._enforceProvidedLabels
        } -SecondValue {
            param([ValidateType(([bool], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._enforceProvidedLabels = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name PrimaryKeyColumnName -Value {
            $this._primaryKeyColumnName
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._primaryKeyColumnName = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name AccuracyCostTradeoff -Value {
            $this._accuracyCostTradeoff
        } -SecondValue {
            param([ValidateType(([double], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._accuracyCostTradeoff = $value
        }
    }

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

Write-Verbose "Importing class 'GlueDatabaseDatabaseInput'"

class GlueDatabaseDatabaseInput : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSGlueDatabaseDatabaseInput'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-database-databaseinput.html'

    hidden [object] $_locationUri
    hidden [object] $_createTableDefaultPermissions
    hidden [object] $_description
    hidden [VSJson] $_parameters
    hidden [object] $_targetDatabase
    hidden [object] $_name

    [string] $LocationUri
    [GlueDatabasePrincipalPrivileges[]] $CreateTableDefaultPermissions
    [string] $Description
    [VSJson] $Parameters
    [GlueDatabaseDatabaseIdentifier] $TargetDatabase
    [string] $Name

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name LocationUri -Value {
            $this._locationUri
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._locationUri = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name CreateTableDefaultPermissions -Value {
            $this._createTableDefaultPermissions
        } -SecondValue {
            param([ValidateType(([GlueDatabasePrincipalPrivileges], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this._createTableDefaultPermissions = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Description -Value {
            $this._description
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._description = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Parameters -Value {
            $this._parameters
        } -SecondValue {
            param([ValidateType(([string], [VSJson], [VSYaml], [psobject], [IDictionary]))][object] $value)
            $this._parameters = [VSJson]::Transform($value)
            Write-Debug $this._parameters
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name TargetDatabase -Value {
            $this._targetDatabase
        } -SecondValue {
            param([ValidateType(([GlueDatabaseDatabaseIdentifier], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._targetDatabase = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Name -Value {
            $this._name
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._name = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
    }

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

Write-Verbose "Importing class 'GlueJobJobCommand'"

class GlueJobJobCommand : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSGlueJobJobCommand'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-job-jobcommand.html'

    hidden [object] $_pythonVersion
    hidden [object] $_scriptLocation
    hidden [object] $_name

    [string] $PythonVersion
    [string] $ScriptLocation
    [string] $Name

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

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

Write-Verbose "Importing class 'GlueCrawlerCatalogTarget'"

class GlueCrawlerCatalogTarget : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSGlueCrawlerCatalogTarget'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-crawler-catalogtarget.html'

    hidden [object] $_databaseName
    hidden [object] $_tables

    [string] $DatabaseName
    [string[]] $Tables

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

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

Write-Verbose "Importing class 'GlueConnectionConnectionInput'"

class GlueConnectionConnectionInput : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSGlueConnectionConnectionInput'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-connection-connectioninput.html'

    hidden [object] $_description
    hidden [object] $_connectionType
    hidden [object] $_matchCriteria
    hidden [object] $_physicalConnectionRequirements
    hidden [VSJson] $_connectionProperties
    hidden [object] $_name

    [string] $Description
    [string] $ConnectionType
    [string[]] $MatchCriteria
    [GlueConnectionPhysicalConnectionRequirements] $PhysicalConnectionRequirements
    [VSJson] $ConnectionProperties
    [string] $Name

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name Description -Value {
            $this._description
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._description = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name ConnectionType -Value {
            $this._connectionType
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._connectionType = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name MatchCriteria -Value {
            $this._matchCriteria
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this._matchCriteria = @($value)
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name PhysicalConnectionRequirements -Value {
            $this._physicalConnectionRequirements
        } -SecondValue {
            param([ValidateType(([GlueConnectionPhysicalConnectionRequirements], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._physicalConnectionRequirements = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name ConnectionProperties -Value {
            $this._connectionProperties
        } -SecondValue {
            param([ValidateType(([string], [VSJson], [VSYaml], [psobject], [IDictionary]))][object] $value)
            $this._connectionProperties = [VSJson]::Transform($value)
            Write-Debug $this._connectionProperties
        }
        $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
            }
        }
    }

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

Write-Verbose "Importing class 'GlueConnectionPhysicalConnectionRequirements'"

class GlueConnectionPhysicalConnectionRequirements : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSGlueConnectionPhysicalConnectionRequirements'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-connection-physicalconnectionrequirements.html'

    hidden [object] $_availabilityZone
    hidden [object] $_securityGroupIdList
    hidden [object] $_subnetId

    [string] $AvailabilityZone
    [string[]] $SecurityGroupIdList
    [string] $SubnetId

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

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

Write-Verbose "Importing class 'GlueSchemaVersionSchema'"

class GlueSchemaVersionSchema : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSGlueSchemaVersionSchema'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-schemaversion-schema.html'

    hidden [object] $_schemaArn
    hidden [object] $_schemaName
    hidden [object] $_registryName

    [string] $SchemaArn
    [string] $SchemaName
    [string] $RegistryName

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

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

Write-Verbose "Importing class 'GlueSchemaSchemaVersion'"

class GlueSchemaSchemaVersion : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSGlueSchemaSchemaVersion'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-schema-schemaversion.html'

    hidden [object] $_isLatest
    hidden [object] $_versionNumber

    [bool] $IsLatest
    [int] $VersionNumber

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

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

Write-Verbose "Importing class 'GlueDatabasePrincipalPrivileges'"

class GlueDatabasePrincipalPrivileges : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSGlueDatabasePrincipalPrivileges'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-database-principalprivileges.html'

    hidden [object] $_permissions
    hidden [object] $_principal

    [string[]] $Permissions
    [GlueDatabaseDataLakePrincipal] $Principal

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name Permissions -Value {
            $this._permissions
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this._permissions = @($value)
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Principal -Value {
            $this._principal
        } -SecondValue {
            param([ValidateType(([GlueDatabaseDataLakePrincipal], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._principal = $value
        }
    }

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

Write-Verbose "Importing class 'GlueCrawlerSchedule'"

class GlueCrawlerSchedule : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSGlueCrawlerSchedule'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-crawler-schedule.html'

    hidden [object] $_scheduleExpression

    [string] $ScheduleExpression

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

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

Write-Verbose "Importing class 'GlueDataCatalogEncryptionSettingsDataCatalogEncryptionSettings'"

class GlueDataCatalogEncryptionSettingsDataCatalogEncryptionSettings : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSGlueDataCatalogEncryptionSettingsDataCatalogEncryptionSettings'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-datacatalogencryptionsettings-datacatalogencryptionsettings.html'

    hidden [object] $_connectionPasswordEncryption
    hidden [object] $_encryptionAtRest

    [GlueDataCatalogEncryptionSettingsConnectionPasswordEncryption] $ConnectionPasswordEncryption
    [GlueDataCatalogEncryptionSettingsEncryptionAtRest] $EncryptionAtRest

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name ConnectionPasswordEncryption -Value {
            $this._connectionPasswordEncryption
        } -SecondValue {
            param([ValidateType(([GlueDataCatalogEncryptionSettingsConnectionPasswordEncryption], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._connectionPasswordEncryption = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name EncryptionAtRest -Value {
            $this._encryptionAtRest
        } -SecondValue {
            param([ValidateType(([GlueDataCatalogEncryptionSettingsEncryptionAtRest], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._encryptionAtRest = $value
        }
    }

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

Write-Verbose "Importing class 'GlueTriggerCondition'"

class GlueTriggerCondition : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSGlueTriggerCondition'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-trigger-condition.html'

    hidden [object] $_crawlerName
    hidden [object] $_state
    hidden [object] $_crawlState
    hidden [object] $_logicalOperator
    hidden [object] $_jobName

    [string] $CrawlerName
    [string] $State
    [string] $CrawlState
    [string] $LogicalOperator
    [string] $JobName

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

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

Write-Verbose "Importing class 'GlueDatabaseDatabaseIdentifier'"

class GlueDatabaseDatabaseIdentifier : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSGlueDatabaseDatabaseIdentifier'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-database-databaseidentifier.html'

    hidden [object] $_databaseName
    hidden [object] $_catalogId

    [string] $DatabaseName
    [string] $CatalogId

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

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

Write-Verbose "Importing class 'GluePartitionPartitionInput'"

class GluePartitionPartitionInput : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSGluePartitionPartitionInput'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-partition-partitioninput.html'

    hidden [VSJson] $_parameters
    hidden [object] $_storageDescriptor
    hidden [object] $_values

    [VSJson] $Parameters
    [GluePartitionStorageDescriptor] $StorageDescriptor
    [string[]] $Values

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name Parameters -Value {
            $this._parameters
        } -SecondValue {
            param([ValidateType(([string], [VSJson], [VSYaml], [psobject], [IDictionary]))][object] $value)
            $this._parameters = [VSJson]::Transform($value)
            Write-Debug $this._parameters
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name StorageDescriptor -Value {
            $this._storageDescriptor
        } -SecondValue {
            param([ValidateType(([GluePartitionStorageDescriptor], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._storageDescriptor = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Values -Value {
            $this._values
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this._values = @($value)
        }
    }

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

Write-Verbose "Importing class 'GlueTableColumn'"

class GlueTableColumn : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSGlueTableColumn'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-table-column.html'

    hidden [object] $_comment
    hidden [object] $_type
    hidden [object] $_name

    [string] $Comment
    [string] $Type
    [string] $Name

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

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

Write-Verbose "Importing class 'GlueDataCatalogEncryptionSettingsEncryptionAtRest'"

class GlueDataCatalogEncryptionSettingsEncryptionAtRest : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSGlueDataCatalogEncryptionSettingsEncryptionAtRest'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-datacatalogencryptionsettings-encryptionatrest.html'

    hidden [object] $_catalogEncryptionMode
    hidden [object] $_sseAwsKmsKeyId

    [string] $CatalogEncryptionMode
    [string] $SseAwsKmsKeyId

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

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

Write-Verbose "Importing class 'GlueCrawlerSchemaChangePolicy'"

class GlueCrawlerSchemaChangePolicy : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSGlueCrawlerSchemaChangePolicy'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-crawler-schemachangepolicy.html'

    hidden [object] $_updateBehavior
    hidden [object] $_deleteBehavior

    [string] $UpdateBehavior
    [string] $DeleteBehavior

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

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

Write-Verbose "Importing class 'GlueMLTransformMLUserDataEncryption'"

class GlueMLTransformMLUserDataEncryption : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSGlueMLTransformMLUserDataEncryption'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-mltransform-transformencryption-mluserdataencryption.html'

    hidden [object] $_mLUserDataEncryptionMode
    hidden [object] $_kmsKeyId

    [string] $MLUserDataEncryptionMode
    [string] $KmsKeyId

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

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

Write-Verbose "Importing class 'GlueClassifierCsvClassifier'"

class GlueClassifierCsvClassifier : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSGlueClassifierCsvClassifier'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-classifier-csvclassifier.html'

    hidden [object] $_quoteSymbol
    hidden [object] $_containsHeader
    hidden [object] $_delimiter
    hidden [object] $_header
    hidden [object] $_allowSingleColumn
    hidden [object] $_disableValueTrimming
    hidden [object] $_name

    [string] $QuoteSymbol
    [string] $ContainsHeader
    [string] $Delimiter
    [string[]] $Header
    [bool] $AllowSingleColumn
    [bool] $DisableValueTrimming
    [string] $Name

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name QuoteSymbol -Value {
            $this._quoteSymbol
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._quoteSymbol = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name ContainsHeader -Value {
            $this._containsHeader
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._containsHeader = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Delimiter -Value {
            $this._delimiter
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._delimiter = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Header -Value {
            $this._header
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this._header = @($value)
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name AllowSingleColumn -Value {
            $this._allowSingleColumn
        } -SecondValue {
            param([ValidateType(([bool], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._allowSingleColumn = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name DisableValueTrimming -Value {
            $this._disableValueTrimming
        } -SecondValue {
            param([ValidateType(([bool], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._disableValueTrimming = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Name -Value {
            $this._name
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._name = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
    }

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

Write-Verbose "Importing class 'GluePartitionOrder'"

class GluePartitionOrder : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSGluePartitionOrder'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-partition-order.html'

    hidden [object] $_column
    hidden [object] $_sortOrder

    [string] $Column
    [int] $SortOrder

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

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

Write-Verbose "Importing class 'GlueSecurityConfigurationEncryptionConfiguration'"

class GlueSecurityConfigurationEncryptionConfiguration : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSGlueSecurityConfigurationEncryptionConfiguration'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-securityconfiguration-encryptionconfiguration.html'

    hidden [object] $_s3Encryptions
    hidden [object] $_cloudWatchEncryption
    hidden [object] $_jobBookmarksEncryption

    [GlueSecurityConfigurationS3Encryptions] $S3Encryptions
    [GlueSecurityConfigurationCloudWatchEncryption] $CloudWatchEncryption
    [GlueSecurityConfigurationJobBookmarksEncryption] $JobBookmarksEncryption

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name S3Encryptions -Value {
            $this._s3Encryptions
        } -SecondValue {
            param([ValidateType(([GlueSecurityConfigurationS3Encryptions], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._s3Encryptions = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name CloudWatchEncryption -Value {
            $this._cloudWatchEncryption
        } -SecondValue {
            param([ValidateType(([GlueSecurityConfigurationCloudWatchEncryption], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._cloudWatchEncryption = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name JobBookmarksEncryption -Value {
            $this._jobBookmarksEncryption
        } -SecondValue {
            param([ValidateType(([GlueSecurityConfigurationJobBookmarksEncryption], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._jobBookmarksEncryption = $value
        }
    }

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

Write-Verbose "Importing class 'GlueTableTableInput'"

class GlueTableTableInput : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSGlueTableTableInput'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-table-tableinput.html'

    hidden [object] $_owner
    hidden [object] $_viewOriginalText
    hidden [object] $_description
    hidden [object] $_tableType
    hidden [VSJson] $_parameters
    hidden [object] $_viewExpandedText
    hidden [object] $_storageDescriptor
    hidden [object] $_targetTable
    hidden [object] $_partitionKeys
    hidden [object] $_retention
    hidden [object] $_name

    [string] $Owner
    [string] $ViewOriginalText
    [string] $Description
    [string] $TableType
    [VSJson] $Parameters
    [string] $ViewExpandedText
    [GlueTableStorageDescriptor] $StorageDescriptor
    [GlueTableTableIdentifier] $TargetTable
    [GlueTableColumn[]] $PartitionKeys
    [int] $Retention
    [string] $Name

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name Owner -Value {
            $this._owner
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._owner = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name ViewOriginalText -Value {
            $this._viewOriginalText
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._viewOriginalText = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Description -Value {
            $this._description
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._description = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name TableType -Value {
            $this._tableType
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._tableType = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Parameters -Value {
            $this._parameters
        } -SecondValue {
            param([ValidateType(([string], [VSJson], [VSYaml], [psobject], [IDictionary]))][object] $value)
            $this._parameters = [VSJson]::Transform($value)
            Write-Debug $this._parameters
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name ViewExpandedText -Value {
            $this._viewExpandedText
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._viewExpandedText = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name StorageDescriptor -Value {
            $this._storageDescriptor
        } -SecondValue {
            param([ValidateType(([GlueTableStorageDescriptor], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._storageDescriptor = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name TargetTable -Value {
            $this._targetTable
        } -SecondValue {
            param([ValidateType(([GlueTableTableIdentifier], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._targetTable = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name PartitionKeys -Value {
            $this._partitionKeys
        } -SecondValue {
            param([ValidateType(([GlueTableColumn], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this._partitionKeys = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Retention -Value {
            $this._retention
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._retention = if ($cast = $value -as [int]) {
                $cast
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Name -Value {
            $this._name
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._name = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
    }

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

Write-Verbose "Importing class 'GluePartitionSchemaReference'"

class GluePartitionSchemaReference : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSGluePartitionSchemaReference'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-partition-schemareference.html'

    hidden [object] $_schemaVersionId
    hidden [object] $_schemaId
    hidden [object] $_schemaVersionNumber

    [string] $SchemaVersionId
    [GluePartitionSchemaId] $SchemaId
    [int] $SchemaVersionNumber

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name SchemaVersionId -Value {
            $this._schemaVersionId
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._schemaVersionId = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name SchemaId -Value {
            $this._schemaId
        } -SecondValue {
            param([ValidateType(([GluePartitionSchemaId], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._schemaId = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name SchemaVersionNumber -Value {
            $this._schemaVersionNumber
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._schemaVersionNumber = if ($cast = $value -as [int]) {
                $cast
            }
            else {
                $value
            }
        }
    }

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

Write-Verbose "Importing class 'GlueClassifierGrokClassifier'"

class GlueClassifierGrokClassifier : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSGlueClassifierGrokClassifier'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-classifier-grokclassifier.html'

    hidden [object] $_customPatterns
    hidden [object] $_grokPattern
    hidden [object] $_classification
    hidden [object] $_name

    [string] $CustomPatterns
    [string] $GrokPattern
    [string] $Classification
    [string] $Name

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

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

Write-Verbose "Importing class 'GlueSchemaRegistry'"

class GlueSchemaRegistry : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSGlueSchemaRegistry'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-schema-registry.html'

    hidden [object] $_name
    hidden [object] $_arn

    [string] $Name
    [string] $Arn

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

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

Write-Verbose "Importing class 'GlueSecurityConfigurationJobBookmarksEncryption'"

class GlueSecurityConfigurationJobBookmarksEncryption : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSGlueSecurityConfigurationJobBookmarksEncryption'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-securityconfiguration-jobbookmarksencryption.html'

    hidden [object] $_kmsKeyArn
    hidden [object] $_jobBookmarksEncryptionMode

    [string] $KmsKeyArn
    [string] $JobBookmarksEncryptionMode

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

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

Write-Verbose "Importing class 'GlueTableSerdeInfo'"

class GlueTableSerdeInfo : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSGlueTableSerdeInfo'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-table-serdeinfo.html'

    hidden [VSJson] $_parameters
    hidden [object] $_serializationLibrary
    hidden [object] $_name

    [VSJson] $Parameters
    [string] $SerializationLibrary
    [string] $Name

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name Parameters -Value {
            $this._parameters
        } -SecondValue {
            param([ValidateType(([string], [VSJson], [VSYaml], [psobject], [IDictionary]))][object] $value)
            $this._parameters = [VSJson]::Transform($value)
            Write-Debug $this._parameters
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name SerializationLibrary -Value {
            $this._serializationLibrary
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._serializationLibrary = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Name -Value {
            $this._name
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._name = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
    }

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

Write-Verbose "Importing class 'GlueClassifierJsonClassifier'"

class GlueClassifierJsonClassifier : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSGlueClassifierJsonClassifier'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-classifier-jsonclassifier.html'

    hidden [object] $_jsonPath
    hidden [object] $_name

    [string] $JsonPath
    [string] $Name

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

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

Write-Verbose "Importing class 'GlueSecurityConfigurationS3Encryptions'"

class GlueSecurityConfigurationS3Encryptions : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSGlueSecurityConfigurationS3Encryptions'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-securityconfiguration-s3encryptions.html'



    hidden [void] _addAccessors() {
    }

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

Write-Verbose "Importing class 'GlueDataCatalogEncryptionSettingsConnectionPasswordEncryption'"

class GlueDataCatalogEncryptionSettingsConnectionPasswordEncryption : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSGlueDataCatalogEncryptionSettingsConnectionPasswordEncryption'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-datacatalogencryptionsettings-connectionpasswordencryption.html'

    hidden [object] $_returnConnectionPasswordEncrypted
    hidden [object] $_kmsKeyId

    [bool] $ReturnConnectionPasswordEncrypted
    [string] $KmsKeyId

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

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

Write-Verbose "Importing class 'GlueMLTransformInputRecordTables'"

class GlueMLTransformInputRecordTables : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSGlueMLTransformInputRecordTables'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-mltransform-inputrecordtables.html'

    hidden [object] $_glueTables

    [GlueMLTransformGlueTables[]] $GlueTables

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

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

Write-Verbose "Importing class 'GlueMLTransformGlueTables'"

class GlueMLTransformGlueTables : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSGlueMLTransformGlueTables'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-mltransform-inputrecordtables-gluetables.html'

    hidden [object] $_connectionName
    hidden [object] $_tableName
    hidden [object] $_databaseName
    hidden [object] $_catalogId

    [string] $ConnectionName
    [string] $TableName
    [string] $DatabaseName
    [string] $CatalogId

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name ConnectionName -Value {
            $this._connectionName
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._connectionName = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name TableName -Value {
            $this._tableName
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._tableName = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name DatabaseName -Value {
            $this._databaseName
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._databaseName = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name CatalogId -Value {
            $this._catalogId
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._catalogId = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
    }

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

Write-Verbose "Importing class 'GluePartitionSerdeInfo'"

class GluePartitionSerdeInfo : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSGluePartitionSerdeInfo'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-partition-serdeinfo.html'

    hidden [VSJson] $_parameters
    hidden [object] $_serializationLibrary
    hidden [object] $_name

    [VSJson] $Parameters
    [string] $SerializationLibrary
    [string] $Name

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name Parameters -Value {
            $this._parameters
        } -SecondValue {
            param([ValidateType(([string], [VSJson], [VSYaml], [psobject], [IDictionary]))][object] $value)
            $this._parameters = [VSJson]::Transform($value)
            Write-Debug $this._parameters
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name SerializationLibrary -Value {
            $this._serializationLibrary
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._serializationLibrary = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Name -Value {
            $this._name
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._name = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
    }

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

Write-Verbose "Importing class 'GlueSecurityConfigurationS3Encryption'"

class GlueSecurityConfigurationS3Encryption : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSGlueSecurityConfigurationS3Encryption'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-securityconfiguration-s3encryption.html'

    hidden [object] $_kmsKeyArn
    hidden [object] $_s3EncryptionMode

    [string] $KmsKeyArn
    [string] $S3EncryptionMode

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

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

Write-Verbose "Importing class 'GlueDatabaseDataLakePrincipal'"

class GlueDatabaseDataLakePrincipal : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSGlueDatabaseDataLakePrincipal'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-database-datalakeprincipal.html'

    hidden [object] $_dataLakePrincipalIdentifier

    [string] $DataLakePrincipalIdentifier

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

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

Write-Verbose "Importing class 'GlueMLTransformTransformEncryption'"

class GlueMLTransformTransformEncryption : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSGlueMLTransformTransformEncryption'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-mltransform-transformencryption.html'

    hidden [object] $_mLUserDataEncryption
    hidden [object] $_taskRunSecurityConfigurationName

    [GlueMLTransformMLUserDataEncryption] $MLUserDataEncryption
    [string] $TaskRunSecurityConfigurationName

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

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

Write-Verbose "Importing class 'GlueJobConnectionsList'"

class GlueJobConnectionsList : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSGlueJobConnectionsList'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-job-connectionslist.html'

    hidden [object] $_connections

    [string[]] $Connections

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

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

Write-Verbose "Importing class 'GlueSecurityConfigurationCloudWatchEncryption'"

class GlueSecurityConfigurationCloudWatchEncryption : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSGlueSecurityConfigurationCloudWatchEncryption'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-securityconfiguration-cloudwatchencryption.html'

    hidden [object] $_kmsKeyArn
    hidden [object] $_cloudWatchEncryptionMode

    [string] $KmsKeyArn
    [string] $CloudWatchEncryptionMode

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

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

Write-Verbose "Importing class 'GlueCrawlerTargets'"

class GlueCrawlerTargets : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSGlueCrawlerTargets'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-crawler-targets.html'

    hidden [object] $_s3Targets
    hidden [object] $_catalogTargets
    hidden [object] $_jdbcTargets
    hidden [object] $_dynamoDBTargets

    [GlueCrawlerS3Target[]] $S3Targets
    [GlueCrawlerCatalogTarget[]] $CatalogTargets
    [GlueCrawlerJdbcTarget[]] $JdbcTargets
    [GlueCrawlerDynamoDBTarget[]] $DynamoDBTargets

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name S3Targets -Value {
            $this._s3Targets
        } -SecondValue {
            param([ValidateType(([GlueCrawlerS3Target], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this._s3Targets = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name CatalogTargets -Value {
            $this._catalogTargets
        } -SecondValue {
            param([ValidateType(([GlueCrawlerCatalogTarget], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this._catalogTargets = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name JdbcTargets -Value {
            $this._jdbcTargets
        } -SecondValue {
            param([ValidateType(([GlueCrawlerJdbcTarget], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this._jdbcTargets = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name DynamoDBTargets -Value {
            $this._dynamoDBTargets
        } -SecondValue {
            param([ValidateType(([GlueCrawlerDynamoDBTarget], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this._dynamoDBTargets = $value
        }
    }

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

Write-Verbose "Importing class 'GlueCrawlerJdbcTarget'"

class GlueCrawlerJdbcTarget : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSGlueCrawlerJdbcTarget'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-crawler-jdbctarget.html'

    hidden [object] $_connectionName
    hidden [object] $_path
    hidden [object] $_exclusions

    [string] $ConnectionName
    [string] $Path
    [string[]] $Exclusions

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

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

Write-Verbose "Importing class 'GlueTableSchemaId'"

class GlueTableSchemaId : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSGlueTableSchemaId'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-table-schemaid.html'

    hidden [object] $_registryName
    hidden [object] $_schemaName
    hidden [object] $_schemaArn

    [string] $RegistryName
    [string] $SchemaName
    [string] $SchemaArn

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

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

Write-Verbose "Importing class 'GlueTriggerPredicate'"

class GlueTriggerPredicate : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSGlueTriggerPredicate'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-trigger-predicate.html'

    hidden [object] $_logical
    hidden [object] $_conditions

    [string] $Logical
    [GlueTriggerCondition[]] $Conditions

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

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

Write-Verbose "Importing class 'GlueTableOrder'"

class GlueTableOrder : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSGlueTableOrder'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-table-order.html'

    hidden [object] $_column
    hidden [object] $_sortOrder

    [string] $Column
    [int] $SortOrder

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

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

Write-Verbose "Importing class 'GluePartitionColumn'"

class GluePartitionColumn : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSGluePartitionColumn'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-partition-column.html'

    hidden [object] $_comment
    hidden [object] $_type
    hidden [object] $_name

    [string] $Comment
    [string] $Type
    [string] $Name

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

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

Write-Verbose "Importing class 'GlueCrawlerDynamoDBTarget'"

class GlueCrawlerDynamoDBTarget : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSGlueCrawlerDynamoDBTarget'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-crawler-dynamodbtarget.html'

    hidden [object] $_path

    [string] $Path

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

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

Write-Verbose "Importing class 'GlueTriggerAction'"

class GlueTriggerAction : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSGlueTriggerAction'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-trigger-action.html'

    hidden [object] $_notificationProperty
    hidden [object] $_crawlerName
    hidden [object] $_timeout
    hidden [object] $_jobName
    hidden [VSJson] $_arguments
    hidden [object] $_securityConfiguration

    [GlueTriggerNotificationProperty] $NotificationProperty
    [string] $CrawlerName
    [int] $Timeout
    [string] $JobName
    [VSJson] $Arguments
    [string] $SecurityConfiguration

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name NotificationProperty -Value {
            $this._notificationProperty
        } -SecondValue {
            param([ValidateType(([GlueTriggerNotificationProperty], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._notificationProperty = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name CrawlerName -Value {
            $this._crawlerName
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._crawlerName = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Timeout -Value {
            $this._timeout
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._timeout = if ($cast = $value -as [int]) {
                $cast
            }
            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 Arguments -Value {
            $this._arguments
        } -SecondValue {
            param([ValidateType(([string], [VSJson], [VSYaml], [psobject], [IDictionary]))][object] $value)
            $this._arguments = [VSJson]::Transform($value)
            Write-Debug $this._arguments
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name SecurityConfiguration -Value {
            $this._securityConfiguration
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._securityConfiguration = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
    }

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

Write-Verbose "Importing class 'GluePartitionStorageDescriptor'"

class GluePartitionStorageDescriptor : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSGluePartitionStorageDescriptor'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-partition-storagedescriptor.html'

    hidden [object] $_storedAsSubDirectories
    hidden [VSJson] $_parameters
    hidden [object] $_bucketColumns
    hidden [object] $_numberOfBuckets
    hidden [object] $_outputFormat
    hidden [object] $_columns
    hidden [object] $_serdeInfo
    hidden [object] $_sortColumns
    hidden [object] $_compressed
    hidden [object] $_schemaReference
    hidden [object] $_skewedInfo
    hidden [object] $_inputFormat
    hidden [object] $_location

    [bool] $StoredAsSubDirectories
    [VSJson] $Parameters
    [string[]] $BucketColumns
    [int] $NumberOfBuckets
    [string] $OutputFormat
    [GluePartitionColumn[]] $Columns
    [GluePartitionSerdeInfo] $SerdeInfo
    [GluePartitionOrder[]] $SortColumns
    [bool] $Compressed
    [GluePartitionSchemaReference] $SchemaReference
    [GluePartitionSkewedInfo] $SkewedInfo
    [string] $InputFormat
    [string] $Location

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name StoredAsSubDirectories -Value {
            $this._storedAsSubDirectories
        } -SecondValue {
            param([ValidateType(([bool], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._storedAsSubDirectories = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Parameters -Value {
            $this._parameters
        } -SecondValue {
            param([ValidateType(([string], [VSJson], [VSYaml], [psobject], [IDictionary]))][object] $value)
            $this._parameters = [VSJson]::Transform($value)
            Write-Debug $this._parameters
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name BucketColumns -Value {
            $this._bucketColumns
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this._bucketColumns = @($value)
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name NumberOfBuckets -Value {
            $this._numberOfBuckets
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._numberOfBuckets = if ($cast = $value -as [int]) {
                $cast
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name OutputFormat -Value {
            $this._outputFormat
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._outputFormat = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Columns -Value {
            $this._columns
        } -SecondValue {
            param([ValidateType(([GluePartitionColumn], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this._columns = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name SerdeInfo -Value {
            $this._serdeInfo
        } -SecondValue {
            param([ValidateType(([GluePartitionSerdeInfo], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._serdeInfo = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name SortColumns -Value {
            $this._sortColumns
        } -SecondValue {
            param([ValidateType(([GluePartitionOrder], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this._sortColumns = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Compressed -Value {
            $this._compressed
        } -SecondValue {
            param([ValidateType(([bool], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._compressed = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name SchemaReference -Value {
            $this._schemaReference
        } -SecondValue {
            param([ValidateType(([GluePartitionSchemaReference], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._schemaReference = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name SkewedInfo -Value {
            $this._skewedInfo
        } -SecondValue {
            param([ValidateType(([GluePartitionSkewedInfo], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._skewedInfo = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name InputFormat -Value {
            $this._inputFormat
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._inputFormat = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Location -Value {
            $this._location
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._location = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
    }

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

Write-Verbose "Importing class 'GlueTableSkewedInfo'"

class GlueTableSkewedInfo : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSGlueTableSkewedInfo'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-table-skewedinfo.html'

    hidden [object] $_skewedColumnNames
    hidden [object] $_skewedColumnValues
    hidden [VSJson] $_skewedColumnValueLocationMaps

    [string[]] $SkewedColumnNames
    [string[]] $SkewedColumnValues
    [VSJson] $SkewedColumnValueLocationMaps

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name SkewedColumnNames -Value {
            $this._skewedColumnNames
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this._skewedColumnNames = @($value)
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name SkewedColumnValues -Value {
            $this._skewedColumnValues
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this._skewedColumnValues = @($value)
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name SkewedColumnValueLocationMaps -Value {
            $this._skewedColumnValueLocationMaps
        } -SecondValue {
            param([ValidateType(([string], [VSJson], [VSYaml], [psobject], [IDictionary]))][object] $value)
            $this._skewedColumnValueLocationMaps = [VSJson]::Transform($value)
            Write-Debug $this._skewedColumnValueLocationMaps
        }
    }

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

Write-Verbose "Importing class 'GlueTableStorageDescriptor'"

class GlueTableStorageDescriptor : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSGlueTableStorageDescriptor'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-table-storagedescriptor.html'

    hidden [object] $_storedAsSubDirectories
    hidden [VSJson] $_parameters
    hidden [object] $_bucketColumns
    hidden [object] $_numberOfBuckets
    hidden [object] $_outputFormat
    hidden [object] $_columns
    hidden [object] $_serdeInfo
    hidden [object] $_sortColumns
    hidden [object] $_compressed
    hidden [object] $_schemaReference
    hidden [object] $_skewedInfo
    hidden [object] $_inputFormat
    hidden [object] $_location

    [bool] $StoredAsSubDirectories
    [VSJson] $Parameters
    [string[]] $BucketColumns
    [int] $NumberOfBuckets
    [string] $OutputFormat
    [GlueTableColumn[]] $Columns
    [GlueTableSerdeInfo] $SerdeInfo
    [GlueTableOrder[]] $SortColumns
    [bool] $Compressed
    [GlueTableSchemaReference] $SchemaReference
    [GlueTableSkewedInfo] $SkewedInfo
    [string] $InputFormat
    [string] $Location

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name StoredAsSubDirectories -Value {
            $this._storedAsSubDirectories
        } -SecondValue {
            param([ValidateType(([bool], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._storedAsSubDirectories = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Parameters -Value {
            $this._parameters
        } -SecondValue {
            param([ValidateType(([string], [VSJson], [VSYaml], [psobject], [IDictionary]))][object] $value)
            $this._parameters = [VSJson]::Transform($value)
            Write-Debug $this._parameters
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name BucketColumns -Value {
            $this._bucketColumns
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this._bucketColumns = @($value)
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name NumberOfBuckets -Value {
            $this._numberOfBuckets
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._numberOfBuckets = if ($cast = $value -as [int]) {
                $cast
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name OutputFormat -Value {
            $this._outputFormat
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._outputFormat = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Columns -Value {
            $this._columns
        } -SecondValue {
            param([ValidateType(([GlueTableColumn], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this._columns = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name SerdeInfo -Value {
            $this._serdeInfo
        } -SecondValue {
            param([ValidateType(([GlueTableSerdeInfo], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._serdeInfo = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name SortColumns -Value {
            $this._sortColumns
        } -SecondValue {
            param([ValidateType(([GlueTableOrder], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this._sortColumns = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Compressed -Value {
            $this._compressed
        } -SecondValue {
            param([ValidateType(([bool], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._compressed = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name SchemaReference -Value {
            $this._schemaReference
        } -SecondValue {
            param([ValidateType(([GlueTableSchemaReference], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._schemaReference = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name SkewedInfo -Value {
            $this._skewedInfo
        } -SecondValue {
            param([ValidateType(([GlueTableSkewedInfo], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._skewedInfo = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name InputFormat -Value {
            $this._inputFormat
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._inputFormat = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Location -Value {
            $this._location
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._location = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
    }

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

Write-Verbose "Importing class 'GlueTriggerNotificationProperty'"

class GlueTriggerNotificationProperty : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSGlueTriggerNotificationProperty'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-trigger-notificationproperty.html'

    hidden [object] $_notifyDelayAfter

    [int] $NotifyDelayAfter

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

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

Write-Verbose "Importing class 'GlueClassifierXMLClassifier'"

class GlueClassifierXMLClassifier : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSGlueClassifierXMLClassifier'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-classifier-xmlclassifier.html'

    hidden [object] $_rowTag
    hidden [object] $_classification
    hidden [object] $_name

    [string] $RowTag
    [string] $Classification
    [string] $Name

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

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

Write-Verbose "Importing class 'GlueMLTransformTransformParameters'"

class GlueMLTransformTransformParameters : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSGlueMLTransformTransformParameters'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-mltransform-transformparameters.html'

    hidden [object] $_transformType
    hidden [object] $_findMatchesParameters

    [string] $TransformType
    [GlueMLTransformFindMatchesParameters] $FindMatchesParameters

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

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

Write-Verbose "Importing class 'GluePartitionSkewedInfo'"

class GluePartitionSkewedInfo : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSGluePartitionSkewedInfo'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-partition-skewedinfo.html'

    hidden [object] $_skewedColumnNames
    hidden [object] $_skewedColumnValues
    hidden [VSJson] $_skewedColumnValueLocationMaps

    [string[]] $SkewedColumnNames
    [string[]] $SkewedColumnValues
    [VSJson] $SkewedColumnValueLocationMaps

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name SkewedColumnNames -Value {
            $this._skewedColumnNames
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this._skewedColumnNames = @($value)
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name SkewedColumnValues -Value {
            $this._skewedColumnValues
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this._skewedColumnValues = @($value)
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name SkewedColumnValueLocationMaps -Value {
            $this._skewedColumnValueLocationMaps
        } -SecondValue {
            param([ValidateType(([string], [VSJson], [VSYaml], [psobject], [IDictionary]))][object] $value)
            $this._skewedColumnValueLocationMaps = [VSJson]::Transform($value)
            Write-Debug $this._skewedColumnValueLocationMaps
        }
    }

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

Write-Verbose "Importing class 'GlueCrawlerS3Target'"

class GlueCrawlerS3Target : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSGlueCrawlerS3Target'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-crawler-s3target.html'

    hidden [object] $_connectionName
    hidden [object] $_path
    hidden [object] $_exclusions

    [string] $ConnectionName
    [string] $Path
    [string[]] $Exclusions

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

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

Write-Verbose "Importing class 'GluePartitionSchemaId'"

class GluePartitionSchemaId : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSGluePartitionSchemaId'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-partition-schemaid.html'

    hidden [object] $_registryName
    hidden [object] $_schemaName
    hidden [object] $_schemaArn

    [string] $RegistryName
    [string] $SchemaName
    [string] $SchemaArn

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

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

Write-Verbose "Importing class 'GlueJobNotificationProperty'"

class GlueJobNotificationProperty : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSGlueJobNotificationProperty'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-job-notificationproperty.html'

    hidden [object] $_notifyDelayAfter

    [int] $NotifyDelayAfter

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

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

Write-Verbose "Importing class 'GlueJobExecutionProperty'"

class GlueJobExecutionProperty : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSGlueJobExecutionProperty'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-job-executionproperty.html'

    hidden [object] $_maxConcurrentRuns

    [double] $MaxConcurrentRuns

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

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

Write-Verbose "Importing class 'GlueCrawlerRecrawlPolicy'"

class GlueCrawlerRecrawlPolicy : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSGlueCrawlerRecrawlPolicy'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-crawler-recrawlpolicy.html'

    hidden [object] $_recrawlBehavior

    [string] $RecrawlBehavior

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

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

Write-Verbose "Importing class 'GlueTableSchemaReference'"

class GlueTableSchemaReference : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSGlueTableSchemaReference'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-table-schemareference.html'

    hidden [object] $_schemaVersionId
    hidden [object] $_schemaId
    hidden [object] $_schemaVersionNumber

    [string] $SchemaVersionId
    [GlueTableSchemaId] $SchemaId
    [int] $SchemaVersionNumber

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name SchemaVersionId -Value {
            $this._schemaVersionId
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._schemaVersionId = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name SchemaId -Value {
            $this._schemaId
        } -SecondValue {
            param([ValidateType(([GlueTableSchemaId], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._schemaId = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name SchemaVersionNumber -Value {
            $this._schemaVersionNumber
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._schemaVersionNumber = if ($cast = $value -as [int]) {
                $cast
            }
            else {
                $value
            }
        }
    }

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

Write-Verbose "Importing class 'GlueTableTableIdentifier'"

class GlueTableTableIdentifier : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSGlueTableTableIdentifier'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-glue-table-tableidentifier.html'

    hidden [object] $_databaseName
    hidden [object] $_catalogId
    hidden [object] $_name

    [string] $DatabaseName
    [string] $CatalogId
    [string] $Name

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

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

Write-Verbose "Importing class 'GlueDevEndpoint'"

class GlueDevEndpoint : VSResource {
    hidden [string] $_vsFunctionName = 'New-VSGlueDevEndpoint'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-glue-devendpoint.html'

    hidden [object] $_condition

    [string] $Type = 'AWS::Glue::DevEndpoint'
    [string] $ExtraJarsS3Path
    [string] $PublicKey
    [int] $NumberOfNodes
    [VSJson] $Arguments
    [string] $SubnetId
    [string[]] $PublicKeys
    [string[]] $SecurityGroupIds
    [string] $RoleArn
    [string] $WorkerType
    [string] $EndpointName
    [string] $GlueVersion
    [string] $ExtraPythonLibsS3Path
    [string] $SecurityConfiguration
    [int] $NumberOfWorkers
    [VSJson] $Tags
    [VSJson] $Metadata
    [UpdatePolicy] $UpdatePolicy
    [string] $Condition

    hidden [void] _addAccessors() {
        $this._addBaseAccessors()
        $this | Add-Member -Force -MemberType ScriptProperty -Name ExtraJarsS3Path -Value {
            $this.Properties['ExtraJarsS3Path']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['ExtraJarsS3Path'] = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name PublicKey -Value {
            $this.Properties['PublicKey']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['PublicKey'] = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name NumberOfNodes -Value {
            $this.Properties['NumberOfNodes']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['NumberOfNodes'] = if ($cast = $value -as [int]) {
                $cast
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Arguments -Value {
            $this.Properties['Arguments']
        } -SecondValue {
            param([ValidateType(([string], [VSJson], [VSYaml], [psobject], [IDictionary]))][object] $value)
            $this.Properties['Arguments'] = [VSJson]::Transform($value)
            Write-Debug $this.Properties['Arguments']
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name SubnetId -Value {
            $this.Properties['SubnetId']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['SubnetId'] = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name PublicKeys -Value {
            $this.Properties['PublicKeys']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this.Properties['PublicKeys'] = @($value)
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name SecurityGroupIds -Value {
            $this.Properties['SecurityGroupIds']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this.Properties['SecurityGroupIds'] = @($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 WorkerType -Value {
            $this.Properties['WorkerType']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['WorkerType'] = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name EndpointName -Value {
            $this.Properties['EndpointName']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['EndpointName'] = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name GlueVersion -Value {
            $this.Properties['GlueVersion']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['GlueVersion'] = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name ExtraPythonLibsS3Path -Value {
            $this.Properties['ExtraPythonLibsS3Path']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['ExtraPythonLibsS3Path'] = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name SecurityConfiguration -Value {
            $this.Properties['SecurityConfiguration']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['SecurityConfiguration'] = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name NumberOfWorkers -Value {
            $this.Properties['NumberOfWorkers']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['NumberOfWorkers'] = if ($cast = $value -as [int]) {
                $cast
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Tags -Value {
            $this.Properties['Tags']
        } -SecondValue {
            param([ValidateType(([string], [VSJson], [VSYaml], [psobject], [IDictionary]))][object] $value)
            $this.Properties['Tags'] = [VSJson]::Transform($value)
            Write-Debug $this.Properties['Tags']
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Condition -Value {
            $this._condition
        } -SecondValue {
            param(
                [ValidateType(([string], [IntrinsicFunction], [ConditionFunction]))] [object]
                $value
            )
            $this._condition = $value
        }
    }

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

Write-Verbose "Importing class 'GlueSchemaVersionMetadata'"

class GlueSchemaVersionMetadata : VSResource {
    hidden [string] $_vsFunctionName = 'New-VSGlueSchemaVersionMetadata'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-glue-schemaversionmetadata.html'

    hidden [object] $_condition

    [string] $Type = 'AWS::Glue::SchemaVersionMetadata'
    [string] $SchemaVersionId
    [string] $Key
    [string] $Value
    [VSJson] $Metadata
    [UpdatePolicy] $UpdatePolicy
    [string] $Condition

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

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

Write-Verbose "Importing class 'GlueMLTransform'"

class GlueMLTransform : VSResource {
    hidden [string] $_vsFunctionName = 'New-VSGlueMLTransform'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-glue-mltransform.html'

    hidden [object] $_condition

    [string] $Type = 'AWS::Glue::MLTransform'
    [int] $MaxRetries
    [string] $Description
    [GlueMLTransformTransformEncryption] $TransformEncryption
    [int] $Timeout
    [string] $Name
    [string] $Role
    [string] $WorkerType
    [string] $GlueVersion
    [GlueMLTransformTransformParameters] $TransformParameters
    [GlueMLTransformInputRecordTables] $InputRecordTables
    [int] $NumberOfWorkers
    [VSJson] $Tags
    [double] $MaxCapacity
    [VSJson] $Metadata
    [UpdatePolicy] $UpdatePolicy
    [string] $Condition

    hidden [void] _addAccessors() {
        $this._addBaseAccessors()
        $this | Add-Member -Force -MemberType ScriptProperty -Name MaxRetries -Value {
            $this.Properties['MaxRetries']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['MaxRetries'] = if ($cast = $value -as [int]) {
                $cast
            }
            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 TransformEncryption -Value {
            $this.Properties['TransformEncryption']
        } -SecondValue {
            param([ValidateType(([GlueMLTransformTransformEncryption], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['TransformEncryption'] = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Timeout -Value {
            $this.Properties['Timeout']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['Timeout'] = if ($cast = $value -as [int]) {
                $cast
            }
            else {
                $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 Role -Value {
            $this.Properties['Role']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['Role'] = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name WorkerType -Value {
            $this.Properties['WorkerType']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['WorkerType'] = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name GlueVersion -Value {
            $this.Properties['GlueVersion']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['GlueVersion'] = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name TransformParameters -Value {
            $this.Properties['TransformParameters']
        } -SecondValue {
            param([ValidateType(([GlueMLTransformTransformParameters], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['TransformParameters'] = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name InputRecordTables -Value {
            $this.Properties['InputRecordTables']
        } -SecondValue {
            param([ValidateType(([GlueMLTransformInputRecordTables], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['InputRecordTables'] = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name NumberOfWorkers -Value {
            $this.Properties['NumberOfWorkers']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['NumberOfWorkers'] = if ($cast = $value -as [int]) {
                $cast
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Tags -Value {
            $this.Properties['Tags']
        } -SecondValue {
            param([ValidateType(([string], [VSJson], [VSYaml], [psobject], [IDictionary]))][object] $value)
            $this.Properties['Tags'] = [VSJson]::Transform($value)
            Write-Debug $this.Properties['Tags']
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name MaxCapacity -Value {
            $this.Properties['MaxCapacity']
        } -SecondValue {
            param([ValidateType(([double], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['MaxCapacity'] = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Condition -Value {
            $this._condition
        } -SecondValue {
            param(
                [ValidateType(([string], [IntrinsicFunction], [ConditionFunction]))] [object]
                $value
            )
            $this._condition = $value
        }
    }

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

Write-Verbose "Importing class 'GlueConnection'"

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

    hidden [object] $_condition

    [string] $Type = 'AWS::Glue::Connection'
    [GlueConnectionConnectionInput] $ConnectionInput
    [string] $CatalogId
    [VSJson] $Metadata
    [UpdatePolicy] $UpdatePolicy
    [string] $Condition

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

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

Write-Verbose "Importing class 'GluePartition'"

class GluePartition : VSResource {
    hidden [string] $_vsFunctionName = 'New-VSGluePartition'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-glue-partition.html'

    hidden [object] $_condition

    [string] $Type = 'AWS::Glue::Partition'
    [string] $TableName
    [string] $DatabaseName
    [string] $CatalogId
    [GluePartitionPartitionInput] $PartitionInput
    [VSJson] $Metadata
    [UpdatePolicy] $UpdatePolicy
    [string] $Condition

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

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

Write-Verbose "Importing class 'GlueTrigger'"

class GlueTrigger : VSResource {
    hidden [string] $_vsFunctionName = 'New-VSGlueTrigger'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-glue-trigger.html'

    hidden [object] $_condition

    [string] $Type = 'AWS::Glue::Trigger'
    [string] $TriggerType
    [bool] $StartOnCreation
    [string] $Description
    [GlueTriggerAction[]] $Actions
    [string] $WorkflowName
    [string] $Schedule
    [VSJson] $Tags
    [string] $Name
    [GlueTriggerPredicate] $Predicate
    [VSJson] $Metadata
    [UpdatePolicy] $UpdatePolicy
    [string] $Condition

    hidden [void] _addAccessors() {
        $this._addBaseAccessors()
        $this | Add-Member -Force -MemberType ScriptProperty -Name TriggerType -Value {
            $this.Properties['TriggerType']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['TriggerType'] = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name StartOnCreation -Value {
            $this.Properties['StartOnCreation']
        } -SecondValue {
            param([ValidateType(([bool], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['StartOnCreation'] = $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 Actions -Value {
            $this.Properties['Actions']
        } -SecondValue {
            param([ValidateType(([GlueTriggerAction], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this.Properties['Actions'] = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name WorkflowName -Value {
            $this.Properties['WorkflowName']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['WorkflowName'] = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Schedule -Value {
            $this.Properties['Schedule']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['Schedule'] = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Tags -Value {
            $this.Properties['Tags']
        } -SecondValue {
            param([ValidateType(([string], [VSJson], [VSYaml], [psobject], [IDictionary]))][object] $value)
            $this.Properties['Tags'] = [VSJson]::Transform($value)
            Write-Debug $this.Properties['Tags']
        }
        $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 Predicate -Value {
            $this.Properties['Predicate']
        } -SecondValue {
            param([ValidateType(([GlueTriggerPredicate], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['Predicate'] = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Condition -Value {
            $this._condition
        } -SecondValue {
            param(
                [ValidateType(([string], [IntrinsicFunction], [ConditionFunction]))] [object]
                $value
            )
            $this._condition = $value
        }
    }

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

Write-Verbose "Importing class 'GlueSecurityConfiguration'"

class GlueSecurityConfiguration : VSResource {
    hidden [string] $_vsFunctionName = 'New-VSGlueSecurityConfiguration'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-glue-securityconfiguration.html'

    hidden [object] $_condition

    [string] $Type = 'AWS::Glue::SecurityConfiguration'
    [GlueSecurityConfigurationEncryptionConfiguration] $EncryptionConfiguration
    [string] $Name
    [VSJson] $Metadata
    [UpdatePolicy] $UpdatePolicy
    [string] $Condition

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

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

Write-Verbose "Importing class 'GlueSchemaVersion'"

class GlueSchemaVersion : VSResource {
    hidden [string] $_vsFunctionName = 'New-VSGlueSchemaVersion'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-glue-schemaversion.html'

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

    [string] $Type = 'AWS::Glue::SchemaVersion'
    [GlueSchemaVersionSchema] $Schema
    [string] $SchemaDefinition
    [VSJson] $Metadata
    [UpdatePolicy] $UpdatePolicy
    [string] $Condition

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

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

Write-Verbose "Importing class 'GlueDataCatalogEncryptionSettings'"

class GlueDataCatalogEncryptionSettings : VSResource {
    hidden [string] $_vsFunctionName = 'New-VSGlueDataCatalogEncryptionSettings'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-glue-datacatalogencryptionsettings.html'

    hidden [object] $_condition

    [string] $Type = 'AWS::Glue::DataCatalogEncryptionSettings'
    [GlueDataCatalogEncryptionSettingsDataCatalogEncryptionSettings] $DataCatalogEncryptionSettings
    [string] $CatalogId
    [VSJson] $Metadata
    [UpdatePolicy] $UpdatePolicy
    [string] $Condition

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

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

Write-Verbose "Importing class 'GlueWorkflow'"

class GlueWorkflow : VSResource {
    hidden [string] $_vsFunctionName = 'New-VSGlueWorkflow'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-glue-workflow.html'

    hidden [object] $_condition

    [string] $Type = 'AWS::Glue::Workflow'
    [string] $Description
    [VSJson] $DefaultRunProperties
    [VSJson] $Tags
    [string] $Name
    [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 DefaultRunProperties -Value {
            $this.Properties['DefaultRunProperties']
        } -SecondValue {
            param([ValidateType(([string], [VSJson], [VSYaml], [psobject], [IDictionary]))][object] $value)
            $this.Properties['DefaultRunProperties'] = [VSJson]::Transform($value)
            Write-Debug $this.Properties['DefaultRunProperties']
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Tags -Value {
            $this.Properties['Tags']
        } -SecondValue {
            param([ValidateType(([string], [VSJson], [VSYaml], [psobject], [IDictionary]))][object] $value)
            $this.Properties['Tags'] = [VSJson]::Transform($value)
            Write-Debug $this.Properties['Tags']
        }
        $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
        }
    }

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

Write-Verbose "Importing class 'GlueJob'"

class GlueJob : VSResource {
    hidden [string] $_vsFunctionName = 'New-VSGlueJob'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-glue-job.html'

    hidden [object] $_condition

    [string] $Type = 'AWS::Glue::Job'
    [GlueJobConnectionsList] $Connections
    [double] $MaxRetries
    [string] $Description
    [int] $Timeout
    [double] $AllocatedCapacity
    [string] $Name
    [string] $Role
    [VSJson] $DefaultArguments
    [GlueJobNotificationProperty] $NotificationProperty
    [string] $WorkerType
    [string] $LogUri
    [GlueJobJobCommand] $Command
    [string] $GlueVersion
    [GlueJobExecutionProperty] $ExecutionProperty
    [string] $SecurityConfiguration
    [int] $NumberOfWorkers
    [VSJson] $Tags
    [double] $MaxCapacity
    [VSJson] $Metadata
    [UpdatePolicy] $UpdatePolicy
    [string] $Condition

    hidden [void] _addAccessors() {
        $this._addBaseAccessors()
        $this | Add-Member -Force -MemberType ScriptProperty -Name Connections -Value {
            $this.Properties['Connections']
        } -SecondValue {
            param([ValidateType(([GlueJobConnectionsList], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['Connections'] = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name MaxRetries -Value {
            $this.Properties['MaxRetries']
        } -SecondValue {
            param([ValidateType(([double], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['MaxRetries'] = $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 Timeout -Value {
            $this.Properties['Timeout']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['Timeout'] = if ($cast = $value -as [int]) {
                $cast
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name AllocatedCapacity -Value {
            $this.Properties['AllocatedCapacity']
        } -SecondValue {
            param([ValidateType(([double], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['AllocatedCapacity'] = $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 Role -Value {
            $this.Properties['Role']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['Role'] = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name DefaultArguments -Value {
            $this.Properties['DefaultArguments']
        } -SecondValue {
            param([ValidateType(([string], [VSJson], [VSYaml], [psobject], [IDictionary]))][object] $value)
            $this.Properties['DefaultArguments'] = [VSJson]::Transform($value)
            Write-Debug $this.Properties['DefaultArguments']
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name NotificationProperty -Value {
            $this.Properties['NotificationProperty']
        } -SecondValue {
            param([ValidateType(([GlueJobNotificationProperty], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['NotificationProperty'] = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name WorkerType -Value {
            $this.Properties['WorkerType']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['WorkerType'] = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name LogUri -Value {
            $this.Properties['LogUri']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['LogUri'] = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Command -Value {
            $this.Properties['Command']
        } -SecondValue {
            param([ValidateType(([GlueJobJobCommand], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['Command'] = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name GlueVersion -Value {
            $this.Properties['GlueVersion']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['GlueVersion'] = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name ExecutionProperty -Value {
            $this.Properties['ExecutionProperty']
        } -SecondValue {
            param([ValidateType(([GlueJobExecutionProperty], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['ExecutionProperty'] = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name SecurityConfiguration -Value {
            $this.Properties['SecurityConfiguration']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['SecurityConfiguration'] = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name NumberOfWorkers -Value {
            $this.Properties['NumberOfWorkers']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['NumberOfWorkers'] = if ($cast = $value -as [int]) {
                $cast
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Tags -Value {
            $this.Properties['Tags']
        } -SecondValue {
            param([ValidateType(([string], [VSJson], [VSYaml], [psobject], [IDictionary]))][object] $value)
            $this.Properties['Tags'] = [VSJson]::Transform($value)
            Write-Debug $this.Properties['Tags']
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name MaxCapacity -Value {
            $this.Properties['MaxCapacity']
        } -SecondValue {
            param([ValidateType(([double], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['MaxCapacity'] = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Condition -Value {
            $this._condition
        } -SecondValue {
            param(
                [ValidateType(([string], [IntrinsicFunction], [ConditionFunction]))] [object]
                $value
            )
            $this._condition = $value
        }
    }

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

Write-Verbose "Importing class 'GlueDatabase'"

class GlueDatabase : VSResource {
    hidden [string] $_vsFunctionName = 'New-VSGlueDatabase'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-glue-database.html'

    hidden [object] $_condition

    [string] $Type = 'AWS::Glue::Database'
    [GlueDatabaseDatabaseInput] $DatabaseInput
    [string] $CatalogId
    [VSJson] $Metadata
    [UpdatePolicy] $UpdatePolicy
    [string] $Condition

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

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

Write-Verbose "Importing class 'GlueCrawler'"

class GlueCrawler : VSResource {
    hidden [string] $_vsFunctionName = 'New-VSGlueCrawler'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-glue-crawler.html'

    hidden [object] $_condition

    [string] $Type = 'AWS::Glue::Crawler'
    [string[]] $Classifiers
    [string] $Description
    [GlueCrawlerSchemaChangePolicy] $SchemaChangePolicy
    [string] $Configuration
    [GlueCrawlerRecrawlPolicy] $RecrawlPolicy
    [string] $DatabaseName
    [GlueCrawlerTargets] $Targets
    [string] $CrawlerSecurityConfiguration
    [string] $Name
    [string] $Role
    [GlueCrawlerSchedule] $Schedule
    [string] $TablePrefix
    [VSJson] $Tags
    [VSJson] $Metadata
    [UpdatePolicy] $UpdatePolicy
    [string] $Condition

    hidden [void] _addAccessors() {
        $this._addBaseAccessors()
        $this | Add-Member -Force -MemberType ScriptProperty -Name Classifiers -Value {
            $this.Properties['Classifiers']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this.Properties['Classifiers'] = @($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 SchemaChangePolicy -Value {
            $this.Properties['SchemaChangePolicy']
        } -SecondValue {
            param([ValidateType(([GlueCrawlerSchemaChangePolicy], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['SchemaChangePolicy'] = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Configuration -Value {
            $this.Properties['Configuration']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['Configuration'] = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name RecrawlPolicy -Value {
            $this.Properties['RecrawlPolicy']
        } -SecondValue {
            param([ValidateType(([GlueCrawlerRecrawlPolicy], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['RecrawlPolicy'] = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name DatabaseName -Value {
            $this.Properties['DatabaseName']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['DatabaseName'] = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Targets -Value {
            $this.Properties['Targets']
        } -SecondValue {
            param([ValidateType(([GlueCrawlerTargets], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['Targets'] = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name CrawlerSecurityConfiguration -Value {
            $this.Properties['CrawlerSecurityConfiguration']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['CrawlerSecurityConfiguration'] = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $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 Role -Value {
            $this.Properties['Role']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['Role'] = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Schedule -Value {
            $this.Properties['Schedule']
        } -SecondValue {
            param([ValidateType(([GlueCrawlerSchedule], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['Schedule'] = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name TablePrefix -Value {
            $this.Properties['TablePrefix']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['TablePrefix'] = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Tags -Value {
            $this.Properties['Tags']
        } -SecondValue {
            param([ValidateType(([string], [VSJson], [VSYaml], [psobject], [IDictionary]))][object] $value)
            $this.Properties['Tags'] = [VSJson]::Transform($value)
            Write-Debug $this.Properties['Tags']
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Condition -Value {
            $this._condition
        } -SecondValue {
            param(
                [ValidateType(([string], [IntrinsicFunction], [ConditionFunction]))] [object]
                $value
            )
            $this._condition = $value
        }
    }

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

Write-Verbose "Importing class 'GlueClassifier'"

class GlueClassifier : VSResource {
    hidden [string] $_vsFunctionName = 'New-VSGlueClassifier'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-glue-classifier.html'

    hidden [object] $_condition

    [string] $Type = 'AWS::Glue::Classifier'
    [GlueClassifierXMLClassifier] $XMLClassifier
    [GlueClassifierJsonClassifier] $JsonClassifier
    [GlueClassifierCsvClassifier] $CsvClassifier
    [GlueClassifierGrokClassifier] $GrokClassifier
    [VSJson] $Metadata
    [UpdatePolicy] $UpdatePolicy
    [string] $Condition

    hidden [void] _addAccessors() {
        $this._addBaseAccessors()
        $this | Add-Member -Force -MemberType ScriptProperty -Name XMLClassifier -Value {
            $this.Properties['XMLClassifier']
        } -SecondValue {
            param([ValidateType(([GlueClassifierXMLClassifier], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['XMLClassifier'] = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name JsonClassifier -Value {
            $this.Properties['JsonClassifier']
        } -SecondValue {
            param([ValidateType(([GlueClassifierJsonClassifier], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['JsonClassifier'] = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name CsvClassifier -Value {
            $this.Properties['CsvClassifier']
        } -SecondValue {
            param([ValidateType(([GlueClassifierCsvClassifier], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['CsvClassifier'] = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name GrokClassifier -Value {
            $this.Properties['GrokClassifier']
        } -SecondValue {
            param([ValidateType(([GlueClassifierGrokClassifier], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['GrokClassifier'] = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Condition -Value {
            $this._condition
        } -SecondValue {
            param(
                [ValidateType(([string], [IntrinsicFunction], [ConditionFunction]))] [object]
                $value
            )
            $this._condition = $value
        }
    }

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

Write-Verbose "Importing class 'GlueSchema'"

class GlueSchema : VSResource {
    hidden [string] $_vsFunctionName = 'New-VSGlueSchema'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-glue-schema.html'

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

    [string] $Type = 'AWS::Glue::Schema'
    [GlueSchemaRegistry] $Registry
    [string] $Name
    [string] $Description
    [string] $DataFormat
    [string] $Compatibility
    [string] $SchemaDefinition
    [GlueSchemaSchemaVersion] $CheckpointVersion
    [VSTag[]] $Tags
    [VSJson] $Metadata
    [UpdatePolicy] $UpdatePolicy
    [string] $Condition

    hidden [void] _addAccessors() {
        $this._addBaseAccessors()
        $this | Add-Member -Force -MemberType ScriptProperty -Name Registry -Value {
            $this.Properties['Registry']
        } -SecondValue {
            param([ValidateType(([GlueSchemaRegistry], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['Registry'] = $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 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 DataFormat -Value {
            $this.Properties['DataFormat']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['DataFormat'] = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Compatibility -Value {
            $this.Properties['Compatibility']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['Compatibility'] = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name SchemaDefinition -Value {
            $this.Properties['SchemaDefinition']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['SchemaDefinition'] = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name CheckpointVersion -Value {
            $this.Properties['CheckpointVersion']
        } -SecondValue {
            param([ValidateType(([GlueSchemaSchemaVersion], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['CheckpointVersion'] = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Tags -Value {
            $this.Properties['Tags']
        } -SecondValue {
            param([TransformTag()] [ValidateType(([IDictionary], [psobject], [VSTag]))] [object] $value)
            $this.Properties['Tags'] = [VSTag]::TransformTag($value)
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Condition -Value {
            $this._condition
        } -SecondValue {
            param(
                [ValidateType(([string], [IntrinsicFunction], [ConditionFunction]))] [object]
                $value
            )
            $this._condition = $value
        }
    }

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

Write-Verbose "Importing class 'GlueTable'"

class GlueTable : VSResource {
    hidden [string] $_vsFunctionName = 'New-VSGlueTable'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-glue-table.html'

    hidden [object] $_condition

    [string] $Type = 'AWS::Glue::Table'
    [GlueTableTableInput] $TableInput
    [string] $DatabaseName
    [string] $CatalogId
    [VSJson] $Metadata
    [UpdatePolicy] $UpdatePolicy
    [string] $Condition

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

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

Write-Verbose "Importing class 'GlueRegistry'"

class GlueRegistry : VSResource {
    hidden [string] $_vsFunctionName = 'New-VSGlueRegistry'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-glue-registry.html'

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

    [string] $Type = 'AWS::Glue::Registry'
    [string] $Name
    [string] $Description
    [VSTag[]] $Tags
    [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 Tags -Value {
            $this.Properties['Tags']
        } -SecondValue {
            param([TransformTag()] [ValidateType(([IDictionary], [psobject], [VSTag]))] [object] $value)
            $this.Properties['Tags'] = [VSTag]::TransformTag($value)
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Condition -Value {
            $this._condition
        } -SecondValue {
            param(
                [ValidateType(([string], [IntrinsicFunction], [ConditionFunction]))] [object]
                $value
            )
            $this._condition = $value
        }
    }

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