VaporShell.IoTAnalytics

3.0.0-beta20211124r1

VaporShell.IoTAnalytics.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 'IoTAnalyticsDatasetDatasetContentVersionValue'"

class IoTAnalyticsDatasetDatasetContentVersionValue : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSIoTAnalyticsDatasetDatasetContentVersionValue'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iotanalytics-dataset-variable-datasetcontentversionvalue.html'

    hidden [object] $_datasetName

    [string] $DatasetName

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

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

Write-Verbose "Importing class 'IoTAnalyticsPipelineDeviceShadowEnrich'"

class IoTAnalyticsPipelineDeviceShadowEnrich : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSIoTAnalyticsPipelineDeviceShadowEnrich'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iotanalytics-pipeline-deviceshadowenrich.html'

    hidden [object] $_attribute
    hidden [object] $_next
    hidden [object] $_thingName
    hidden [object] $_roleArn
    hidden [object] $_name

    [string] $Attribute
    [string] $Next
    [string] $ThingName
    [string] $RoleArn
    [string] $Name

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

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

Write-Verbose "Importing class 'IoTAnalyticsDatasetGlueConfiguration'"

class IoTAnalyticsDatasetGlueConfiguration : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSIoTAnalyticsDatasetGlueConfiguration'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iotanalytics-dataset-glueconfiguration.html'

    hidden [object] $_tableName
    hidden [object] $_databaseName

    [string] $TableName
    [string] $DatabaseName

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

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

Write-Verbose "Importing class 'IoTAnalyticsDatasetDeltaTimeSessionWindowConfiguration'"

class IoTAnalyticsDatasetDeltaTimeSessionWindowConfiguration : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSIoTAnalyticsDatasetDeltaTimeSessionWindowConfiguration'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iotanalytics-dataset-deltatimesessionwindowconfiguration.html'

    hidden [object] $_timeoutInMinutes

    [int] $TimeoutInMinutes

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

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

Write-Verbose "Importing class 'IoTAnalyticsDatasetOutputFileUriValue'"

class IoTAnalyticsDatasetOutputFileUriValue : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSIoTAnalyticsDatasetOutputFileUriValue'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iotanalytics-dataset-variable-outputfileurivalue.html'

    hidden [object] $_fileName

    [string] $FileName

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

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

Write-Verbose "Importing class 'IoTAnalyticsDatasetFilter'"

class IoTAnalyticsDatasetFilter : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSIoTAnalyticsDatasetFilter'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iotanalytics-dataset-filter.html'

    hidden [object] $_deltaTime

    [IoTAnalyticsDatasetDeltaTime] $DeltaTime

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

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

Write-Verbose "Importing class 'IoTAnalyticsDatastoreIotSiteWiseMultiLayerStorage'"

class IoTAnalyticsDatastoreIotSiteWiseMultiLayerStorage : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSIoTAnalyticsDatastoreIotSiteWiseMultiLayerStorage'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iotanalytics-datastore-iotsitewisemultilayerstorage.html'

    hidden [object] $_customerManagedS3Storage

    [IoTAnalyticsDatastoreCustomerManagedS3Storage] $CustomerManagedS3Storage

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

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

Write-Verbose "Importing class 'IoTAnalyticsPipelineSelectAttributes'"

class IoTAnalyticsPipelineSelectAttributes : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSIoTAnalyticsPipelineSelectAttributes'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iotanalytics-pipeline-selectattributes.html'

    hidden [object] $_next
    hidden [object] $_attributes
    hidden [object] $_name

    [string] $Next
    [string[]] $Attributes
    [string] $Name

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

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

Write-Verbose "Importing class 'IoTAnalyticsDatastoreFileFormatConfiguration'"

class IoTAnalyticsDatastoreFileFormatConfiguration : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSIoTAnalyticsDatastoreFileFormatConfiguration'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iotanalytics-datastore-fileformatconfiguration.html'

    hidden [object] $_parquetConfiguration
    hidden [object] $_jsonConfiguration

    [IoTAnalyticsDatastoreParquetConfiguration] $ParquetConfiguration
    [IoTAnalyticsDatastoreJsonConfiguration] $JsonConfiguration

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name ParquetConfiguration -Value {
            $this._parquetConfiguration
        } -SecondValue {
            param([ValidateType(([IoTAnalyticsDatastoreParquetConfiguration], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._parquetConfiguration = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name JsonConfiguration -Value {
            $this._jsonConfiguration
        } -SecondValue {
            param([ValidateType(([IoTAnalyticsDatastoreJsonConfiguration], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._jsonConfiguration = $value
        }
    }

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

Write-Verbose "Importing class 'IoTAnalyticsDatasetDatasetContentDeliveryRule'"

class IoTAnalyticsDatasetDatasetContentDeliveryRule : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSIoTAnalyticsDatasetDatasetContentDeliveryRule'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iotanalytics-dataset-datasetcontentdeliveryrule.html'

    hidden [object] $_destination
    hidden [object] $_entryName

    [IoTAnalyticsDatasetDatasetContentDeliveryRuleDestination] $Destination
    [string] $EntryName

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

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

Write-Verbose "Importing class 'IoTAnalyticsDatastoreServiceManagedS3'"

class IoTAnalyticsDatastoreServiceManagedS3 : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSIoTAnalyticsDatastoreServiceManagedS3'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iotanalytics-datastore-servicemanageds3.html'



    hidden [void] _addAccessors() {
    }

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

Write-Verbose "Importing class 'IoTAnalyticsDatasetAction'"

class IoTAnalyticsDatasetAction : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSIoTAnalyticsDatasetAction'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iotanalytics-dataset-action.html'

    hidden [object] $_actionName
    hidden [object] $_containerAction
    hidden [object] $_queryAction

    [string] $ActionName
    [IoTAnalyticsDatasetContainerAction] $ContainerAction
    [IoTAnalyticsDatasetQueryAction] $QueryAction

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name ActionName -Value {
            $this._actionName
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._actionName = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name ContainerAction -Value {
            $this._containerAction
        } -SecondValue {
            param([ValidateType(([IoTAnalyticsDatasetContainerAction], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._containerAction = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name QueryAction -Value {
            $this._queryAction
        } -SecondValue {
            param([ValidateType(([IoTAnalyticsDatasetQueryAction], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._queryAction = $value
        }
    }

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

Write-Verbose "Importing class 'IoTAnalyticsDatasetLateDataRuleConfiguration'"

class IoTAnalyticsDatasetLateDataRuleConfiguration : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSIoTAnalyticsDatasetLateDataRuleConfiguration'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iotanalytics-dataset-latedataruleconfiguration.html'

    hidden [object] $_deltaTimeSessionWindowConfiguration

    [IoTAnalyticsDatasetDeltaTimeSessionWindowConfiguration] $DeltaTimeSessionWindowConfiguration

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

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

Write-Verbose "Importing class 'IoTAnalyticsDatasetContainerAction'"

class IoTAnalyticsDatasetContainerAction : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSIoTAnalyticsDatasetContainerAction'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iotanalytics-dataset-containeraction.html'

    hidden [object] $_variables
    hidden [object] $_executionRoleArn
    hidden [object] $_image
    hidden [object] $_resourceConfiguration

    [IoTAnalyticsDatasetVariable[]] $Variables
    [string] $ExecutionRoleArn
    [string] $Image
    [IoTAnalyticsDatasetResourceConfiguration] $ResourceConfiguration

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name Variables -Value {
            $this._variables
        } -SecondValue {
            param([ValidateType(([IoTAnalyticsDatasetVariable], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this._variables = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name ExecutionRoleArn -Value {
            $this._executionRoleArn
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._executionRoleArn = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Image -Value {
            $this._image
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._image = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name ResourceConfiguration -Value {
            $this._resourceConfiguration
        } -SecondValue {
            param([ValidateType(([IoTAnalyticsDatasetResourceConfiguration], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._resourceConfiguration = $value
        }
    }

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

Write-Verbose "Importing class 'IoTAnalyticsDatasetLateDataRule'"

class IoTAnalyticsDatasetLateDataRule : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSIoTAnalyticsDatasetLateDataRule'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iotanalytics-dataset-latedatarule.html'

    hidden [object] $_ruleConfiguration
    hidden [object] $_ruleName

    [IoTAnalyticsDatasetLateDataRuleConfiguration] $RuleConfiguration
    [string] $RuleName

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

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

Write-Verbose "Importing class 'IoTAnalyticsDatastoreRetentionPeriod'"

class IoTAnalyticsDatastoreRetentionPeriod : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSIoTAnalyticsDatastoreRetentionPeriod'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iotanalytics-datastore-retentionperiod.html'

    hidden [object] $_numberOfDays
    hidden [object] $_unlimited

    [int] $NumberOfDays
    [bool] $Unlimited

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

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

Write-Verbose "Importing class 'IoTAnalyticsDatasetQueryAction'"

class IoTAnalyticsDatasetQueryAction : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSIoTAnalyticsDatasetQueryAction'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iotanalytics-dataset-queryaction.html'

    hidden [object] $_filters
    hidden [object] $_sqlQuery

    [IoTAnalyticsDatasetFilter[]] $Filters
    [string] $SqlQuery

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

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

Write-Verbose "Importing class 'IoTAnalyticsChannelCustomerManagedS3'"

class IoTAnalyticsChannelCustomerManagedS3 : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSIoTAnalyticsChannelCustomerManagedS3'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iotanalytics-channel-customermanageds3.html'

    hidden [object] $_bucket
    hidden [object] $_roleArn
    hidden [object] $_keyPrefix

    [string] $Bucket
    [string] $RoleArn
    [string] $KeyPrefix

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

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

Write-Verbose "Importing class 'IoTAnalyticsDatasetDatasetContentDeliveryRuleDestination'"

class IoTAnalyticsDatasetDatasetContentDeliveryRuleDestination : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSIoTAnalyticsDatasetDatasetContentDeliveryRuleDestination'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iotanalytics-dataset-datasetcontentdeliveryruledestination.html'

    hidden [object] $_iotEventsDestinationConfiguration
    hidden [object] $_s3DestinationConfiguration

    [IoTAnalyticsDatasetIotEventsDestinationConfiguration] $IotEventsDestinationConfiguration
    [IoTAnalyticsDatasetS3DestinationConfiguration] $S3DestinationConfiguration

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name IotEventsDestinationConfiguration -Value {
            $this._iotEventsDestinationConfiguration
        } -SecondValue {
            param([ValidateType(([IoTAnalyticsDatasetIotEventsDestinationConfiguration], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._iotEventsDestinationConfiguration = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name S3DestinationConfiguration -Value {
            $this._s3DestinationConfiguration
        } -SecondValue {
            param([ValidateType(([IoTAnalyticsDatasetS3DestinationConfiguration], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._s3DestinationConfiguration = $value
        }
    }

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

Write-Verbose "Importing class 'IoTAnalyticsPipelineRemoveAttributes'"

class IoTAnalyticsPipelineRemoveAttributes : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSIoTAnalyticsPipelineRemoveAttributes'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iotanalytics-pipeline-removeattributes.html'

    hidden [object] $_next
    hidden [object] $_attributes
    hidden [object] $_name

    [string] $Next
    [string[]] $Attributes
    [string] $Name

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

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

Write-Verbose "Importing class 'IoTAnalyticsDatasetVersioningConfiguration'"

class IoTAnalyticsDatasetVersioningConfiguration : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSIoTAnalyticsDatasetVersioningConfiguration'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iotanalytics-dataset-versioningconfiguration.html'

    hidden [object] $_maxVersions
    hidden [object] $_unlimited

    [int] $MaxVersions
    [bool] $Unlimited

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

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

Write-Verbose "Importing class 'IoTAnalyticsPipelineDatastore'"

class IoTAnalyticsPipelineDatastore : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSIoTAnalyticsPipelineDatastore'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iotanalytics-pipeline-datastore.html'

    hidden [object] $_datastoreName
    hidden [object] $_name

    [string] $DatastoreName
    [string] $Name

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

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

Write-Verbose "Importing class 'IoTAnalyticsDatastoreCustomerManagedS3'"

class IoTAnalyticsDatastoreCustomerManagedS3 : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSIoTAnalyticsDatastoreCustomerManagedS3'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iotanalytics-datastore-customermanageds3.html'

    hidden [object] $_bucket
    hidden [object] $_roleArn
    hidden [object] $_keyPrefix

    [string] $Bucket
    [string] $RoleArn
    [string] $KeyPrefix

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

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

Write-Verbose "Importing class 'IoTAnalyticsDatasetSchedule'"

class IoTAnalyticsDatasetSchedule : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSIoTAnalyticsDatasetSchedule'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iotanalytics-dataset-trigger-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
            }
        }
    }

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

Write-Verbose "Importing class 'IoTAnalyticsPipelineDeviceRegistryEnrich'"

class IoTAnalyticsPipelineDeviceRegistryEnrich : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSIoTAnalyticsPipelineDeviceRegistryEnrich'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iotanalytics-pipeline-deviceregistryenrich.html'

    hidden [object] $_attribute
    hidden [object] $_next
    hidden [object] $_thingName
    hidden [object] $_roleArn
    hidden [object] $_name

    [string] $Attribute
    [string] $Next
    [string] $ThingName
    [string] $RoleArn
    [string] $Name

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

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

Write-Verbose "Importing class 'IoTAnalyticsChannelRetentionPeriod'"

class IoTAnalyticsChannelRetentionPeriod : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSIoTAnalyticsChannelRetentionPeriod'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iotanalytics-channel-retentionperiod.html'

    hidden [object] $_numberOfDays
    hidden [object] $_unlimited

    [int] $NumberOfDays
    [bool] $Unlimited

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

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

Write-Verbose "Importing class 'IoTAnalyticsDatasetRetentionPeriod'"

class IoTAnalyticsDatasetRetentionPeriod : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSIoTAnalyticsDatasetRetentionPeriod'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iotanalytics-dataset-retentionperiod.html'

    hidden [object] $_numberOfDays
    hidden [object] $_unlimited

    [int] $NumberOfDays
    [bool] $Unlimited

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

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

Write-Verbose "Importing class 'IoTAnalyticsDatasetS3DestinationConfiguration'"

class IoTAnalyticsDatasetS3DestinationConfiguration : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSIoTAnalyticsDatasetS3DestinationConfiguration'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iotanalytics-dataset-s3destinationconfiguration.html'

    hidden [object] $_glueConfiguration
    hidden [object] $_bucket
    hidden [object] $_key
    hidden [object] $_roleArn

    [IoTAnalyticsDatasetGlueConfiguration] $GlueConfiguration
    [string] $Bucket
    [string] $Key
    [string] $RoleArn

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

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

Write-Verbose "Importing class 'IoTAnalyticsDatastoreDatastorePartitions'"

class IoTAnalyticsDatastoreDatastorePartitions : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSIoTAnalyticsDatastoreDatastorePartitions'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iotanalytics-datastore-datastorepartitions.html'

    hidden [object] $_partitions

    [IoTAnalyticsDatastoreDatastorePartition[]] $Partitions

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

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

Write-Verbose "Importing class 'IoTAnalyticsChannelServiceManagedS3'"

class IoTAnalyticsChannelServiceManagedS3 : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSIoTAnalyticsChannelServiceManagedS3'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iotanalytics-channel-servicemanageds3.html'



    hidden [void] _addAccessors() {
    }

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

Write-Verbose "Importing class 'IoTAnalyticsDatastoreSchemaDefinition'"

class IoTAnalyticsDatastoreSchemaDefinition : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSIoTAnalyticsDatastoreSchemaDefinition'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iotanalytics-datastore-schemadefinition.html'

    hidden [object] $_columns

    [IoTAnalyticsDatastoreColumn[]] $Columns

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

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

Write-Verbose "Importing class 'IoTAnalyticsPipelineLambda'"

class IoTAnalyticsPipelineLambda : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSIoTAnalyticsPipelineLambda'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iotanalytics-pipeline-lambda.html'

    hidden [object] $_batchSize
    hidden [object] $_next
    hidden [object] $_lambdaName
    hidden [object] $_name

    [int] $BatchSize
    [string] $Next
    [string] $LambdaName
    [string] $Name

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

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

Write-Verbose "Importing class 'IoTAnalyticsDatastoreColumn'"

class IoTAnalyticsDatastoreColumn : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSIoTAnalyticsDatastoreColumn'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iotanalytics-datastore-column.html'

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

    [string] $Type
    [string] $Name

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

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

Write-Verbose "Importing class 'IoTAnalyticsDatasetVariable'"

class IoTAnalyticsDatasetVariable : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSIoTAnalyticsDatasetVariable'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iotanalytics-dataset-variable.html'

    hidden [object] $_datasetContentVersionValue
    hidden [object] $_doubleValue
    hidden [object] $_outputFileUriValue
    hidden [object] $_variableName
    hidden [object] $_stringValue

    [IoTAnalyticsDatasetDatasetContentVersionValue] $DatasetContentVersionValue
    [double] $DoubleValue
    [IoTAnalyticsDatasetOutputFileUriValue] $OutputFileUriValue
    [string] $VariableName
    [string] $StringValue

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name DatasetContentVersionValue -Value {
            $this._datasetContentVersionValue
        } -SecondValue {
            param([ValidateType(([IoTAnalyticsDatasetDatasetContentVersionValue], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._datasetContentVersionValue = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name DoubleValue -Value {
            $this._doubleValue
        } -SecondValue {
            param([ValidateType(([double], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._doubleValue = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name OutputFileUriValue -Value {
            $this._outputFileUriValue
        } -SecondValue {
            param([ValidateType(([IoTAnalyticsDatasetOutputFileUriValue], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._outputFileUriValue = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name VariableName -Value {
            $this._variableName
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._variableName = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name StringValue -Value {
            $this._stringValue
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._stringValue = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
    }

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

Write-Verbose "Importing class 'IoTAnalyticsDatastoreParquetConfiguration'"

class IoTAnalyticsDatastoreParquetConfiguration : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSIoTAnalyticsDatastoreParquetConfiguration'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iotanalytics-datastore-parquetconfiguration.html'

    hidden [object] $_schemaDefinition

    [IoTAnalyticsDatastoreSchemaDefinition] $SchemaDefinition

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

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

Write-Verbose "Importing class 'IoTAnalyticsDatasetDeltaTime'"

class IoTAnalyticsDatasetDeltaTime : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSIoTAnalyticsDatasetDeltaTime'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iotanalytics-dataset-deltatime.html'

    hidden [object] $_timeExpression
    hidden [object] $_offsetSeconds

    [string] $TimeExpression
    [int] $OffsetSeconds

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

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

Write-Verbose "Importing class 'IoTAnalyticsDatastoreDatastoreStorage'"

class IoTAnalyticsDatastoreDatastoreStorage : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSIoTAnalyticsDatastoreDatastoreStorage'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iotanalytics-datastore-datastorestorage.html'

    hidden [object] $_customerManagedS3
    hidden [object] $_serviceManagedS3
    hidden [object] $_iotSiteWiseMultiLayerStorage

    [IoTAnalyticsDatastoreCustomerManagedS3] $CustomerManagedS3
    [IoTAnalyticsDatastoreServiceManagedS3] $ServiceManagedS3
    [IoTAnalyticsDatastoreIotSiteWiseMultiLayerStorage] $IotSiteWiseMultiLayerStorage

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name CustomerManagedS3 -Value {
            $this._customerManagedS3
        } -SecondValue {
            param([ValidateType(([IoTAnalyticsDatastoreCustomerManagedS3], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._customerManagedS3 = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name ServiceManagedS3 -Value {
            $this._serviceManagedS3
        } -SecondValue {
            param([ValidateType(([IoTAnalyticsDatastoreServiceManagedS3], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._serviceManagedS3 = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name IotSiteWiseMultiLayerStorage -Value {
            $this._iotSiteWiseMultiLayerStorage
        } -SecondValue {
            param([ValidateType(([IoTAnalyticsDatastoreIotSiteWiseMultiLayerStorage], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._iotSiteWiseMultiLayerStorage = $value
        }
    }

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

Write-Verbose "Importing class 'IoTAnalyticsDatasetTrigger'"

class IoTAnalyticsDatasetTrigger : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSIoTAnalyticsDatasetTrigger'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iotanalytics-dataset-trigger.html'

    hidden [object] $_schedule
    hidden [object] $_triggeringDataset

    [IoTAnalyticsDatasetSchedule] $Schedule
    [IoTAnalyticsDatasetTriggeringDataset] $TriggeringDataset

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name Schedule -Value {
            $this._schedule
        } -SecondValue {
            param([ValidateType(([IoTAnalyticsDatasetSchedule], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._schedule = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name TriggeringDataset -Value {
            $this._triggeringDataset
        } -SecondValue {
            param([ValidateType(([IoTAnalyticsDatasetTriggeringDataset], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._triggeringDataset = $value
        }
    }

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

Write-Verbose "Importing class 'IoTAnalyticsPipelineChannel'"

class IoTAnalyticsPipelineChannel : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSIoTAnalyticsPipelineChannel'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iotanalytics-pipeline-channel.html'

    hidden [object] $_channelName
    hidden [object] $_next
    hidden [object] $_name

    [string] $ChannelName
    [string] $Next
    [string] $Name

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

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

Write-Verbose "Importing class 'IoTAnalyticsPipelineFilter'"

class IoTAnalyticsPipelineFilter : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSIoTAnalyticsPipelineFilter'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iotanalytics-pipeline-filter.html'

    hidden [object] $_filter
    hidden [object] $_next
    hidden [object] $_name

    [string] $Filter
    [string] $Next
    [string] $Name

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

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

Write-Verbose "Importing class 'IoTAnalyticsDatasetIotEventsDestinationConfiguration'"

class IoTAnalyticsDatasetIotEventsDestinationConfiguration : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSIoTAnalyticsDatasetIotEventsDestinationConfiguration'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iotanalytics-dataset-ioteventsdestinationconfiguration.html'

    hidden [object] $_inputName
    hidden [object] $_roleArn

    [string] $InputName
    [string] $RoleArn

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

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

Write-Verbose "Importing class 'IoTAnalyticsDatastoreCustomerManagedS3Storage'"

class IoTAnalyticsDatastoreCustomerManagedS3Storage : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSIoTAnalyticsDatastoreCustomerManagedS3Storage'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iotanalytics-datastore-customermanageds3storage.html'

    hidden [object] $_bucket
    hidden [object] $_keyPrefix

    [string] $Bucket
    [string] $KeyPrefix

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

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

Write-Verbose "Importing class 'IoTAnalyticsChannelChannelStorage'"

class IoTAnalyticsChannelChannelStorage : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSIoTAnalyticsChannelChannelStorage'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iotanalytics-channel-channelstorage.html'

    hidden [object] $_customerManagedS3
    hidden [object] $_serviceManagedS3

    [IoTAnalyticsChannelCustomerManagedS3] $CustomerManagedS3
    [IoTAnalyticsChannelServiceManagedS3] $ServiceManagedS3

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name CustomerManagedS3 -Value {
            $this._customerManagedS3
        } -SecondValue {
            param([ValidateType(([IoTAnalyticsChannelCustomerManagedS3], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._customerManagedS3 = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name ServiceManagedS3 -Value {
            $this._serviceManagedS3
        } -SecondValue {
            param([ValidateType(([IoTAnalyticsChannelServiceManagedS3], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._serviceManagedS3 = $value
        }
    }

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

Write-Verbose "Importing class 'IoTAnalyticsPipelineActivity'"

class IoTAnalyticsPipelineActivity : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSIoTAnalyticsPipelineActivity'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iotanalytics-pipeline-activity.html'

    hidden [object] $_selectAttributes
    hidden [object] $_datastore
    hidden [object] $_filter
    hidden [object] $_addAttributes
    hidden [object] $_channel
    hidden [object] $_deviceShadowEnrich
    hidden [object] $_math
    hidden [object] $_lambda
    hidden [object] $_deviceRegistryEnrich
    hidden [object] $_removeAttributes

    [IoTAnalyticsPipelineSelectAttributes] $SelectAttributes
    [IoTAnalyticsPipelineDatastore] $Datastore
    [IoTAnalyticsPipelineFilter] $Filter
    [IoTAnalyticsPipelineAddAttributes] $AddAttributes
    [IoTAnalyticsPipelineChannel] $Channel
    [IoTAnalyticsPipelineDeviceShadowEnrich] $DeviceShadowEnrich
    [IoTAnalyticsPipelineMath] $Math
    [IoTAnalyticsPipelineLambda] $Lambda
    [IoTAnalyticsPipelineDeviceRegistryEnrich] $DeviceRegistryEnrich
    [IoTAnalyticsPipelineRemoveAttributes] $RemoveAttributes

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name SelectAttributes -Value {
            $this._selectAttributes
        } -SecondValue {
            param([ValidateType(([IoTAnalyticsPipelineSelectAttributes], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._selectAttributes = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Datastore -Value {
            $this._datastore
        } -SecondValue {
            param([ValidateType(([IoTAnalyticsPipelineDatastore], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._datastore = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Filter -Value {
            $this._filter
        } -SecondValue {
            param([ValidateType(([IoTAnalyticsPipelineFilter], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._filter = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name AddAttributes -Value {
            $this._addAttributes
        } -SecondValue {
            param([ValidateType(([IoTAnalyticsPipelineAddAttributes], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._addAttributes = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Channel -Value {
            $this._channel
        } -SecondValue {
            param([ValidateType(([IoTAnalyticsPipelineChannel], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._channel = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name DeviceShadowEnrich -Value {
            $this._deviceShadowEnrich
        } -SecondValue {
            param([ValidateType(([IoTAnalyticsPipelineDeviceShadowEnrich], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._deviceShadowEnrich = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Math -Value {
            $this._math
        } -SecondValue {
            param([ValidateType(([IoTAnalyticsPipelineMath], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._math = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Lambda -Value {
            $this._lambda
        } -SecondValue {
            param([ValidateType(([IoTAnalyticsPipelineLambda], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._lambda = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name DeviceRegistryEnrich -Value {
            $this._deviceRegistryEnrich
        } -SecondValue {
            param([ValidateType(([IoTAnalyticsPipelineDeviceRegistryEnrich], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._deviceRegistryEnrich = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name RemoveAttributes -Value {
            $this._removeAttributes
        } -SecondValue {
            param([ValidateType(([IoTAnalyticsPipelineRemoveAttributes], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._removeAttributes = $value
        }
    }

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

Write-Verbose "Importing class 'IoTAnalyticsDatastorePartition'"

class IoTAnalyticsDatastorePartition : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSIoTAnalyticsDatastorePartition'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iotanalytics-datastore-partition.html'

    hidden [object] $_attributeName

    [string] $AttributeName

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

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

Write-Verbose "Importing class 'IoTAnalyticsDatastoreDatastorePartition'"

class IoTAnalyticsDatastoreDatastorePartition : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSIoTAnalyticsDatastoreDatastorePartition'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iotanalytics-datastore-datastorepartition.html'

    hidden [object] $_partition
    hidden [object] $_timestampPartition

    [IoTAnalyticsDatastorePartition] $Partition
    [IoTAnalyticsDatastoreTimestampPartition] $TimestampPartition

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name Partition -Value {
            $this._partition
        } -SecondValue {
            param([ValidateType(([IoTAnalyticsDatastorePartition], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._partition = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name TimestampPartition -Value {
            $this._timestampPartition
        } -SecondValue {
            param([ValidateType(([IoTAnalyticsDatastoreTimestampPartition], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._timestampPartition = $value
        }
    }

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

Write-Verbose "Importing class 'IoTAnalyticsPipelineMath'"

class IoTAnalyticsPipelineMath : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSIoTAnalyticsPipelineMath'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iotanalytics-pipeline-math.html'

    hidden [object] $_attribute
    hidden [object] $_next
    hidden [object] $_math
    hidden [object] $_name

    [string] $Attribute
    [string] $Next
    [string] $Math
    [string] $Name

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

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

Write-Verbose "Importing class 'IoTAnalyticsDatasetResourceConfiguration'"

class IoTAnalyticsDatasetResourceConfiguration : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSIoTAnalyticsDatasetResourceConfiguration'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iotanalytics-dataset-resourceconfiguration.html'

    hidden [object] $_volumeSizeInGB
    hidden [object] $_computeType

    [int] $VolumeSizeInGB
    [string] $ComputeType

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

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

Write-Verbose "Importing class 'IoTAnalyticsDatasetTriggeringDataset'"

class IoTAnalyticsDatasetTriggeringDataset : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSIoTAnalyticsDatasetTriggeringDataset'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iotanalytics-dataset-triggeringdataset.html'

    hidden [object] $_datasetName

    [string] $DatasetName

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

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

Write-Verbose "Importing class 'IoTAnalyticsPipelineAddAttributes'"

class IoTAnalyticsPipelineAddAttributes : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSIoTAnalyticsPipelineAddAttributes'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iotanalytics-pipeline-addattributes.html'

    hidden [object] $_next
    hidden [VSJson] $_attributes
    hidden [object] $_name

    [string] $Next
    [VSJson] $Attributes
    [string] $Name

    hidden [void] _addAccessors() {
        $this | Add-Member -Force -MemberType ScriptProperty -Name Next -Value {
            $this._next
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this._next = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Attributes -Value {
            $this._attributes
        } -SecondValue {
            param([ValidateType(([string], [VSJson], [VSYaml], [psobject], [IDictionary]))][object] $value)
            $this._attributes = [VSJson]::Transform($value)
            Write-Debug $this._attributes
        }
        $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
            }
        }
    }

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

Write-Verbose "Importing class 'IoTAnalyticsDatastoreTimestampPartition'"

class IoTAnalyticsDatastoreTimestampPartition : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSIoTAnalyticsDatastoreTimestampPartition'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iotanalytics-datastore-timestamppartition.html'

    hidden [object] $_attributeName
    hidden [object] $_timestampFormat

    [string] $AttributeName
    [string] $TimestampFormat

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

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

Write-Verbose "Importing class 'IoTAnalyticsDatastoreJsonConfiguration'"

class IoTAnalyticsDatastoreJsonConfiguration : VSResourceProperty {
    hidden [string] $_vsFunctionName = 'Add-VSIoTAnalyticsDatastoreJsonConfiguration'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iotanalytics-datastore-jsonconfiguration.html'



    hidden [void] _addAccessors() {
    }

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

Write-Verbose "Importing class 'IoTAnalyticsChannel'"

class IoTAnalyticsChannel : VSResource {
    hidden [string] $_vsFunctionName = 'New-VSIoTAnalyticsChannel'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iotanalytics-channel.html'

    hidden [object] $_condition

    [string] $Type = 'AWS::IoTAnalytics::Channel'
    [string] $ChannelName
    [IoTAnalyticsChannelChannelStorage] $ChannelStorage
    [IoTAnalyticsChannelRetentionPeriod] $RetentionPeriod
    [VSTag[]] $Tags
    [VSJson] $Metadata
    [UpdatePolicy] $UpdatePolicy
    [string] $Condition

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

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

Write-Verbose "Importing class 'IoTAnalyticsDatastore'"

class IoTAnalyticsDatastore : VSResource {
    hidden [string] $_vsFunctionName = 'New-VSIoTAnalyticsDatastore'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iotanalytics-datastore.html'

    hidden [object] $_condition

    [string] $Type = 'AWS::IoTAnalytics::Datastore'
    [IoTAnalyticsDatastoreDatastoreStorage] $DatastoreStorage
    [IoTAnalyticsDatastoreFileFormatConfiguration] $FileFormatConfiguration
    [IoTAnalyticsDatastoreDatastorePartitions] $DatastorePartitions
    [string] $DatastoreName
    [IoTAnalyticsDatastoreRetentionPeriod] $RetentionPeriod
    [VSTag[]] $Tags
    [VSJson] $Metadata
    [UpdatePolicy] $UpdatePolicy
    [string] $Condition

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

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

Write-Verbose "Importing class 'IoTAnalyticsDataset'"

class IoTAnalyticsDataset : VSResource {
    hidden [string] $_vsFunctionName = 'New-VSIoTAnalyticsDataset'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iotanalytics-dataset.html'

    hidden [object] $_condition

    [string] $Type = 'AWS::IoTAnalytics::Dataset'
    [IoTAnalyticsDatasetAction[]] $Actions
    [IoTAnalyticsDatasetLateDataRule[]] $LateDataRules
    [string] $DatasetName
    [IoTAnalyticsDatasetDatasetContentDeliveryRule[]] $ContentDeliveryRules
    [IoTAnalyticsDatasetTrigger[]] $Triggers
    [IoTAnalyticsDatasetVersioningConfiguration] $VersioningConfiguration
    [IoTAnalyticsDatasetRetentionPeriod] $RetentionPeriod
    [VSTag[]] $Tags
    [VSJson] $Metadata
    [UpdatePolicy] $UpdatePolicy
    [string] $Condition

    hidden [void] _addAccessors() {
        $this._addBaseAccessors()
        $this | Add-Member -Force -MemberType ScriptProperty -Name Actions -Value {
            $this.Properties['Actions']
        } -SecondValue {
            param([ValidateType(([IoTAnalyticsDatasetAction], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this.Properties['Actions'] = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name LateDataRules -Value {
            $this.Properties['LateDataRules']
        } -SecondValue {
            param([ValidateType(([IoTAnalyticsDatasetLateDataRule], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this.Properties['LateDataRules'] = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name DatasetName -Value {
            $this.Properties['DatasetName']
        } -SecondValue {
            param([ValidateType(([string], [int], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['DatasetName'] = if ($value -is [int]) {
                $value.ToString()
            }
            else {
                $value
            }
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name ContentDeliveryRules -Value {
            $this.Properties['ContentDeliveryRules']
        } -SecondValue {
            param([ValidateType(([IoTAnalyticsDatasetDatasetContentDeliveryRule], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this.Properties['ContentDeliveryRules'] = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name Triggers -Value {
            $this.Properties['Triggers']
        } -SecondValue {
            param([ValidateType(([IoTAnalyticsDatasetTrigger], [IntrinsicFunction], [ConditionFunction]))] [object[]] $value)
            $this.Properties['Triggers'] = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name VersioningConfiguration -Value {
            $this.Properties['VersioningConfiguration']
        } -SecondValue {
            param([ValidateType(([IoTAnalyticsDatasetVersioningConfiguration], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['VersioningConfiguration'] = $value
        }
        $this | Add-Member -Force -MemberType ScriptProperty -Name RetentionPeriod -Value {
            $this.Properties['RetentionPeriod']
        } -SecondValue {
            param([ValidateType(([IoTAnalyticsDatasetRetentionPeriod], [string], [IntrinsicFunction], [ConditionFunction]))] [object] $value)
            $this.Properties['RetentionPeriod'] = $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
        }
    }

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

Write-Verbose "Importing class 'IoTAnalyticsPipeline'"

class IoTAnalyticsPipeline : VSResource {
    hidden [string] $_vsFunctionName = 'New-VSIoTAnalyticsPipeline'
    hidden [string] $_awsDocumentation = 'http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iotanalytics-pipeline.html'

    hidden [object] $_condition

    [string] $Type = 'AWS::IoTAnalytics::Pipeline'
    [string] $PipelineName
    [VSTag[]] $Tags
    [IoTAnalyticsPipelineActivity[]] $PipelineActivities
    [VSJson] $Metadata
    [UpdatePolicy] $UpdatePolicy
    [string] $Condition

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

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