// THIS FILE IS AUTOMATICALLY GENERATED by https://github.com/swift-aws/aws-sdk-swift/blob/master/CodeGenerator/Sources/CodeGenerator/main.swift. DO NOT EDIT.

import Foundation
import AWSSDKSwiftCore

extension KinesisAnalyticsV2 {

    public struct AddApplicationCloudWatchLoggingOptionRequest: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "ApplicationName", required: true, type: .string), 
            AWSShapeMember(label: "CloudWatchLoggingOption", required: true, type: .structure), 
            AWSShapeMember(label: "CurrentApplicationVersionId", required: true, type: .long)
        ]

        /// The Kinesis Data Analytics application name.
        public let applicationName: String
        /// Provides the Amazon CloudWatch log stream Amazon Resource Name (ARN). 
        public let cloudWatchLoggingOption: CloudWatchLoggingOption
        /// The version ID of the Kinesis Data Analytics application. You can retrieve the application version ID using DescribeApplication.
        public let currentApplicationVersionId: Int64

        public init(applicationName: String, cloudWatchLoggingOption: CloudWatchLoggingOption, currentApplicationVersionId: Int64) {
            self.applicationName = applicationName
            self.cloudWatchLoggingOption = cloudWatchLoggingOption
            self.currentApplicationVersionId = currentApplicationVersionId
        }

        public func validate(name: String) throws {
            try validate(applicationName, name:"applicationName", parent: name, max: 128)
            try validate(applicationName, name:"applicationName", parent: name, min: 1)
            try validate(applicationName, name:"applicationName", parent: name, pattern: "[a-zA-Z0-9_.-]+")
            try cloudWatchLoggingOption.validate(name: "\(name).cloudWatchLoggingOption")
            try validate(currentApplicationVersionId, name:"currentApplicationVersionId", parent: name, max: 999999999)
            try validate(currentApplicationVersionId, name:"currentApplicationVersionId", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case applicationName = "ApplicationName"
            case cloudWatchLoggingOption = "CloudWatchLoggingOption"
            case currentApplicationVersionId = "CurrentApplicationVersionId"
        }
    }

    public struct AddApplicationCloudWatchLoggingOptionResponse: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "ApplicationARN", required: false, type: .string), 
            AWSShapeMember(label: "ApplicationVersionId", required: false, type: .long), 
            AWSShapeMember(label: "CloudWatchLoggingOptionDescriptions", required: false, type: .list)
        ]

        /// The application's ARN.
        public let applicationARN: String?
        /// The new version ID of the Kinesis Data Analytics application. Kinesis Data Analytics updates the ApplicationVersionId each time you change the CloudWatch logging options. 
        public let applicationVersionId: Int64?
        /// The descriptions of the current CloudWatch logging options for the Kinesis Data Analytics application.
        public let cloudWatchLoggingOptionDescriptions: [CloudWatchLoggingOptionDescription]?

        public init(applicationARN: String? = nil, applicationVersionId: Int64? = nil, cloudWatchLoggingOptionDescriptions: [CloudWatchLoggingOptionDescription]? = nil) {
            self.applicationARN = applicationARN
            self.applicationVersionId = applicationVersionId
            self.cloudWatchLoggingOptionDescriptions = cloudWatchLoggingOptionDescriptions
        }

        private enum CodingKeys: String, CodingKey {
            case applicationARN = "ApplicationARN"
            case applicationVersionId = "ApplicationVersionId"
            case cloudWatchLoggingOptionDescriptions = "CloudWatchLoggingOptionDescriptions"
        }
    }

    public struct AddApplicationInputProcessingConfigurationRequest: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "ApplicationName", required: true, type: .string), 
            AWSShapeMember(label: "CurrentApplicationVersionId", required: true, type: .long), 
            AWSShapeMember(label: "InputId", required: true, type: .string), 
            AWSShapeMember(label: "InputProcessingConfiguration", required: true, type: .structure)
        ]

        /// The name of the application to which you want to add the input processing configuration.
        public let applicationName: String
        /// The version of the application to which you want to add the input processing configuration. You can use the DescribeApplication operation to get the current application version. If the version specified is not the current version, the ConcurrentModificationException is returned.
        public let currentApplicationVersionId: Int64
        /// The ID of the input configuration to add the input processing configuration to. You can get a list of the input IDs for an application using the DescribeApplication operation.
        public let inputId: String
        /// The InputProcessingConfiguration to add to the application.
        public let inputProcessingConfiguration: InputProcessingConfiguration

        public init(applicationName: String, currentApplicationVersionId: Int64, inputId: String, inputProcessingConfiguration: InputProcessingConfiguration) {
            self.applicationName = applicationName
            self.currentApplicationVersionId = currentApplicationVersionId
            self.inputId = inputId
            self.inputProcessingConfiguration = inputProcessingConfiguration
        }

        public func validate(name: String) throws {
            try validate(applicationName, name:"applicationName", parent: name, max: 128)
            try validate(applicationName, name:"applicationName", parent: name, min: 1)
            try validate(applicationName, name:"applicationName", parent: name, pattern: "[a-zA-Z0-9_.-]+")
            try validate(currentApplicationVersionId, name:"currentApplicationVersionId", parent: name, max: 999999999)
            try validate(currentApplicationVersionId, name:"currentApplicationVersionId", parent: name, min: 1)
            try validate(inputId, name:"inputId", parent: name, max: 50)
            try validate(inputId, name:"inputId", parent: name, min: 1)
            try validate(inputId, name:"inputId", parent: name, pattern: "[a-zA-Z0-9_.-]+")
            try inputProcessingConfiguration.validate(name: "\(name).inputProcessingConfiguration")
        }

        private enum CodingKeys: String, CodingKey {
            case applicationName = "ApplicationName"
            case currentApplicationVersionId = "CurrentApplicationVersionId"
            case inputId = "InputId"
            case inputProcessingConfiguration = "InputProcessingConfiguration"
        }
    }

    public struct AddApplicationInputProcessingConfigurationResponse: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "ApplicationARN", required: false, type: .string), 
            AWSShapeMember(label: "ApplicationVersionId", required: false, type: .long), 
            AWSShapeMember(label: "InputId", required: false, type: .string), 
            AWSShapeMember(label: "InputProcessingConfigurationDescription", required: false, type: .structure)
        ]

        /// The Amazon Resource Name (ARN) of the application.
        public let applicationARN: String?
        /// Provides the current application version.
        public let applicationVersionId: Int64?
        /// The input ID that is associated with the application input. This is the ID that Amazon Kinesis Data Analytics assigns to each input configuration that you add to your application.
        public let inputId: String?
        /// The description of the preprocessor that executes on records in this input before the application's code is run.
        public let inputProcessingConfigurationDescription: InputProcessingConfigurationDescription?

        public init(applicationARN: String? = nil, applicationVersionId: Int64? = nil, inputId: String? = nil, inputProcessingConfigurationDescription: InputProcessingConfigurationDescription? = nil) {
            self.applicationARN = applicationARN
            self.applicationVersionId = applicationVersionId
            self.inputId = inputId
            self.inputProcessingConfigurationDescription = inputProcessingConfigurationDescription
        }

        private enum CodingKeys: String, CodingKey {
            case applicationARN = "ApplicationARN"
            case applicationVersionId = "ApplicationVersionId"
            case inputId = "InputId"
            case inputProcessingConfigurationDescription = "InputProcessingConfigurationDescription"
        }
    }

    public struct AddApplicationInputRequest: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "ApplicationName", required: true, type: .string), 
            AWSShapeMember(label: "CurrentApplicationVersionId", required: true, type: .long), 
            AWSShapeMember(label: "Input", required: true, type: .structure)
        ]

        /// The name of your existing application to which you want to add the streaming source.
        public let applicationName: String
        /// The current version of your application. You can use the DescribeApplication operation to find the current application version.
        public let currentApplicationVersionId: Int64
        /// The Input to add.
        public let input: Input

        public init(applicationName: String, currentApplicationVersionId: Int64, input: Input) {
            self.applicationName = applicationName
            self.currentApplicationVersionId = currentApplicationVersionId
            self.input = input
        }

        public func validate(name: String) throws {
            try validate(applicationName, name:"applicationName", parent: name, max: 128)
            try validate(applicationName, name:"applicationName", parent: name, min: 1)
            try validate(applicationName, name:"applicationName", parent: name, pattern: "[a-zA-Z0-9_.-]+")
            try validate(currentApplicationVersionId, name:"currentApplicationVersionId", parent: name, max: 999999999)
            try validate(currentApplicationVersionId, name:"currentApplicationVersionId", parent: name, min: 1)
            try input.validate(name: "\(name).input")
        }

        private enum CodingKeys: String, CodingKey {
            case applicationName = "ApplicationName"
            case currentApplicationVersionId = "CurrentApplicationVersionId"
            case input = "Input"
        }
    }

    public struct AddApplicationInputResponse: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "ApplicationARN", required: false, type: .string), 
            AWSShapeMember(label: "ApplicationVersionId", required: false, type: .long), 
            AWSShapeMember(label: "InputDescriptions", required: false, type: .list)
        ]

        /// The Amazon Resource Name (ARN) of the application.
        public let applicationARN: String?
        /// Provides the current application version.
        public let applicationVersionId: Int64?
        /// Describes the application input configuration. 
        public let inputDescriptions: [InputDescription]?

        public init(applicationARN: String? = nil, applicationVersionId: Int64? = nil, inputDescriptions: [InputDescription]? = nil) {
            self.applicationARN = applicationARN
            self.applicationVersionId = applicationVersionId
            self.inputDescriptions = inputDescriptions
        }

        private enum CodingKeys: String, CodingKey {
            case applicationARN = "ApplicationARN"
            case applicationVersionId = "ApplicationVersionId"
            case inputDescriptions = "InputDescriptions"
        }
    }

    public struct AddApplicationOutputRequest: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "ApplicationName", required: true, type: .string), 
            AWSShapeMember(label: "CurrentApplicationVersionId", required: true, type: .long), 
            AWSShapeMember(label: "Output", required: true, type: .structure)
        ]

        /// The name of the application to which you want to add the output configuration.
        public let applicationName: String
        /// The version of the application to which you want to add the output configuration. You can use the DescribeApplication operation to get the current application version. If the version specified is not the current version, the ConcurrentModificationException is returned. 
        public let currentApplicationVersionId: Int64
        /// An array of objects, each describing one output configuration. In the output configuration, you specify the name of an in-application stream, a destination (that is, a Kinesis data stream, a Kinesis Data Firehose delivery stream, or an AWS Lambda function), and record the formation to use when writing to the destination.
        public let output: Output

        public init(applicationName: String, currentApplicationVersionId: Int64, output: Output) {
            self.applicationName = applicationName
            self.currentApplicationVersionId = currentApplicationVersionId
            self.output = output
        }

        public func validate(name: String) throws {
            try validate(applicationName, name:"applicationName", parent: name, max: 128)
            try validate(applicationName, name:"applicationName", parent: name, min: 1)
            try validate(applicationName, name:"applicationName", parent: name, pattern: "[a-zA-Z0-9_.-]+")
            try validate(currentApplicationVersionId, name:"currentApplicationVersionId", parent: name, max: 999999999)
            try validate(currentApplicationVersionId, name:"currentApplicationVersionId", parent: name, min: 1)
            try output.validate(name: "\(name).output")
        }

        private enum CodingKeys: String, CodingKey {
            case applicationName = "ApplicationName"
            case currentApplicationVersionId = "CurrentApplicationVersionId"
            case output = "Output"
        }
    }

    public struct AddApplicationOutputResponse: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "ApplicationARN", required: false, type: .string), 
            AWSShapeMember(label: "ApplicationVersionId", required: false, type: .long), 
            AWSShapeMember(label: "OutputDescriptions", required: false, type: .list)
        ]

        /// The application Amazon Resource Name (ARN).
        public let applicationARN: String?
        /// The updated application version ID. Kinesis Data Analytics increments this ID when the application is updated.
        public let applicationVersionId: Int64?
        /// Describes the application output configuration. For more information, see Configuring Application Output. 
        public let outputDescriptions: [OutputDescription]?

        public init(applicationARN: String? = nil, applicationVersionId: Int64? = nil, outputDescriptions: [OutputDescription]? = nil) {
            self.applicationARN = applicationARN
            self.applicationVersionId = applicationVersionId
            self.outputDescriptions = outputDescriptions
        }

        private enum CodingKeys: String, CodingKey {
            case applicationARN = "ApplicationARN"
            case applicationVersionId = "ApplicationVersionId"
            case outputDescriptions = "OutputDescriptions"
        }
    }

    public struct AddApplicationReferenceDataSourceRequest: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "ApplicationName", required: true, type: .string), 
            AWSShapeMember(label: "CurrentApplicationVersionId", required: true, type: .long), 
            AWSShapeMember(label: "ReferenceDataSource", required: true, type: .structure)
        ]

        /// The name of an existing application.
        public let applicationName: String
        /// The version of the application for which you are adding the reference data source. You can use the DescribeApplication operation to get the current application version. If the version specified is not the current version, the ConcurrentModificationException is returned.
        public let currentApplicationVersionId: Int64
        /// The reference data source can be an object in your Amazon S3 bucket. Kinesis Data Analytics reads the object and copies the data into the in-application table that is created. You provide an S3 bucket, object key name, and the resulting in-application table that is created. 
        public let referenceDataSource: ReferenceDataSource

        public init(applicationName: String, currentApplicationVersionId: Int64, referenceDataSource: ReferenceDataSource) {
            self.applicationName = applicationName
            self.currentApplicationVersionId = currentApplicationVersionId
            self.referenceDataSource = referenceDataSource
        }

        public func validate(name: String) throws {
            try validate(applicationName, name:"applicationName", parent: name, max: 128)
            try validate(applicationName, name:"applicationName", parent: name, min: 1)
            try validate(applicationName, name:"applicationName", parent: name, pattern: "[a-zA-Z0-9_.-]+")
            try validate(currentApplicationVersionId, name:"currentApplicationVersionId", parent: name, max: 999999999)
            try validate(currentApplicationVersionId, name:"currentApplicationVersionId", parent: name, min: 1)
            try referenceDataSource.validate(name: "\(name).referenceDataSource")
        }

        private enum CodingKeys: String, CodingKey {
            case applicationName = "ApplicationName"
            case currentApplicationVersionId = "CurrentApplicationVersionId"
            case referenceDataSource = "ReferenceDataSource"
        }
    }

    public struct AddApplicationReferenceDataSourceResponse: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "ApplicationARN", required: false, type: .string), 
            AWSShapeMember(label: "ApplicationVersionId", required: false, type: .long), 
            AWSShapeMember(label: "ReferenceDataSourceDescriptions", required: false, type: .list)
        ]

        /// The application Amazon Resource Name (ARN).
        public let applicationARN: String?
        /// The updated application version ID. Amazon Kinesis Data Analytics increments this ID when the application is updated.
        public let applicationVersionId: Int64?
        /// Describes reference data sources configured for the application. 
        public let referenceDataSourceDescriptions: [ReferenceDataSourceDescription]?

        public init(applicationARN: String? = nil, applicationVersionId: Int64? = nil, referenceDataSourceDescriptions: [ReferenceDataSourceDescription]? = nil) {
            self.applicationARN = applicationARN
            self.applicationVersionId = applicationVersionId
            self.referenceDataSourceDescriptions = referenceDataSourceDescriptions
        }

        private enum CodingKeys: String, CodingKey {
            case applicationARN = "ApplicationARN"
            case applicationVersionId = "ApplicationVersionId"
            case referenceDataSourceDescriptions = "ReferenceDataSourceDescriptions"
        }
    }

    public struct ApplicationCodeConfiguration: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "CodeContent", required: false, type: .structure), 
            AWSShapeMember(label: "CodeContentType", required: true, type: .enum)
        ]

        /// The location and type of the application code.
        public let codeContent: CodeContent?
        /// Specifies whether the code content is in text or zip format.
        public let codeContentType: CodeContentType

        public init(codeContent: CodeContent? = nil, codeContentType: CodeContentType) {
            self.codeContent = codeContent
            self.codeContentType = codeContentType
        }

        public func validate(name: String) throws {
            try codeContent?.validate(name: "\(name).codeContent")
        }

        private enum CodingKeys: String, CodingKey {
            case codeContent = "CodeContent"
            case codeContentType = "CodeContentType"
        }
    }

    public struct ApplicationCodeConfigurationDescription: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "CodeContentDescription", required: false, type: .structure), 
            AWSShapeMember(label: "CodeContentType", required: true, type: .enum)
        ]

        /// Describes details about the location and format of the application code.
        public let codeContentDescription: CodeContentDescription?
        /// Specifies whether the code content is in text or zip format.
        public let codeContentType: CodeContentType

        public init(codeContentDescription: CodeContentDescription? = nil, codeContentType: CodeContentType) {
            self.codeContentDescription = codeContentDescription
            self.codeContentType = codeContentType
        }

        private enum CodingKeys: String, CodingKey {
            case codeContentDescription = "CodeContentDescription"
            case codeContentType = "CodeContentType"
        }
    }

    public struct ApplicationCodeConfigurationUpdate: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "CodeContentTypeUpdate", required: false, type: .enum), 
            AWSShapeMember(label: "CodeContentUpdate", required: false, type: .structure)
        ]

        /// Describes updates to the code content type.
        public let codeContentTypeUpdate: CodeContentType?
        /// Describes updates to the code content of an application.
        public let codeContentUpdate: CodeContentUpdate?

        public init(codeContentTypeUpdate: CodeContentType? = nil, codeContentUpdate: CodeContentUpdate? = nil) {
            self.codeContentTypeUpdate = codeContentTypeUpdate
            self.codeContentUpdate = codeContentUpdate
        }

        public func validate(name: String) throws {
            try codeContentUpdate?.validate(name: "\(name).codeContentUpdate")
        }

        private enum CodingKeys: String, CodingKey {
            case codeContentTypeUpdate = "CodeContentTypeUpdate"
            case codeContentUpdate = "CodeContentUpdate"
        }
    }

    public struct ApplicationConfiguration: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "ApplicationCodeConfiguration", required: true, type: .structure), 
            AWSShapeMember(label: "ApplicationSnapshotConfiguration", required: false, type: .structure), 
            AWSShapeMember(label: "EnvironmentProperties", required: false, type: .structure), 
            AWSShapeMember(label: "FlinkApplicationConfiguration", required: false, type: .structure), 
            AWSShapeMember(label: "SqlApplicationConfiguration", required: false, type: .structure)
        ]

        /// The code location and type parameters for a Java-based Kinesis Data Analytics application.
        public let applicationCodeConfiguration: ApplicationCodeConfiguration
        /// Describes whether snapshots are enabled for a Java-based Kinesis Data Analytics application.
        public let applicationSnapshotConfiguration: ApplicationSnapshotConfiguration?
        /// Describes execution properties for a Java-based Kinesis Data Analytics application.
        public let environmentProperties: EnvironmentProperties?
        /// The creation and update parameters for a Java-based Kinesis Data Analytics application.
        public let flinkApplicationConfiguration: FlinkApplicationConfiguration?
        /// The creation and update parameters for an SQL-based Kinesis Data Analytics application.
        public let sqlApplicationConfiguration: SqlApplicationConfiguration?

        public init(applicationCodeConfiguration: ApplicationCodeConfiguration, applicationSnapshotConfiguration: ApplicationSnapshotConfiguration? = nil, environmentProperties: EnvironmentProperties? = nil, flinkApplicationConfiguration: FlinkApplicationConfiguration? = nil, sqlApplicationConfiguration: SqlApplicationConfiguration? = nil) {
            self.applicationCodeConfiguration = applicationCodeConfiguration
            self.applicationSnapshotConfiguration = applicationSnapshotConfiguration
            self.environmentProperties = environmentProperties
            self.flinkApplicationConfiguration = flinkApplicationConfiguration
            self.sqlApplicationConfiguration = sqlApplicationConfiguration
        }

        public func validate(name: String) throws {
            try applicationCodeConfiguration.validate(name: "\(name).applicationCodeConfiguration")
            try environmentProperties?.validate(name: "\(name).environmentProperties")
            try flinkApplicationConfiguration?.validate(name: "\(name).flinkApplicationConfiguration")
            try sqlApplicationConfiguration?.validate(name: "\(name).sqlApplicationConfiguration")
        }

        private enum CodingKeys: String, CodingKey {
            case applicationCodeConfiguration = "ApplicationCodeConfiguration"
            case applicationSnapshotConfiguration = "ApplicationSnapshotConfiguration"
            case environmentProperties = "EnvironmentProperties"
            case flinkApplicationConfiguration = "FlinkApplicationConfiguration"
            case sqlApplicationConfiguration = "SqlApplicationConfiguration"
        }
    }

    public struct ApplicationConfigurationDescription: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "ApplicationCodeConfigurationDescription", required: false, type: .structure), 
            AWSShapeMember(label: "ApplicationSnapshotConfigurationDescription", required: false, type: .structure), 
            AWSShapeMember(label: "EnvironmentPropertyDescriptions", required: false, type: .structure), 
            AWSShapeMember(label: "FlinkApplicationConfigurationDescription", required: false, type: .structure), 
            AWSShapeMember(label: "RunConfigurationDescription", required: false, type: .structure), 
            AWSShapeMember(label: "SqlApplicationConfigurationDescription", required: false, type: .structure)
        ]

        /// The details about the application code for a Java-based Kinesis Data Analytics application.
        public let applicationCodeConfigurationDescription: ApplicationCodeConfigurationDescription?
        /// Describes whether snapshots are enabled for a Java-based Kinesis Data Analytics application.
        public let applicationSnapshotConfigurationDescription: ApplicationSnapshotConfigurationDescription?
        /// Describes execution properties for a Java-based Kinesis Data Analytics application.
        public let environmentPropertyDescriptions: EnvironmentPropertyDescriptions?
        /// The details about a Java-based Kinesis Data Analytics application.
        public let flinkApplicationConfigurationDescription: FlinkApplicationConfigurationDescription?
        /// The details about the starting properties for a Kinesis Data Analytics application.
        public let runConfigurationDescription: RunConfigurationDescription?
        /// The details about inputs, outputs, and reference data sources for an SQL-based Kinesis Data Analytics application.
        public let sqlApplicationConfigurationDescription: SqlApplicationConfigurationDescription?

        public init(applicationCodeConfigurationDescription: ApplicationCodeConfigurationDescription? = nil, applicationSnapshotConfigurationDescription: ApplicationSnapshotConfigurationDescription? = nil, environmentPropertyDescriptions: EnvironmentPropertyDescriptions? = nil, flinkApplicationConfigurationDescription: FlinkApplicationConfigurationDescription? = nil, runConfigurationDescription: RunConfigurationDescription? = nil, sqlApplicationConfigurationDescription: SqlApplicationConfigurationDescription? = nil) {
            self.applicationCodeConfigurationDescription = applicationCodeConfigurationDescription
            self.applicationSnapshotConfigurationDescription = applicationSnapshotConfigurationDescription
            self.environmentPropertyDescriptions = environmentPropertyDescriptions
            self.flinkApplicationConfigurationDescription = flinkApplicationConfigurationDescription
            self.runConfigurationDescription = runConfigurationDescription
            self.sqlApplicationConfigurationDescription = sqlApplicationConfigurationDescription
        }

        private enum CodingKeys: String, CodingKey {
            case applicationCodeConfigurationDescription = "ApplicationCodeConfigurationDescription"
            case applicationSnapshotConfigurationDescription = "ApplicationSnapshotConfigurationDescription"
            case environmentPropertyDescriptions = "EnvironmentPropertyDescriptions"
            case flinkApplicationConfigurationDescription = "FlinkApplicationConfigurationDescription"
            case runConfigurationDescription = "RunConfigurationDescription"
            case sqlApplicationConfigurationDescription = "SqlApplicationConfigurationDescription"
        }
    }

    public struct ApplicationConfigurationUpdate: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "ApplicationCodeConfigurationUpdate", required: false, type: .structure), 
            AWSShapeMember(label: "ApplicationSnapshotConfigurationUpdate", required: false, type: .structure), 
            AWSShapeMember(label: "EnvironmentPropertyUpdates", required: false, type: .structure), 
            AWSShapeMember(label: "FlinkApplicationConfigurationUpdate", required: false, type: .structure), 
            AWSShapeMember(label: "SqlApplicationConfigurationUpdate", required: false, type: .structure)
        ]

        /// Describes updates to a Java-based Kinesis Data Analytics application's code configuration.
        public let applicationCodeConfigurationUpdate: ApplicationCodeConfigurationUpdate?
        /// Describes whether snapshots are enabled for a Java-based Kinesis Data Analytics application.
        public let applicationSnapshotConfigurationUpdate: ApplicationSnapshotConfigurationUpdate?
        /// Describes updates to the environment properties for a Java-based Kinesis Data Analytics application.
        public let environmentPropertyUpdates: EnvironmentPropertyUpdates?
        /// Describes updates to a Java-based Kinesis Data Analytics application's configuration.
        public let flinkApplicationConfigurationUpdate: FlinkApplicationConfigurationUpdate?
        /// Describes updates to an SQL-based Kinesis Data Analytics application's configuration.
        public let sqlApplicationConfigurationUpdate: SqlApplicationConfigurationUpdate?

        public init(applicationCodeConfigurationUpdate: ApplicationCodeConfigurationUpdate? = nil, applicationSnapshotConfigurationUpdate: ApplicationSnapshotConfigurationUpdate? = nil, environmentPropertyUpdates: EnvironmentPropertyUpdates? = nil, flinkApplicationConfigurationUpdate: FlinkApplicationConfigurationUpdate? = nil, sqlApplicationConfigurationUpdate: SqlApplicationConfigurationUpdate? = nil) {
            self.applicationCodeConfigurationUpdate = applicationCodeConfigurationUpdate
            self.applicationSnapshotConfigurationUpdate = applicationSnapshotConfigurationUpdate
            self.environmentPropertyUpdates = environmentPropertyUpdates
            self.flinkApplicationConfigurationUpdate = flinkApplicationConfigurationUpdate
            self.sqlApplicationConfigurationUpdate = sqlApplicationConfigurationUpdate
        }

        public func validate(name: String) throws {
            try applicationCodeConfigurationUpdate?.validate(name: "\(name).applicationCodeConfigurationUpdate")
            try environmentPropertyUpdates?.validate(name: "\(name).environmentPropertyUpdates")
            try flinkApplicationConfigurationUpdate?.validate(name: "\(name).flinkApplicationConfigurationUpdate")
            try sqlApplicationConfigurationUpdate?.validate(name: "\(name).sqlApplicationConfigurationUpdate")
        }

        private enum CodingKeys: String, CodingKey {
            case applicationCodeConfigurationUpdate = "ApplicationCodeConfigurationUpdate"
            case applicationSnapshotConfigurationUpdate = "ApplicationSnapshotConfigurationUpdate"
            case environmentPropertyUpdates = "EnvironmentPropertyUpdates"
            case flinkApplicationConfigurationUpdate = "FlinkApplicationConfigurationUpdate"
            case sqlApplicationConfigurationUpdate = "SqlApplicationConfigurationUpdate"
        }
    }

    public struct ApplicationDetail: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "ApplicationARN", required: true, type: .string), 
            AWSShapeMember(label: "ApplicationConfigurationDescription", required: false, type: .structure), 
            AWSShapeMember(label: "ApplicationDescription", required: false, type: .string), 
            AWSShapeMember(label: "ApplicationName", required: true, type: .string), 
            AWSShapeMember(label: "ApplicationStatus", required: true, type: .enum), 
            AWSShapeMember(label: "ApplicationVersionId", required: true, type: .long), 
            AWSShapeMember(label: "CloudWatchLoggingOptionDescriptions", required: false, type: .list), 
            AWSShapeMember(label: "CreateTimestamp", required: false, type: .timestamp), 
            AWSShapeMember(label: "LastUpdateTimestamp", required: false, type: .timestamp), 
            AWSShapeMember(label: "RuntimeEnvironment", required: true, type: .enum), 
            AWSShapeMember(label: "ServiceExecutionRole", required: false, type: .string)
        ]

        /// The ARN of the application.
        public let applicationARN: String
        /// Provides details about the application's SQL or Java code and starting parameters.
        public let applicationConfigurationDescription: ApplicationConfigurationDescription?
        /// The description of the application.
        public let applicationDescription: String?
        /// The name of the application.
        public let applicationName: String
        /// The status of the application.
        public let applicationStatus: ApplicationStatus
        /// Provides the current application version. Kinesis Data Analytics updates the ApplicationVersionId each time you update the application.
        public let applicationVersionId: Int64
        /// Describes the application Amazon CloudWatch logging options.
        public let cloudWatchLoggingOptionDescriptions: [CloudWatchLoggingOptionDescription]?
        /// The current timestamp when the application was created.
        public let createTimestamp: TimeStamp?
        /// The current timestamp when the application was last updated.
        public let lastUpdateTimestamp: TimeStamp?
        /// The runtime environment for the application (SQL-1.0 or FLINK-1_6).
        public let runtimeEnvironment: RuntimeEnvironment
        /// Specifies the IAM role that the application uses to access external resources.
        public let serviceExecutionRole: String?

        public init(applicationARN: String, applicationConfigurationDescription: ApplicationConfigurationDescription? = nil, applicationDescription: String? = nil, applicationName: String, applicationStatus: ApplicationStatus, applicationVersionId: Int64, cloudWatchLoggingOptionDescriptions: [CloudWatchLoggingOptionDescription]? = nil, createTimestamp: TimeStamp? = nil, lastUpdateTimestamp: TimeStamp? = nil, runtimeEnvironment: RuntimeEnvironment, serviceExecutionRole: String? = nil) {
            self.applicationARN = applicationARN
            self.applicationConfigurationDescription = applicationConfigurationDescription
            self.applicationDescription = applicationDescription
            self.applicationName = applicationName
            self.applicationStatus = applicationStatus
            self.applicationVersionId = applicationVersionId
            self.cloudWatchLoggingOptionDescriptions = cloudWatchLoggingOptionDescriptions
            self.createTimestamp = createTimestamp
            self.lastUpdateTimestamp = lastUpdateTimestamp
            self.runtimeEnvironment = runtimeEnvironment
            self.serviceExecutionRole = serviceExecutionRole
        }

        private enum CodingKeys: String, CodingKey {
            case applicationARN = "ApplicationARN"
            case applicationConfigurationDescription = "ApplicationConfigurationDescription"
            case applicationDescription = "ApplicationDescription"
            case applicationName = "ApplicationName"
            case applicationStatus = "ApplicationStatus"
            case applicationVersionId = "ApplicationVersionId"
            case cloudWatchLoggingOptionDescriptions = "CloudWatchLoggingOptionDescriptions"
            case createTimestamp = "CreateTimestamp"
            case lastUpdateTimestamp = "LastUpdateTimestamp"
            case runtimeEnvironment = "RuntimeEnvironment"
            case serviceExecutionRole = "ServiceExecutionRole"
        }
    }

    public struct ApplicationRestoreConfiguration: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "ApplicationRestoreType", required: true, type: .enum), 
            AWSShapeMember(label: "SnapshotName", required: false, type: .string)
        ]

        /// Specifies how the application should be restored.
        public let applicationRestoreType: ApplicationRestoreType
        /// The identifier of an existing snapshot of application state to use to restart an application. The application uses this value if RESTORE_FROM_CUSTOM_SNAPSHOT is specified for the ApplicationRestoreType.
        public let snapshotName: String?

        public init(applicationRestoreType: ApplicationRestoreType, snapshotName: String? = nil) {
            self.applicationRestoreType = applicationRestoreType
            self.snapshotName = snapshotName
        }

        public func validate(name: String) throws {
            try validate(snapshotName, name:"snapshotName", parent: name, max: 128)
            try validate(snapshotName, name:"snapshotName", parent: name, min: 1)
            try validate(snapshotName, name:"snapshotName", parent: name, pattern: "[a-zA-Z0-9_.-]+")
        }

        private enum CodingKeys: String, CodingKey {
            case applicationRestoreType = "ApplicationRestoreType"
            case snapshotName = "SnapshotName"
        }
    }

    public enum ApplicationRestoreType: String, CustomStringConvertible, Codable {
        case skipRestoreFromSnapshot = "SKIP_RESTORE_FROM_SNAPSHOT"
        case restoreFromLatestSnapshot = "RESTORE_FROM_LATEST_SNAPSHOT"
        case restoreFromCustomSnapshot = "RESTORE_FROM_CUSTOM_SNAPSHOT"
        public var description: String { return self.rawValue }
    }

    public struct ApplicationSnapshotConfiguration: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "SnapshotsEnabled", required: true, type: .boolean)
        ]

        /// Describes whether snapshots are enabled for a Java-based Kinesis Data Analytics application.
        public let snapshotsEnabled: Bool

        public init(snapshotsEnabled: Bool) {
            self.snapshotsEnabled = snapshotsEnabled
        }

        private enum CodingKeys: String, CodingKey {
            case snapshotsEnabled = "SnapshotsEnabled"
        }
    }

    public struct ApplicationSnapshotConfigurationDescription: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "SnapshotsEnabled", required: true, type: .boolean)
        ]

        /// Describes whether snapshots are enabled for a Java-based Kinesis Data Analytics application.
        public let snapshotsEnabled: Bool

        public init(snapshotsEnabled: Bool) {
            self.snapshotsEnabled = snapshotsEnabled
        }

        private enum CodingKeys: String, CodingKey {
            case snapshotsEnabled = "SnapshotsEnabled"
        }
    }

    public struct ApplicationSnapshotConfigurationUpdate: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "SnapshotsEnabledUpdate", required: true, type: .boolean)
        ]

        /// Describes updates to whether snapshots are enabled for a Java-based Kinesis Data Analytics application.
        public let snapshotsEnabledUpdate: Bool

        public init(snapshotsEnabledUpdate: Bool) {
            self.snapshotsEnabledUpdate = snapshotsEnabledUpdate
        }

        private enum CodingKeys: String, CodingKey {
            case snapshotsEnabledUpdate = "SnapshotsEnabledUpdate"
        }
    }

    public enum ApplicationStatus: String, CustomStringConvertible, Codable {
        case deleting = "DELETING"
        case starting = "STARTING"
        case stopping = "STOPPING"
        case ready = "READY"
        case running = "RUNNING"
        case updating = "UPDATING"
        public var description: String { return self.rawValue }
    }

    public struct ApplicationSummary: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "ApplicationARN", required: true, type: .string), 
            AWSShapeMember(label: "ApplicationName", required: true, type: .string), 
            AWSShapeMember(label: "ApplicationStatus", required: true, type: .enum), 
            AWSShapeMember(label: "ApplicationVersionId", required: true, type: .long), 
            AWSShapeMember(label: "RuntimeEnvironment", required: true, type: .enum)
        ]

        /// The ARN of the application.
        public let applicationARN: String
        /// The name of the application.
        public let applicationName: String
        /// The status of the application.
        public let applicationStatus: ApplicationStatus
        /// Provides the current application version.
        public let applicationVersionId: Int64
        /// The runtime environment for the application (SQL-1.0 or FLINK-1_6).
        public let runtimeEnvironment: RuntimeEnvironment

        public init(applicationARN: String, applicationName: String, applicationStatus: ApplicationStatus, applicationVersionId: Int64, runtimeEnvironment: RuntimeEnvironment) {
            self.applicationARN = applicationARN
            self.applicationName = applicationName
            self.applicationStatus = applicationStatus
            self.applicationVersionId = applicationVersionId
            self.runtimeEnvironment = runtimeEnvironment
        }

        private enum CodingKeys: String, CodingKey {
            case applicationARN = "ApplicationARN"
            case applicationName = "ApplicationName"
            case applicationStatus = "ApplicationStatus"
            case applicationVersionId = "ApplicationVersionId"
            case runtimeEnvironment = "RuntimeEnvironment"
        }
    }

    public struct CSVMappingParameters: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "RecordColumnDelimiter", required: true, type: .string), 
            AWSShapeMember(label: "RecordRowDelimiter", required: true, type: .string)
        ]

        /// The column delimiter. For example, in a CSV format, a comma (",") is the typical column delimiter.
        public let recordColumnDelimiter: String
        /// The row delimiter. For example, in a CSV format, '\n' is the typical row delimiter.
        public let recordRowDelimiter: String

        public init(recordColumnDelimiter: String, recordRowDelimiter: String) {
            self.recordColumnDelimiter = recordColumnDelimiter
            self.recordRowDelimiter = recordRowDelimiter
        }

        public func validate(name: String) throws {
            try validate(recordColumnDelimiter, name:"recordColumnDelimiter", parent: name, min: 1)
            try validate(recordRowDelimiter, name:"recordRowDelimiter", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case recordColumnDelimiter = "RecordColumnDelimiter"
            case recordRowDelimiter = "RecordRowDelimiter"
        }
    }

    public struct CheckpointConfiguration: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "CheckpointingEnabled", required: false, type: .boolean), 
            AWSShapeMember(label: "CheckpointInterval", required: false, type: .long), 
            AWSShapeMember(label: "ConfigurationType", required: true, type: .enum), 
            AWSShapeMember(label: "MinPauseBetweenCheckpoints", required: false, type: .long)
        ]

        /// Describes whether checkpointing is enabled for a Java-based Kinesis Data Analytics application.
        public let checkpointingEnabled: Bool?
        /// Describes the interval in milliseconds between checkpoint operations. 
        public let checkpointInterval: Int64?
        /// Describes whether the application uses Amazon Kinesis Data Analytics' default checkpointing behavior. 
        public let configurationType: ConfigurationType
        /// Describes the minimum time in milliseconds after a checkpoint operation completes that a new checkpoint operation can start. If a checkpoint operation takes longer than the CheckpointInterval, the application otherwise performs continual checkpoint operations. For more information, see  Tuning Checkpointing in the Apache Flink Documentation.
        public let minPauseBetweenCheckpoints: Int64?

        public init(checkpointingEnabled: Bool? = nil, checkpointInterval: Int64? = nil, configurationType: ConfigurationType, minPauseBetweenCheckpoints: Int64? = nil) {
            self.checkpointingEnabled = checkpointingEnabled
            self.checkpointInterval = checkpointInterval
            self.configurationType = configurationType
            self.minPauseBetweenCheckpoints = minPauseBetweenCheckpoints
        }

        public func validate(name: String) throws {
            try validate(checkpointInterval, name:"checkpointInterval", parent: name, min: 0)
            try validate(minPauseBetweenCheckpoints, name:"minPauseBetweenCheckpoints", parent: name, min: 0)
        }

        private enum CodingKeys: String, CodingKey {
            case checkpointingEnabled = "CheckpointingEnabled"
            case checkpointInterval = "CheckpointInterval"
            case configurationType = "ConfigurationType"
            case minPauseBetweenCheckpoints = "MinPauseBetweenCheckpoints"
        }
    }

    public struct CheckpointConfigurationDescription: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "CheckpointingEnabled", required: false, type: .boolean), 
            AWSShapeMember(label: "CheckpointInterval", required: false, type: .long), 
            AWSShapeMember(label: "ConfigurationType", required: false, type: .enum), 
            AWSShapeMember(label: "MinPauseBetweenCheckpoints", required: false, type: .long)
        ]

        /// Describes whether checkpointing is enabled for a Java-based Kinesis Data Analytics application.
        public let checkpointingEnabled: Bool?
        /// Describes the interval in milliseconds between checkpoint operations.
        public let checkpointInterval: Int64?
        /// Describes whether the application uses the default checkpointing behavior in Kinesis Data Analytics.
        public let configurationType: ConfigurationType?
        /// Describes the minimum time in milliseconds after a checkpoint operation completes that a new checkpoint operation can start.
        public let minPauseBetweenCheckpoints: Int64?

        public init(checkpointingEnabled: Bool? = nil, checkpointInterval: Int64? = nil, configurationType: ConfigurationType? = nil, minPauseBetweenCheckpoints: Int64? = nil) {
            self.checkpointingEnabled = checkpointingEnabled
            self.checkpointInterval = checkpointInterval
            self.configurationType = configurationType
            self.minPauseBetweenCheckpoints = minPauseBetweenCheckpoints
        }

        private enum CodingKeys: String, CodingKey {
            case checkpointingEnabled = "CheckpointingEnabled"
            case checkpointInterval = "CheckpointInterval"
            case configurationType = "ConfigurationType"
            case minPauseBetweenCheckpoints = "MinPauseBetweenCheckpoints"
        }
    }

    public struct CheckpointConfigurationUpdate: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "CheckpointingEnabledUpdate", required: false, type: .boolean), 
            AWSShapeMember(label: "CheckpointIntervalUpdate", required: false, type: .long), 
            AWSShapeMember(label: "ConfigurationTypeUpdate", required: false, type: .enum), 
            AWSShapeMember(label: "MinPauseBetweenCheckpointsUpdate", required: false, type: .long)
        ]

        /// Describes updates to whether checkpointing is enabled for an application.
        public let checkpointingEnabledUpdate: Bool?
        /// Describes updates to the interval in milliseconds between checkpoint operations.
        public let checkpointIntervalUpdate: Int64?
        /// Describes updates to whether the application uses the default checkpointing behavior of Kinesis Data Analytics.
        public let configurationTypeUpdate: ConfigurationType?
        /// Describes updates to the minimum time in milliseconds after a checkpoint operation completes that a new checkpoint operation can start.
        public let minPauseBetweenCheckpointsUpdate: Int64?

        public init(checkpointingEnabledUpdate: Bool? = nil, checkpointIntervalUpdate: Int64? = nil, configurationTypeUpdate: ConfigurationType? = nil, minPauseBetweenCheckpointsUpdate: Int64? = nil) {
            self.checkpointingEnabledUpdate = checkpointingEnabledUpdate
            self.checkpointIntervalUpdate = checkpointIntervalUpdate
            self.configurationTypeUpdate = configurationTypeUpdate
            self.minPauseBetweenCheckpointsUpdate = minPauseBetweenCheckpointsUpdate
        }

        public func validate(name: String) throws {
            try validate(checkpointIntervalUpdate, name:"checkpointIntervalUpdate", parent: name, min: 0)
            try validate(minPauseBetweenCheckpointsUpdate, name:"minPauseBetweenCheckpointsUpdate", parent: name, min: 0)
        }

        private enum CodingKeys: String, CodingKey {
            case checkpointingEnabledUpdate = "CheckpointingEnabledUpdate"
            case checkpointIntervalUpdate = "CheckpointIntervalUpdate"
            case configurationTypeUpdate = "ConfigurationTypeUpdate"
            case minPauseBetweenCheckpointsUpdate = "MinPauseBetweenCheckpointsUpdate"
        }
    }

    public struct CloudWatchLoggingOption: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "LogStreamARN", required: true, type: .string)
        ]

        /// The ARN of the CloudWatch log to receive application messages.
        public let logStreamARN: String

        public init(logStreamARN: String) {
            self.logStreamARN = logStreamARN
        }

        public func validate(name: String) throws {
            try validate(logStreamARN, name:"logStreamARN", parent: name, max: 2048)
            try validate(logStreamARN, name:"logStreamARN", parent: name, min: 1)
            try validate(logStreamARN, name:"logStreamARN", parent: name, pattern: "arn:.*")
        }

        private enum CodingKeys: String, CodingKey {
            case logStreamARN = "LogStreamARN"
        }
    }

    public struct CloudWatchLoggingOptionDescription: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "CloudWatchLoggingOptionId", required: false, type: .string), 
            AWSShapeMember(label: "LogStreamARN", required: true, type: .string), 
            AWSShapeMember(label: "RoleARN", required: false, type: .string)
        ]

        /// The ID of the CloudWatch logging option description.
        public let cloudWatchLoggingOptionId: String?
        /// The Amazon Resource Name (ARN) of the CloudWatch log to receive application messages.
        public let logStreamARN: String
        /// The IAM ARN of the role to use to send application messages.   Provided for backward compatibility. Applications created with the current API version have an application-level service execution role rather than a resource-level role. 
        public let roleARN: String?

        public init(cloudWatchLoggingOptionId: String? = nil, logStreamARN: String, roleARN: String? = nil) {
            self.cloudWatchLoggingOptionId = cloudWatchLoggingOptionId
            self.logStreamARN = logStreamARN
            self.roleARN = roleARN
        }

        private enum CodingKeys: String, CodingKey {
            case cloudWatchLoggingOptionId = "CloudWatchLoggingOptionId"
            case logStreamARN = "LogStreamARN"
            case roleARN = "RoleARN"
        }
    }

    public struct CloudWatchLoggingOptionUpdate: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "CloudWatchLoggingOptionId", required: true, type: .string), 
            AWSShapeMember(label: "LogStreamARNUpdate", required: false, type: .string)
        ]

        /// The ID of the CloudWatch logging option to update
        public let cloudWatchLoggingOptionId: String
        /// The Amazon Resource Name (ARN) of the CloudWatch log to receive application messages.
        public let logStreamARNUpdate: String?

        public init(cloudWatchLoggingOptionId: String, logStreamARNUpdate: String? = nil) {
            self.cloudWatchLoggingOptionId = cloudWatchLoggingOptionId
            self.logStreamARNUpdate = logStreamARNUpdate
        }

        public func validate(name: String) throws {
            try validate(cloudWatchLoggingOptionId, name:"cloudWatchLoggingOptionId", parent: name, max: 50)
            try validate(cloudWatchLoggingOptionId, name:"cloudWatchLoggingOptionId", parent: name, min: 1)
            try validate(cloudWatchLoggingOptionId, name:"cloudWatchLoggingOptionId", parent: name, pattern: "[a-zA-Z0-9_.-]+")
            try validate(logStreamARNUpdate, name:"logStreamARNUpdate", parent: name, max: 2048)
            try validate(logStreamARNUpdate, name:"logStreamARNUpdate", parent: name, min: 1)
            try validate(logStreamARNUpdate, name:"logStreamARNUpdate", parent: name, pattern: "arn:.*")
        }

        private enum CodingKeys: String, CodingKey {
            case cloudWatchLoggingOptionId = "CloudWatchLoggingOptionId"
            case logStreamARNUpdate = "LogStreamARNUpdate"
        }
    }

    public struct CodeContent: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "S3ContentLocation", required: false, type: .structure), 
            AWSShapeMember(label: "TextContent", required: false, type: .string), 
            AWSShapeMember(label: "ZipFileContent", required: false, type: .blob)
        ]

        /// Information about the Amazon S3 bucket containing the application code.
        public let s3ContentLocation: S3ContentLocation?
        /// The text-format code for a Java-based Kinesis Data Analytics application.
        public let textContent: String?
        /// The zip-format code for a Java-based Kinesis Data Analytics application.
        public let zipFileContent: Data?

        public init(s3ContentLocation: S3ContentLocation? = nil, textContent: String? = nil, zipFileContent: Data? = nil) {
            self.s3ContentLocation = s3ContentLocation
            self.textContent = textContent
            self.zipFileContent = zipFileContent
        }

        public func validate(name: String) throws {
            try s3ContentLocation?.validate(name: "\(name).s3ContentLocation")
            try validate(textContent, name:"textContent", parent: name, max: 102400)
            try validate(textContent, name:"textContent", parent: name, min: 0)
            try validate(zipFileContent, name:"zipFileContent", parent: name, max: 52428800)
            try validate(zipFileContent, name:"zipFileContent", parent: name, min: 0)
        }

        private enum CodingKeys: String, CodingKey {
            case s3ContentLocation = "S3ContentLocation"
            case textContent = "TextContent"
            case zipFileContent = "ZipFileContent"
        }
    }

    public struct CodeContentDescription: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "CodeMD5", required: false, type: .string), 
            AWSShapeMember(label: "CodeSize", required: false, type: .long), 
            AWSShapeMember(label: "S3ApplicationCodeLocationDescription", required: false, type: .structure), 
            AWSShapeMember(label: "TextContent", required: false, type: .string)
        ]

        /// The checksum that can be used to validate zip-format code.
        public let codeMD5: String?
        /// The size in bytes of the application code. Can be used to validate zip-format code.
        public let codeSize: Int64?
        /// The S3 bucket Amazon Resource Name (ARN), file key, and object version of the application code stored in Amazon S3.
        public let s3ApplicationCodeLocationDescription: S3ApplicationCodeLocationDescription?
        /// The text-format code
        public let textContent: String?

        public init(codeMD5: String? = nil, codeSize: Int64? = nil, s3ApplicationCodeLocationDescription: S3ApplicationCodeLocationDescription? = nil, textContent: String? = nil) {
            self.codeMD5 = codeMD5
            self.codeSize = codeSize
            self.s3ApplicationCodeLocationDescription = s3ApplicationCodeLocationDescription
            self.textContent = textContent
        }

        private enum CodingKeys: String, CodingKey {
            case codeMD5 = "CodeMD5"
            case codeSize = "CodeSize"
            case s3ApplicationCodeLocationDescription = "S3ApplicationCodeLocationDescription"
            case textContent = "TextContent"
        }
    }

    public enum CodeContentType: String, CustomStringConvertible, Codable {
        case plaintext = "PLAINTEXT"
        case zipfile = "ZIPFILE"
        public var description: String { return self.rawValue }
    }

    public struct CodeContentUpdate: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "S3ContentLocationUpdate", required: false, type: .structure), 
            AWSShapeMember(label: "TextContentUpdate", required: false, type: .string), 
            AWSShapeMember(label: "ZipFileContentUpdate", required: false, type: .blob)
        ]

        /// Describes an update to the location of code for an application.
        public let s3ContentLocationUpdate: S3ContentLocationUpdate?
        /// Describes an update to the text code for an application.
        public let textContentUpdate: String?
        /// Describes an update to the zipped code for an application.
        public let zipFileContentUpdate: Data?

        public init(s3ContentLocationUpdate: S3ContentLocationUpdate? = nil, textContentUpdate: String? = nil, zipFileContentUpdate: Data? = nil) {
            self.s3ContentLocationUpdate = s3ContentLocationUpdate
            self.textContentUpdate = textContentUpdate
            self.zipFileContentUpdate = zipFileContentUpdate
        }

        public func validate(name: String) throws {
            try s3ContentLocationUpdate?.validate(name: "\(name).s3ContentLocationUpdate")
            try validate(textContentUpdate, name:"textContentUpdate", parent: name, max: 102400)
            try validate(textContentUpdate, name:"textContentUpdate", parent: name, min: 0)
            try validate(zipFileContentUpdate, name:"zipFileContentUpdate", parent: name, max: 52428800)
            try validate(zipFileContentUpdate, name:"zipFileContentUpdate", parent: name, min: 0)
        }

        private enum CodingKeys: String, CodingKey {
            case s3ContentLocationUpdate = "S3ContentLocationUpdate"
            case textContentUpdate = "TextContentUpdate"
            case zipFileContentUpdate = "ZipFileContentUpdate"
        }
    }

    public enum ConfigurationType: String, CustomStringConvertible, Codable {
        case `default` = "DEFAULT"
        case custom = "CUSTOM"
        public var description: String { return self.rawValue }
    }

    public struct CreateApplicationRequest: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "ApplicationConfiguration", required: false, type: .structure), 
            AWSShapeMember(label: "ApplicationDescription", required: false, type: .string), 
            AWSShapeMember(label: "ApplicationName", required: true, type: .string), 
            AWSShapeMember(label: "CloudWatchLoggingOptions", required: false, type: .list), 
            AWSShapeMember(label: "RuntimeEnvironment", required: true, type: .enum), 
            AWSShapeMember(label: "ServiceExecutionRole", required: true, type: .string), 
            AWSShapeMember(label: "Tags", required: false, type: .list)
        ]

        /// Use this parameter to configure the application.
        public let applicationConfiguration: ApplicationConfiguration?
        /// A summary description of the application.
        public let applicationDescription: String?
        /// The name of your application (for example, sample-app).
        public let applicationName: String
        /// Use this parameter to configure an Amazon CloudWatch log stream to monitor application configuration errors. 
        public let cloudWatchLoggingOptions: [CloudWatchLoggingOption]?
        /// The runtime environment for the application (SQL-1.0 or FLINK-1_6).
        public let runtimeEnvironment: RuntimeEnvironment
        /// The IAM role used by the application to access Kinesis data streams, Kinesis Data Firehose delivery streams, Amazon S3 objects, and other external resources.
        public let serviceExecutionRole: String
        /// A list of one or more tags to assign to the application. A tag is a key-value pair that identifies an application. Note that the maximum number of application tags includes system tags. The maximum number of user-defined application tags is 50. For more information, see Using Cost Allocation Tags in the AWS Billing and Cost Management Guide.
        public let tags: [Tag]?

        public init(applicationConfiguration: ApplicationConfiguration? = nil, applicationDescription: String? = nil, applicationName: String, cloudWatchLoggingOptions: [CloudWatchLoggingOption]? = nil, runtimeEnvironment: RuntimeEnvironment, serviceExecutionRole: String, tags: [Tag]? = nil) {
            self.applicationConfiguration = applicationConfiguration
            self.applicationDescription = applicationDescription
            self.applicationName = applicationName
            self.cloudWatchLoggingOptions = cloudWatchLoggingOptions
            self.runtimeEnvironment = runtimeEnvironment
            self.serviceExecutionRole = serviceExecutionRole
            self.tags = tags
        }

        public func validate(name: String) throws {
            try applicationConfiguration?.validate(name: "\(name).applicationConfiguration")
            try validate(applicationDescription, name:"applicationDescription", parent: name, max: 1024)
            try validate(applicationDescription, name:"applicationDescription", parent: name, min: 0)
            try validate(applicationName, name:"applicationName", parent: name, max: 128)
            try validate(applicationName, name:"applicationName", parent: name, min: 1)
            try validate(applicationName, name:"applicationName", parent: name, pattern: "[a-zA-Z0-9_.-]+")
            try cloudWatchLoggingOptions?.forEach {
                try $0.validate(name: "\(name).cloudWatchLoggingOptions[]")
            }
            try validate(serviceExecutionRole, name:"serviceExecutionRole", parent: name, max: 2048)
            try validate(serviceExecutionRole, name:"serviceExecutionRole", parent: name, min: 1)
            try validate(serviceExecutionRole, name:"serviceExecutionRole", parent: name, pattern: "arn:aws:iam::\\d{12}:role/?[a-zA-Z_0-9+=,.@\\-_/]+")
            try tags?.forEach {
                try $0.validate(name: "\(name).tags[]")
            }
            try validate(tags, name:"tags", parent: name, max: 200)
            try validate(tags, name:"tags", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case applicationConfiguration = "ApplicationConfiguration"
            case applicationDescription = "ApplicationDescription"
            case applicationName = "ApplicationName"
            case cloudWatchLoggingOptions = "CloudWatchLoggingOptions"
            case runtimeEnvironment = "RuntimeEnvironment"
            case serviceExecutionRole = "ServiceExecutionRole"
            case tags = "Tags"
        }
    }

    public struct CreateApplicationResponse: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "ApplicationDetail", required: true, type: .structure)
        ]

        /// In response to your CreateApplication request, Kinesis Data Analytics returns a response with details of the application it created.
        public let applicationDetail: ApplicationDetail

        public init(applicationDetail: ApplicationDetail) {
            self.applicationDetail = applicationDetail
        }

        private enum CodingKeys: String, CodingKey {
            case applicationDetail = "ApplicationDetail"
        }
    }

    public struct CreateApplicationSnapshotRequest: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "ApplicationName", required: true, type: .string), 
            AWSShapeMember(label: "SnapshotName", required: true, type: .string)
        ]

        /// The name of an existing application
        public let applicationName: String
        /// An identifier for the application snapshot.
        public let snapshotName: String

        public init(applicationName: String, snapshotName: String) {
            self.applicationName = applicationName
            self.snapshotName = snapshotName
        }

        public func validate(name: String) throws {
            try validate(applicationName, name:"applicationName", parent: name, max: 128)
            try validate(applicationName, name:"applicationName", parent: name, min: 1)
            try validate(applicationName, name:"applicationName", parent: name, pattern: "[a-zA-Z0-9_.-]+")
            try validate(snapshotName, name:"snapshotName", parent: name, max: 128)
            try validate(snapshotName, name:"snapshotName", parent: name, min: 1)
            try validate(snapshotName, name:"snapshotName", parent: name, pattern: "[a-zA-Z0-9_.-]+")
        }

        private enum CodingKeys: String, CodingKey {
            case applicationName = "ApplicationName"
            case snapshotName = "SnapshotName"
        }
    }

    public struct CreateApplicationSnapshotResponse: AWSShape {


        public init() {
        }

    }

    public struct DeleteApplicationCloudWatchLoggingOptionRequest: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "ApplicationName", required: true, type: .string), 
            AWSShapeMember(label: "CloudWatchLoggingOptionId", required: true, type: .string), 
            AWSShapeMember(label: "CurrentApplicationVersionId", required: true, type: .long)
        ]

        /// The application name.
        public let applicationName: String
        /// The CloudWatchLoggingOptionId of the Amazon CloudWatch logging option to delete. You can get the CloudWatchLoggingOptionId by using the DescribeApplication operation. 
        public let cloudWatchLoggingOptionId: String
        /// The version ID of the application. You can retrieve the application version ID using DescribeApplication.
        public let currentApplicationVersionId: Int64

        public init(applicationName: String, cloudWatchLoggingOptionId: String, currentApplicationVersionId: Int64) {
            self.applicationName = applicationName
            self.cloudWatchLoggingOptionId = cloudWatchLoggingOptionId
            self.currentApplicationVersionId = currentApplicationVersionId
        }

        public func validate(name: String) throws {
            try validate(applicationName, name:"applicationName", parent: name, max: 128)
            try validate(applicationName, name:"applicationName", parent: name, min: 1)
            try validate(applicationName, name:"applicationName", parent: name, pattern: "[a-zA-Z0-9_.-]+")
            try validate(cloudWatchLoggingOptionId, name:"cloudWatchLoggingOptionId", parent: name, max: 50)
            try validate(cloudWatchLoggingOptionId, name:"cloudWatchLoggingOptionId", parent: name, min: 1)
            try validate(cloudWatchLoggingOptionId, name:"cloudWatchLoggingOptionId", parent: name, pattern: "[a-zA-Z0-9_.-]+")
            try validate(currentApplicationVersionId, name:"currentApplicationVersionId", parent: name, max: 999999999)
            try validate(currentApplicationVersionId, name:"currentApplicationVersionId", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case applicationName = "ApplicationName"
            case cloudWatchLoggingOptionId = "CloudWatchLoggingOptionId"
            case currentApplicationVersionId = "CurrentApplicationVersionId"
        }
    }

    public struct DeleteApplicationCloudWatchLoggingOptionResponse: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "ApplicationARN", required: false, type: .string), 
            AWSShapeMember(label: "ApplicationVersionId", required: false, type: .long), 
            AWSShapeMember(label: "CloudWatchLoggingOptionDescriptions", required: false, type: .list)
        ]

        /// The application's Amazon Resource Name (ARN).
        public let applicationARN: String?
        /// The version ID of the application. Kinesis Data Analytics updates the ApplicationVersionId each time you change the CloudWatch logging options.
        public let applicationVersionId: Int64?
        /// The descriptions of the remaining CloudWatch logging options for the application.
        public let cloudWatchLoggingOptionDescriptions: [CloudWatchLoggingOptionDescription]?

        public init(applicationARN: String? = nil, applicationVersionId: Int64? = nil, cloudWatchLoggingOptionDescriptions: [CloudWatchLoggingOptionDescription]? = nil) {
            self.applicationARN = applicationARN
            self.applicationVersionId = applicationVersionId
            self.cloudWatchLoggingOptionDescriptions = cloudWatchLoggingOptionDescriptions
        }

        private enum CodingKeys: String, CodingKey {
            case applicationARN = "ApplicationARN"
            case applicationVersionId = "ApplicationVersionId"
            case cloudWatchLoggingOptionDescriptions = "CloudWatchLoggingOptionDescriptions"
        }
    }

    public struct DeleteApplicationInputProcessingConfigurationRequest: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "ApplicationName", required: true, type: .string), 
            AWSShapeMember(label: "CurrentApplicationVersionId", required: true, type: .long), 
            AWSShapeMember(label: "InputId", required: true, type: .string)
        ]

        /// The name of the application.
        public let applicationName: String
        /// The application version. You can use the DescribeApplication operation to get the current application version. If the version specified is not the current version, the ConcurrentModificationException is returned. 
        public let currentApplicationVersionId: Int64
        /// The ID of the input configuration from which to delete the input processing configuration. You can get a list of the input IDs for an application by using the DescribeApplication operation.
        public let inputId: String

        public init(applicationName: String, currentApplicationVersionId: Int64, inputId: String) {
            self.applicationName = applicationName
            self.currentApplicationVersionId = currentApplicationVersionId
            self.inputId = inputId
        }

        public func validate(name: String) throws {
            try validate(applicationName, name:"applicationName", parent: name, max: 128)
            try validate(applicationName, name:"applicationName", parent: name, min: 1)
            try validate(applicationName, name:"applicationName", parent: name, pattern: "[a-zA-Z0-9_.-]+")
            try validate(currentApplicationVersionId, name:"currentApplicationVersionId", parent: name, max: 999999999)
            try validate(currentApplicationVersionId, name:"currentApplicationVersionId", parent: name, min: 1)
            try validate(inputId, name:"inputId", parent: name, max: 50)
            try validate(inputId, name:"inputId", parent: name, min: 1)
            try validate(inputId, name:"inputId", parent: name, pattern: "[a-zA-Z0-9_.-]+")
        }

        private enum CodingKeys: String, CodingKey {
            case applicationName = "ApplicationName"
            case currentApplicationVersionId = "CurrentApplicationVersionId"
            case inputId = "InputId"
        }
    }

    public struct DeleteApplicationInputProcessingConfigurationResponse: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "ApplicationARN", required: false, type: .string), 
            AWSShapeMember(label: "ApplicationVersionId", required: false, type: .long)
        ]

        /// The Amazon Resource Name (ARN) of the application.
        public let applicationARN: String?
        /// The current application version ID.
        public let applicationVersionId: Int64?

        public init(applicationARN: String? = nil, applicationVersionId: Int64? = nil) {
            self.applicationARN = applicationARN
            self.applicationVersionId = applicationVersionId
        }

        private enum CodingKeys: String, CodingKey {
            case applicationARN = "ApplicationARN"
            case applicationVersionId = "ApplicationVersionId"
        }
    }

    public struct DeleteApplicationOutputRequest: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "ApplicationName", required: true, type: .string), 
            AWSShapeMember(label: "CurrentApplicationVersionId", required: true, type: .long), 
            AWSShapeMember(label: "OutputId", required: true, type: .string)
        ]

        /// The application name.
        public let applicationName: String
        /// The application version. You can use the DescribeApplication operation to get the current application version. If the version specified is not the current version, the ConcurrentModificationException is returned. 
        public let currentApplicationVersionId: Int64
        /// The ID of the configuration to delete. Each output configuration that is added to the application (either when the application is created or later) using the AddApplicationOutput operation has a unique ID. You need to provide the ID to uniquely identify the output configuration that you want to delete from the application configuration. You can use the DescribeApplication operation to get the specific OutputId. 
        public let outputId: String

        public init(applicationName: String, currentApplicationVersionId: Int64, outputId: String) {
            self.applicationName = applicationName
            self.currentApplicationVersionId = currentApplicationVersionId
            self.outputId = outputId
        }

        public func validate(name: String) throws {
            try validate(applicationName, name:"applicationName", parent: name, max: 128)
            try validate(applicationName, name:"applicationName", parent: name, min: 1)
            try validate(applicationName, name:"applicationName", parent: name, pattern: "[a-zA-Z0-9_.-]+")
            try validate(currentApplicationVersionId, name:"currentApplicationVersionId", parent: name, max: 999999999)
            try validate(currentApplicationVersionId, name:"currentApplicationVersionId", parent: name, min: 1)
            try validate(outputId, name:"outputId", parent: name, max: 50)
            try validate(outputId, name:"outputId", parent: name, min: 1)
            try validate(outputId, name:"outputId", parent: name, pattern: "[a-zA-Z0-9_.-]+")
        }

        private enum CodingKeys: String, CodingKey {
            case applicationName = "ApplicationName"
            case currentApplicationVersionId = "CurrentApplicationVersionId"
            case outputId = "OutputId"
        }
    }

    public struct DeleteApplicationOutputResponse: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "ApplicationARN", required: false, type: .string), 
            AWSShapeMember(label: "ApplicationVersionId", required: false, type: .long)
        ]

        /// The application Amazon Resource Name (ARN).
        public let applicationARN: String?
        /// The current application version ID.
        public let applicationVersionId: Int64?

        public init(applicationARN: String? = nil, applicationVersionId: Int64? = nil) {
            self.applicationARN = applicationARN
            self.applicationVersionId = applicationVersionId
        }

        private enum CodingKeys: String, CodingKey {
            case applicationARN = "ApplicationARN"
            case applicationVersionId = "ApplicationVersionId"
        }
    }

    public struct DeleteApplicationReferenceDataSourceRequest: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "ApplicationName", required: true, type: .string), 
            AWSShapeMember(label: "CurrentApplicationVersionId", required: true, type: .long), 
            AWSShapeMember(label: "ReferenceId", required: true, type: .string)
        ]

        /// The name of an existing application.
        public let applicationName: String
        /// The current application version. You can use the DescribeApplication operation to get the current application version. If the version specified is not the current version, the ConcurrentModificationException is returned.
        public let currentApplicationVersionId: Int64
        /// The ID of the reference data source. When you add a reference data source to your application using the AddApplicationReferenceDataSource, Kinesis Data Analytics assigns an ID. You can use the DescribeApplication operation to get the reference ID. 
        public let referenceId: String

        public init(applicationName: String, currentApplicationVersionId: Int64, referenceId: String) {
            self.applicationName = applicationName
            self.currentApplicationVersionId = currentApplicationVersionId
            self.referenceId = referenceId
        }

        public func validate(name: String) throws {
            try validate(applicationName, name:"applicationName", parent: name, max: 128)
            try validate(applicationName, name:"applicationName", parent: name, min: 1)
            try validate(applicationName, name:"applicationName", parent: name, pattern: "[a-zA-Z0-9_.-]+")
            try validate(currentApplicationVersionId, name:"currentApplicationVersionId", parent: name, max: 999999999)
            try validate(currentApplicationVersionId, name:"currentApplicationVersionId", parent: name, min: 1)
            try validate(referenceId, name:"referenceId", parent: name, max: 50)
            try validate(referenceId, name:"referenceId", parent: name, min: 1)
            try validate(referenceId, name:"referenceId", parent: name, pattern: "[a-zA-Z0-9_.-]+")
        }

        private enum CodingKeys: String, CodingKey {
            case applicationName = "ApplicationName"
            case currentApplicationVersionId = "CurrentApplicationVersionId"
            case referenceId = "ReferenceId"
        }
    }

    public struct DeleteApplicationReferenceDataSourceResponse: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "ApplicationARN", required: false, type: .string), 
            AWSShapeMember(label: "ApplicationVersionId", required: false, type: .long)
        ]

        /// The application Amazon Resource Name (ARN).
        public let applicationARN: String?
        /// The updated version ID of the application.
        public let applicationVersionId: Int64?

        public init(applicationARN: String? = nil, applicationVersionId: Int64? = nil) {
            self.applicationARN = applicationARN
            self.applicationVersionId = applicationVersionId
        }

        private enum CodingKeys: String, CodingKey {
            case applicationARN = "ApplicationARN"
            case applicationVersionId = "ApplicationVersionId"
        }
    }

    public struct DeleteApplicationRequest: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "ApplicationName", required: true, type: .string), 
            AWSShapeMember(label: "CreateTimestamp", required: true, type: .timestamp)
        ]

        /// The name of the application to delete.
        public let applicationName: String
        /// Use the DescribeApplication operation to get this value.
        public let createTimestamp: TimeStamp

        public init(applicationName: String, createTimestamp: TimeStamp) {
            self.applicationName = applicationName
            self.createTimestamp = createTimestamp
        }

        public func validate(name: String) throws {
            try validate(applicationName, name:"applicationName", parent: name, max: 128)
            try validate(applicationName, name:"applicationName", parent: name, min: 1)
            try validate(applicationName, name:"applicationName", parent: name, pattern: "[a-zA-Z0-9_.-]+")
        }

        private enum CodingKeys: String, CodingKey {
            case applicationName = "ApplicationName"
            case createTimestamp = "CreateTimestamp"
        }
    }

    public struct DeleteApplicationResponse: AWSShape {


        public init() {
        }

    }

    public struct DeleteApplicationSnapshotRequest: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "ApplicationName", required: true, type: .string), 
            AWSShapeMember(label: "SnapshotCreationTimestamp", required: true, type: .timestamp), 
            AWSShapeMember(label: "SnapshotName", required: true, type: .string)
        ]

        /// The name of an existing application.
        public let applicationName: String
        /// The creation timestamp of the application snapshot to delete. You can retrieve this value using or .
        public let snapshotCreationTimestamp: TimeStamp
        /// The identifier for the snapshot delete.
        public let snapshotName: String

        public init(applicationName: String, snapshotCreationTimestamp: TimeStamp, snapshotName: String) {
            self.applicationName = applicationName
            self.snapshotCreationTimestamp = snapshotCreationTimestamp
            self.snapshotName = snapshotName
        }

        public func validate(name: String) throws {
            try validate(applicationName, name:"applicationName", parent: name, max: 128)
            try validate(applicationName, name:"applicationName", parent: name, min: 1)
            try validate(applicationName, name:"applicationName", parent: name, pattern: "[a-zA-Z0-9_.-]+")
            try validate(snapshotName, name:"snapshotName", parent: name, max: 128)
            try validate(snapshotName, name:"snapshotName", parent: name, min: 1)
            try validate(snapshotName, name:"snapshotName", parent: name, pattern: "[a-zA-Z0-9_.-]+")
        }

        private enum CodingKeys: String, CodingKey {
            case applicationName = "ApplicationName"
            case snapshotCreationTimestamp = "SnapshotCreationTimestamp"
            case snapshotName = "SnapshotName"
        }
    }

    public struct DeleteApplicationSnapshotResponse: AWSShape {


        public init() {
        }

    }

    public struct DescribeApplicationRequest: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "ApplicationName", required: true, type: .string), 
            AWSShapeMember(label: "IncludeAdditionalDetails", required: false, type: .boolean)
        ]

        /// The name of the application.
        public let applicationName: String
        /// Displays verbose information about a Kinesis Data Analytics application, including the application's job plan.
        public let includeAdditionalDetails: Bool?

        public init(applicationName: String, includeAdditionalDetails: Bool? = nil) {
            self.applicationName = applicationName
            self.includeAdditionalDetails = includeAdditionalDetails
        }

        public func validate(name: String) throws {
            try validate(applicationName, name:"applicationName", parent: name, max: 128)
            try validate(applicationName, name:"applicationName", parent: name, min: 1)
            try validate(applicationName, name:"applicationName", parent: name, pattern: "[a-zA-Z0-9_.-]+")
        }

        private enum CodingKeys: String, CodingKey {
            case applicationName = "ApplicationName"
            case includeAdditionalDetails = "IncludeAdditionalDetails"
        }
    }

    public struct DescribeApplicationResponse: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "ApplicationDetail", required: true, type: .structure)
        ]

        /// Provides a description of the application, such as the application's Amazon Resource Name (ARN), status, and latest version.
        public let applicationDetail: ApplicationDetail

        public init(applicationDetail: ApplicationDetail) {
            self.applicationDetail = applicationDetail
        }

        private enum CodingKeys: String, CodingKey {
            case applicationDetail = "ApplicationDetail"
        }
    }

    public struct DescribeApplicationSnapshotRequest: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "ApplicationName", required: true, type: .string), 
            AWSShapeMember(label: "SnapshotName", required: true, type: .string)
        ]

        /// The name of an existing application.
        public let applicationName: String
        /// The identifier of an application snapshot. You can retrieve this value using .
        public let snapshotName: String

        public init(applicationName: String, snapshotName: String) {
            self.applicationName = applicationName
            self.snapshotName = snapshotName
        }

        public func validate(name: String) throws {
            try validate(applicationName, name:"applicationName", parent: name, max: 128)
            try validate(applicationName, name:"applicationName", parent: name, min: 1)
            try validate(applicationName, name:"applicationName", parent: name, pattern: "[a-zA-Z0-9_.-]+")
            try validate(snapshotName, name:"snapshotName", parent: name, max: 128)
            try validate(snapshotName, name:"snapshotName", parent: name, min: 1)
            try validate(snapshotName, name:"snapshotName", parent: name, pattern: "[a-zA-Z0-9_.-]+")
        }

        private enum CodingKeys: String, CodingKey {
            case applicationName = "ApplicationName"
            case snapshotName = "SnapshotName"
        }
    }

    public struct DescribeApplicationSnapshotResponse: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "SnapshotDetails", required: true, type: .structure)
        ]

        /// An object containing information about the application snapshot.
        public let snapshotDetails: SnapshotDetails

        public init(snapshotDetails: SnapshotDetails) {
            self.snapshotDetails = snapshotDetails
        }

        private enum CodingKeys: String, CodingKey {
            case snapshotDetails = "SnapshotDetails"
        }
    }

    public struct DestinationSchema: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "RecordFormatType", required: true, type: .enum)
        ]

        /// Specifies the format of the records on the output stream.
        public let recordFormatType: RecordFormatType

        public init(recordFormatType: RecordFormatType) {
            self.recordFormatType = recordFormatType
        }

        private enum CodingKeys: String, CodingKey {
            case recordFormatType = "RecordFormatType"
        }
    }

    public struct DiscoverInputSchemaRequest: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "InputProcessingConfiguration", required: false, type: .structure), 
            AWSShapeMember(label: "InputStartingPositionConfiguration", required: false, type: .structure), 
            AWSShapeMember(label: "ResourceARN", required: false, type: .string), 
            AWSShapeMember(label: "S3Configuration", required: false, type: .structure), 
            AWSShapeMember(label: "ServiceExecutionRole", required: true, type: .string)
        ]

        /// The InputProcessingConfiguration to use to preprocess the records before discovering the schema of the records.
        public let inputProcessingConfiguration: InputProcessingConfiguration?
        /// The point at which you want Kinesis Data Analytics to start reading records from the specified streaming source discovery purposes.
        public let inputStartingPositionConfiguration: InputStartingPositionConfiguration?
        /// The Amazon Resource Name (ARN) of the streaming source.
        public let resourceARN: String?
        /// Specify this parameter to discover a schema from data in an Amazon S3 object.
        public let s3Configuration: S3Configuration?
        /// The ARN of the role that is used to access the streaming source.
        public let serviceExecutionRole: String

        public init(inputProcessingConfiguration: InputProcessingConfiguration? = nil, inputStartingPositionConfiguration: InputStartingPositionConfiguration? = nil, resourceARN: String? = nil, s3Configuration: S3Configuration? = nil, serviceExecutionRole: String) {
            self.inputProcessingConfiguration = inputProcessingConfiguration
            self.inputStartingPositionConfiguration = inputStartingPositionConfiguration
            self.resourceARN = resourceARN
            self.s3Configuration = s3Configuration
            self.serviceExecutionRole = serviceExecutionRole
        }

        public func validate(name: String) throws {
            try inputProcessingConfiguration?.validate(name: "\(name).inputProcessingConfiguration")
            try validate(resourceARN, name:"resourceARN", parent: name, max: 2048)
            try validate(resourceARN, name:"resourceARN", parent: name, min: 1)
            try validate(resourceARN, name:"resourceARN", parent: name, pattern: "arn:.*")
            try s3Configuration?.validate(name: "\(name).s3Configuration")
            try validate(serviceExecutionRole, name:"serviceExecutionRole", parent: name, max: 2048)
            try validate(serviceExecutionRole, name:"serviceExecutionRole", parent: name, min: 1)
            try validate(serviceExecutionRole, name:"serviceExecutionRole", parent: name, pattern: "arn:aws:iam::\\d{12}:role/?[a-zA-Z_0-9+=,.@\\-_/]+")
        }

        private enum CodingKeys: String, CodingKey {
            case inputProcessingConfiguration = "InputProcessingConfiguration"
            case inputStartingPositionConfiguration = "InputStartingPositionConfiguration"
            case resourceARN = "ResourceARN"
            case s3Configuration = "S3Configuration"
            case serviceExecutionRole = "ServiceExecutionRole"
        }
    }

    public struct DiscoverInputSchemaResponse: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "InputSchema", required: false, type: .structure), 
            AWSShapeMember(label: "ParsedInputRecords", required: false, type: .list), 
            AWSShapeMember(label: "ProcessedInputRecords", required: false, type: .list), 
            AWSShapeMember(label: "RawInputRecords", required: false, type: .list)
        ]

        /// The schema inferred from the streaming source. It identifies the format of the data in the streaming source and how each data element maps to corresponding columns in the in-application stream that you can create.
        public let inputSchema: SourceSchema?
        /// An array of elements, where each element corresponds to a row in a stream record (a stream record can have more than one row).
        public let parsedInputRecords: [[String]]?
        /// The stream data that was modified by the processor specified in the InputProcessingConfiguration parameter.
        public let processedInputRecords: [String]?
        /// The raw stream data that was sampled to infer the schema.
        public let rawInputRecords: [String]?

        public init(inputSchema: SourceSchema? = nil, parsedInputRecords: [[String]]? = nil, processedInputRecords: [String]? = nil, rawInputRecords: [String]? = nil) {
            self.inputSchema = inputSchema
            self.parsedInputRecords = parsedInputRecords
            self.processedInputRecords = processedInputRecords
            self.rawInputRecords = rawInputRecords
        }

        private enum CodingKeys: String, CodingKey {
            case inputSchema = "InputSchema"
            case parsedInputRecords = "ParsedInputRecords"
            case processedInputRecords = "ProcessedInputRecords"
            case rawInputRecords = "RawInputRecords"
        }
    }

    public struct EnvironmentProperties: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "PropertyGroups", required: true, type: .list)
        ]

        /// Describes the execution property groups.
        public let propertyGroups: [PropertyGroup]

        public init(propertyGroups: [PropertyGroup]) {
            self.propertyGroups = propertyGroups
        }

        public func validate(name: String) throws {
            try propertyGroups.forEach {
                try $0.validate(name: "\(name).propertyGroups[]")
            }
            try validate(propertyGroups, name:"propertyGroups", parent: name, max: 50)
        }

        private enum CodingKeys: String, CodingKey {
            case propertyGroups = "PropertyGroups"
        }
    }

    public struct EnvironmentPropertyDescriptions: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "PropertyGroupDescriptions", required: false, type: .list)
        ]

        /// Describes the execution property groups.
        public let propertyGroupDescriptions: [PropertyGroup]?

        public init(propertyGroupDescriptions: [PropertyGroup]? = nil) {
            self.propertyGroupDescriptions = propertyGroupDescriptions
        }

        private enum CodingKeys: String, CodingKey {
            case propertyGroupDescriptions = "PropertyGroupDescriptions"
        }
    }

    public struct EnvironmentPropertyUpdates: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "PropertyGroups", required: true, type: .list)
        ]

        /// Describes updates to the execution property groups.
        public let propertyGroups: [PropertyGroup]

        public init(propertyGroups: [PropertyGroup]) {
            self.propertyGroups = propertyGroups
        }

        public func validate(name: String) throws {
            try propertyGroups.forEach {
                try $0.validate(name: "\(name).propertyGroups[]")
            }
            try validate(propertyGroups, name:"propertyGroups", parent: name, max: 50)
        }

        private enum CodingKeys: String, CodingKey {
            case propertyGroups = "PropertyGroups"
        }
    }

    public struct FlinkApplicationConfiguration: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "CheckpointConfiguration", required: false, type: .structure), 
            AWSShapeMember(label: "MonitoringConfiguration", required: false, type: .structure), 
            AWSShapeMember(label: "ParallelismConfiguration", required: false, type: .structure)
        ]

        /// Describes an application's checkpointing configuration. Checkpointing is the process of persisting application state for fault tolerance. For more information, see  Checkpoints for Fault Tolerance in the Apache Flink Documentation. 
        public let checkpointConfiguration: CheckpointConfiguration?
        /// Describes configuration parameters for Amazon CloudWatch logging for an application.
        public let monitoringConfiguration: MonitoringConfiguration?
        /// Describes parameters for how an application executes multiple tasks simultaneously.
        public let parallelismConfiguration: ParallelismConfiguration?

        public init(checkpointConfiguration: CheckpointConfiguration? = nil, monitoringConfiguration: MonitoringConfiguration? = nil, parallelismConfiguration: ParallelismConfiguration? = nil) {
            self.checkpointConfiguration = checkpointConfiguration
            self.monitoringConfiguration = monitoringConfiguration
            self.parallelismConfiguration = parallelismConfiguration
        }

        public func validate(name: String) throws {
            try checkpointConfiguration?.validate(name: "\(name).checkpointConfiguration")
            try parallelismConfiguration?.validate(name: "\(name).parallelismConfiguration")
        }

        private enum CodingKeys: String, CodingKey {
            case checkpointConfiguration = "CheckpointConfiguration"
            case monitoringConfiguration = "MonitoringConfiguration"
            case parallelismConfiguration = "ParallelismConfiguration"
        }
    }

    public struct FlinkApplicationConfigurationDescription: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "CheckpointConfigurationDescription", required: false, type: .structure), 
            AWSShapeMember(label: "JobPlanDescription", required: false, type: .string), 
            AWSShapeMember(label: "MonitoringConfigurationDescription", required: false, type: .structure), 
            AWSShapeMember(label: "ParallelismConfigurationDescription", required: false, type: .structure)
        ]

        /// Describes an application's checkpointing configuration. Checkpointing is the process of persisting application state for fault tolerance.
        public let checkpointConfigurationDescription: CheckpointConfigurationDescription?
        /// The job plan for an application. For more information about the job plan, see Jobs and Scheduling in the Apache Flink Documentation. To retrieve the job plan for the application, use the DescribeApplicationRequest$IncludeAdditionalDetails parameter of the DescribeApplication operation.
        public let jobPlanDescription: String?
        /// Describes configuration parameters for Amazon CloudWatch logging for an application.
        public let monitoringConfigurationDescription: MonitoringConfigurationDescription?
        /// Describes parameters for how an application executes multiple tasks simultaneously.
        public let parallelismConfigurationDescription: ParallelismConfigurationDescription?

        public init(checkpointConfigurationDescription: CheckpointConfigurationDescription? = nil, jobPlanDescription: String? = nil, monitoringConfigurationDescription: MonitoringConfigurationDescription? = nil, parallelismConfigurationDescription: ParallelismConfigurationDescription? = nil) {
            self.checkpointConfigurationDescription = checkpointConfigurationDescription
            self.jobPlanDescription = jobPlanDescription
            self.monitoringConfigurationDescription = monitoringConfigurationDescription
            self.parallelismConfigurationDescription = parallelismConfigurationDescription
        }

        private enum CodingKeys: String, CodingKey {
            case checkpointConfigurationDescription = "CheckpointConfigurationDescription"
            case jobPlanDescription = "JobPlanDescription"
            case monitoringConfigurationDescription = "MonitoringConfigurationDescription"
            case parallelismConfigurationDescription = "ParallelismConfigurationDescription"
        }
    }

    public struct FlinkApplicationConfigurationUpdate: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "CheckpointConfigurationUpdate", required: false, type: .structure), 
            AWSShapeMember(label: "MonitoringConfigurationUpdate", required: false, type: .structure), 
            AWSShapeMember(label: "ParallelismConfigurationUpdate", required: false, type: .structure)
        ]

        /// Describes updates to an application's checkpointing configuration. Checkpointing is the process of persisting application state for fault tolerance.
        public let checkpointConfigurationUpdate: CheckpointConfigurationUpdate?
        /// Describes updates to the configuration parameters for Amazon CloudWatch logging for an application.
        public let monitoringConfigurationUpdate: MonitoringConfigurationUpdate?
        /// Describes updates to the parameters for how an application executes multiple tasks simultaneously.
        public let parallelismConfigurationUpdate: ParallelismConfigurationUpdate?

        public init(checkpointConfigurationUpdate: CheckpointConfigurationUpdate? = nil, monitoringConfigurationUpdate: MonitoringConfigurationUpdate? = nil, parallelismConfigurationUpdate: ParallelismConfigurationUpdate? = nil) {
            self.checkpointConfigurationUpdate = checkpointConfigurationUpdate
            self.monitoringConfigurationUpdate = monitoringConfigurationUpdate
            self.parallelismConfigurationUpdate = parallelismConfigurationUpdate
        }

        public func validate(name: String) throws {
            try checkpointConfigurationUpdate?.validate(name: "\(name).checkpointConfigurationUpdate")
            try parallelismConfigurationUpdate?.validate(name: "\(name).parallelismConfigurationUpdate")
        }

        private enum CodingKeys: String, CodingKey {
            case checkpointConfigurationUpdate = "CheckpointConfigurationUpdate"
            case monitoringConfigurationUpdate = "MonitoringConfigurationUpdate"
            case parallelismConfigurationUpdate = "ParallelismConfigurationUpdate"
        }
    }

    public struct Input: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "InputParallelism", required: false, type: .structure), 
            AWSShapeMember(label: "InputProcessingConfiguration", required: false, type: .structure), 
            AWSShapeMember(label: "InputSchema", required: true, type: .structure), 
            AWSShapeMember(label: "KinesisFirehoseInput", required: false, type: .structure), 
            AWSShapeMember(label: "KinesisStreamsInput", required: false, type: .structure), 
            AWSShapeMember(label: "NamePrefix", required: true, type: .string)
        ]

        /// Describes the number of in-application streams to create. 
        public let inputParallelism: InputParallelism?
        /// The InputProcessingConfiguration for the input. An input processor transforms records as they are received from the stream, before the application's SQL code executes. Currently, the only input processing configuration available is InputLambdaProcessor. 
        public let inputProcessingConfiguration: InputProcessingConfiguration?
        /// Describes the format of the data in the streaming source, and how each data element maps to corresponding columns in the in-application stream that is being created. Also used to describe the format of the reference data source.
        public let inputSchema: SourceSchema
        /// If the streaming source is an Amazon Kinesis Data Firehose delivery stream, identifies the delivery stream's ARN.
        public let kinesisFirehoseInput: KinesisFirehoseInput?
        /// If the streaming source is an Amazon Kinesis data stream, identifies the stream's Amazon Resource Name (ARN). 
        public let kinesisStreamsInput: KinesisStreamsInput?
        /// The name prefix to use when creating an in-application stream. Suppose that you specify a prefix "MyInApplicationStream." Kinesis Data Analytics then creates one or more (as per the InputParallelism count you specified) in-application streams with the names "MyInApplicationStream_001," "MyInApplicationStream_002," and so on. 
        public let namePrefix: String

        public init(inputParallelism: InputParallelism? = nil, inputProcessingConfiguration: InputProcessingConfiguration? = nil, inputSchema: SourceSchema, kinesisFirehoseInput: KinesisFirehoseInput? = nil, kinesisStreamsInput: KinesisStreamsInput? = nil, namePrefix: String) {
            self.inputParallelism = inputParallelism
            self.inputProcessingConfiguration = inputProcessingConfiguration
            self.inputSchema = inputSchema
            self.kinesisFirehoseInput = kinesisFirehoseInput
            self.kinesisStreamsInput = kinesisStreamsInput
            self.namePrefix = namePrefix
        }

        public func validate(name: String) throws {
            try inputParallelism?.validate(name: "\(name).inputParallelism")
            try inputProcessingConfiguration?.validate(name: "\(name).inputProcessingConfiguration")
            try inputSchema.validate(name: "\(name).inputSchema")
            try kinesisFirehoseInput?.validate(name: "\(name).kinesisFirehoseInput")
            try kinesisStreamsInput?.validate(name: "\(name).kinesisStreamsInput")
            try validate(namePrefix, name:"namePrefix", parent: name, max: 32)
            try validate(namePrefix, name:"namePrefix", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case inputParallelism = "InputParallelism"
            case inputProcessingConfiguration = "InputProcessingConfiguration"
            case inputSchema = "InputSchema"
            case kinesisFirehoseInput = "KinesisFirehoseInput"
            case kinesisStreamsInput = "KinesisStreamsInput"
            case namePrefix = "NamePrefix"
        }
    }

    public struct InputDescription: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "InAppStreamNames", required: false, type: .list), 
            AWSShapeMember(label: "InputId", required: false, type: .string), 
            AWSShapeMember(label: "InputParallelism", required: false, type: .structure), 
            AWSShapeMember(label: "InputProcessingConfigurationDescription", required: false, type: .structure), 
            AWSShapeMember(label: "InputSchema", required: false, type: .structure), 
            AWSShapeMember(label: "InputStartingPositionConfiguration", required: false, type: .structure), 
            AWSShapeMember(label: "KinesisFirehoseInputDescription", required: false, type: .structure), 
            AWSShapeMember(label: "KinesisStreamsInputDescription", required: false, type: .structure), 
            AWSShapeMember(label: "NamePrefix", required: false, type: .string)
        ]

        /// Returns the in-application stream names that are mapped to the stream source. 
        public let inAppStreamNames: [String]?
        /// The input ID that is associated with the application input. This is the ID that Kinesis Data Analytics assigns to each input configuration that you add to your application. 
        public let inputId: String?
        /// Describes the configured parallelism (number of in-application streams mapped to the streaming source). 
        public let inputParallelism: InputParallelism?
        /// The description of the preprocessor that executes on records in this input before the application's code is run. 
        public let inputProcessingConfigurationDescription: InputProcessingConfigurationDescription?
        /// Describes the format of the data in the streaming source, and how each data element maps to corresponding columns in the in-application stream that is being created. 
        public let inputSchema: SourceSchema?
        /// The point at which the application is configured to read from the input stream.
        public let inputStartingPositionConfiguration: InputStartingPositionConfiguration?
        /// If a Kinesis Data Firehose delivery stream is configured as a streaming source, provides the delivery stream's ARN. 
        public let kinesisFirehoseInputDescription: KinesisFirehoseInputDescription?
        /// If a Kinesis data stream is configured as a streaming source, provides the Kinesis data stream's Amazon Resource Name (ARN). 
        public let kinesisStreamsInputDescription: KinesisStreamsInputDescription?
        /// The in-application name prefix.
        public let namePrefix: String?

        public init(inAppStreamNames: [String]? = nil, inputId: String? = nil, inputParallelism: InputParallelism? = nil, inputProcessingConfigurationDescription: InputProcessingConfigurationDescription? = nil, inputSchema: SourceSchema? = nil, inputStartingPositionConfiguration: InputStartingPositionConfiguration? = nil, kinesisFirehoseInputDescription: KinesisFirehoseInputDescription? = nil, kinesisStreamsInputDescription: KinesisStreamsInputDescription? = nil, namePrefix: String? = nil) {
            self.inAppStreamNames = inAppStreamNames
            self.inputId = inputId
            self.inputParallelism = inputParallelism
            self.inputProcessingConfigurationDescription = inputProcessingConfigurationDescription
            self.inputSchema = inputSchema
            self.inputStartingPositionConfiguration = inputStartingPositionConfiguration
            self.kinesisFirehoseInputDescription = kinesisFirehoseInputDescription
            self.kinesisStreamsInputDescription = kinesisStreamsInputDescription
            self.namePrefix = namePrefix
        }

        private enum CodingKeys: String, CodingKey {
            case inAppStreamNames = "InAppStreamNames"
            case inputId = "InputId"
            case inputParallelism = "InputParallelism"
            case inputProcessingConfigurationDescription = "InputProcessingConfigurationDescription"
            case inputSchema = "InputSchema"
            case inputStartingPositionConfiguration = "InputStartingPositionConfiguration"
            case kinesisFirehoseInputDescription = "KinesisFirehoseInputDescription"
            case kinesisStreamsInputDescription = "KinesisStreamsInputDescription"
            case namePrefix = "NamePrefix"
        }
    }

    public struct InputLambdaProcessor: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "ResourceARN", required: true, type: .string)
        ]

        /// The ARN of the AWS Lambda function that operates on records in the stream.  To specify an earlier version of the Lambda function than the latest, include the Lambda function version in the Lambda function ARN. For more information about Lambda ARNs, see Example ARNs: AWS Lambda  
        public let resourceARN: String

        public init(resourceARN: String) {
            self.resourceARN = resourceARN
        }

        public func validate(name: String) throws {
            try validate(resourceARN, name:"resourceARN", parent: name, max: 2048)
            try validate(resourceARN, name:"resourceARN", parent: name, min: 1)
            try validate(resourceARN, name:"resourceARN", parent: name, pattern: "arn:.*")
        }

        private enum CodingKeys: String, CodingKey {
            case resourceARN = "ResourceARN"
        }
    }

    public struct InputLambdaProcessorDescription: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "ResourceARN", required: true, type: .string), 
            AWSShapeMember(label: "RoleARN", required: false, type: .string)
        ]

        /// The ARN of the AWS Lambda function that is used to preprocess the records in the stream.  To specify an earlier version of the Lambda function than the latest, include the Lambda function version in the Lambda function ARN. For more information about Lambda ARNs, see Example ARNs: AWS Lambda  
        public let resourceARN: String
        /// The ARN of the IAM role that is used to access the AWS Lambda function.  Provided for backward compatibility. Applications that are created with the current API version have an application-level service execution role rather than a resource-level role. 
        public let roleARN: String?

        public init(resourceARN: String, roleARN: String? = nil) {
            self.resourceARN = resourceARN
            self.roleARN = roleARN
        }

        private enum CodingKeys: String, CodingKey {
            case resourceARN = "ResourceARN"
            case roleARN = "RoleARN"
        }
    }

    public struct InputLambdaProcessorUpdate: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "ResourceARNUpdate", required: true, type: .string)
        ]

        /// The Amazon Resource Name (ARN) of the new AWS Lambda function that is used to preprocess the records in the stream.  To specify an earlier version of the Lambda function than the latest, include the Lambda function version in the Lambda function ARN. For more information about Lambda ARNs, see Example ARNs: AWS Lambda  
        public let resourceARNUpdate: String

        public init(resourceARNUpdate: String) {
            self.resourceARNUpdate = resourceARNUpdate
        }

        public func validate(name: String) throws {
            try validate(resourceARNUpdate, name:"resourceARNUpdate", parent: name, max: 2048)
            try validate(resourceARNUpdate, name:"resourceARNUpdate", parent: name, min: 1)
            try validate(resourceARNUpdate, name:"resourceARNUpdate", parent: name, pattern: "arn:.*")
        }

        private enum CodingKeys: String, CodingKey {
            case resourceARNUpdate = "ResourceARNUpdate"
        }
    }

    public struct InputParallelism: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "Count", required: false, type: .integer)
        ]

        /// The number of in-application streams to create.
        public let count: Int?

        public init(count: Int? = nil) {
            self.count = count
        }

        public func validate(name: String) throws {
            try validate(count, name:"count", parent: name, max: 64)
            try validate(count, name:"count", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case count = "Count"
        }
    }

    public struct InputParallelismUpdate: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "CountUpdate", required: true, type: .integer)
        ]

        /// The number of in-application streams to create for the specified streaming source.
        public let countUpdate: Int

        public init(countUpdate: Int) {
            self.countUpdate = countUpdate
        }

        public func validate(name: String) throws {
            try validate(countUpdate, name:"countUpdate", parent: name, max: 64)
            try validate(countUpdate, name:"countUpdate", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case countUpdate = "CountUpdate"
        }
    }

    public struct InputProcessingConfiguration: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "InputLambdaProcessor", required: true, type: .structure)
        ]

        /// The InputLambdaProcessor that is used to preprocess the records in the stream before being processed by your application code.
        public let inputLambdaProcessor: InputLambdaProcessor

        public init(inputLambdaProcessor: InputLambdaProcessor) {
            self.inputLambdaProcessor = inputLambdaProcessor
        }

        public func validate(name: String) throws {
            try inputLambdaProcessor.validate(name: "\(name).inputLambdaProcessor")
        }

        private enum CodingKeys: String, CodingKey {
            case inputLambdaProcessor = "InputLambdaProcessor"
        }
    }

    public struct InputProcessingConfigurationDescription: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "InputLambdaProcessorDescription", required: false, type: .structure)
        ]

        /// Provides configuration information about the associated InputLambdaProcessorDescription 
        public let inputLambdaProcessorDescription: InputLambdaProcessorDescription?

        public init(inputLambdaProcessorDescription: InputLambdaProcessorDescription? = nil) {
            self.inputLambdaProcessorDescription = inputLambdaProcessorDescription
        }

        private enum CodingKeys: String, CodingKey {
            case inputLambdaProcessorDescription = "InputLambdaProcessorDescription"
        }
    }

    public struct InputProcessingConfigurationUpdate: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "InputLambdaProcessorUpdate", required: true, type: .structure)
        ]

        /// Provides update information for an InputLambdaProcessor.
        public let inputLambdaProcessorUpdate: InputLambdaProcessorUpdate

        public init(inputLambdaProcessorUpdate: InputLambdaProcessorUpdate) {
            self.inputLambdaProcessorUpdate = inputLambdaProcessorUpdate
        }

        public func validate(name: String) throws {
            try inputLambdaProcessorUpdate.validate(name: "\(name).inputLambdaProcessorUpdate")
        }

        private enum CodingKeys: String, CodingKey {
            case inputLambdaProcessorUpdate = "InputLambdaProcessorUpdate"
        }
    }

    public struct InputSchemaUpdate: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "RecordColumnUpdates", required: false, type: .list), 
            AWSShapeMember(label: "RecordEncodingUpdate", required: false, type: .string), 
            AWSShapeMember(label: "RecordFormatUpdate", required: false, type: .structure)
        ]

        /// A list of RecordColumn objects. Each object describes the mapping of the streaming source element to the corresponding column in the in-application stream.
        public let recordColumnUpdates: [RecordColumn]?
        /// Specifies the encoding of the records in the streaming source; for example, UTF-8.
        public let recordEncodingUpdate: String?
        /// Specifies the format of the records on the streaming source.
        public let recordFormatUpdate: RecordFormat?

        public init(recordColumnUpdates: [RecordColumn]? = nil, recordEncodingUpdate: String? = nil, recordFormatUpdate: RecordFormat? = nil) {
            self.recordColumnUpdates = recordColumnUpdates
            self.recordEncodingUpdate = recordEncodingUpdate
            self.recordFormatUpdate = recordFormatUpdate
        }

        public func validate(name: String) throws {
            try recordColumnUpdates?.forEach {
                try $0.validate(name: "\(name).recordColumnUpdates[]")
            }
            try validate(recordColumnUpdates, name:"recordColumnUpdates", parent: name, max: 1000)
            try validate(recordColumnUpdates, name:"recordColumnUpdates", parent: name, min: 1)
            try validate(recordEncodingUpdate, name:"recordEncodingUpdate", parent: name, pattern: "UTF-8")
            try recordFormatUpdate?.validate(name: "\(name).recordFormatUpdate")
        }

        private enum CodingKeys: String, CodingKey {
            case recordColumnUpdates = "RecordColumnUpdates"
            case recordEncodingUpdate = "RecordEncodingUpdate"
            case recordFormatUpdate = "RecordFormatUpdate"
        }
    }

    public enum InputStartingPosition: String, CustomStringConvertible, Codable {
        case now = "NOW"
        case trimHorizon = "TRIM_HORIZON"
        case lastStoppedPoint = "LAST_STOPPED_POINT"
        public var description: String { return self.rawValue }
    }

    public struct InputStartingPositionConfiguration: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "InputStartingPosition", required: false, type: .enum)
        ]

        /// The starting position on the stream.    NOW - Start reading just after the most recent record in the stream, and start at the request timestamp that the customer issued.    TRIM_HORIZON - Start reading at the last untrimmed record in the stream, which is the oldest record available in the stream. This option is not available for an Amazon Kinesis Data Firehose delivery stream.    LAST_STOPPED_POINT - Resume reading from where the application last stopped reading.  
        public let inputStartingPosition: InputStartingPosition?

        public init(inputStartingPosition: InputStartingPosition? = nil) {
            self.inputStartingPosition = inputStartingPosition
        }

        private enum CodingKeys: String, CodingKey {
            case inputStartingPosition = "InputStartingPosition"
        }
    }

    public struct InputUpdate: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "InputId", required: true, type: .string), 
            AWSShapeMember(label: "InputParallelismUpdate", required: false, type: .structure), 
            AWSShapeMember(label: "InputProcessingConfigurationUpdate", required: false, type: .structure), 
            AWSShapeMember(label: "InputSchemaUpdate", required: false, type: .structure), 
            AWSShapeMember(label: "KinesisFirehoseInputUpdate", required: false, type: .structure), 
            AWSShapeMember(label: "KinesisStreamsInputUpdate", required: false, type: .structure), 
            AWSShapeMember(label: "NamePrefixUpdate", required: false, type: .string)
        ]

        /// The input ID of the application input to be updated.
        public let inputId: String
        /// Describes the parallelism updates (the number of in-application streams Kinesis Data Analytics creates for the specific streaming source).
        public let inputParallelismUpdate: InputParallelismUpdate?
        /// Describes updates to an InputProcessingConfiguration.
        public let inputProcessingConfigurationUpdate: InputProcessingConfigurationUpdate?
        /// Describes the data format on the streaming source, and how record elements on the streaming source map to columns of the in-application stream that is created.
        public let inputSchemaUpdate: InputSchemaUpdate?
        /// If a Kinesis Data Firehose delivery stream is the streaming source to be updated, provides an updated stream ARN.
        public let kinesisFirehoseInputUpdate: KinesisFirehoseInputUpdate?
        /// If a Kinesis data stream is the streaming source to be updated, provides an updated stream Amazon Resource Name (ARN).
        public let kinesisStreamsInputUpdate: KinesisStreamsInputUpdate?
        /// The name prefix for in-application streams that Kinesis Data Analytics creates for the specific streaming source.
        public let namePrefixUpdate: String?

        public init(inputId: String, inputParallelismUpdate: InputParallelismUpdate? = nil, inputProcessingConfigurationUpdate: InputProcessingConfigurationUpdate? = nil, inputSchemaUpdate: InputSchemaUpdate? = nil, kinesisFirehoseInputUpdate: KinesisFirehoseInputUpdate? = nil, kinesisStreamsInputUpdate: KinesisStreamsInputUpdate? = nil, namePrefixUpdate: String? = nil) {
            self.inputId = inputId
            self.inputParallelismUpdate = inputParallelismUpdate
            self.inputProcessingConfigurationUpdate = inputProcessingConfigurationUpdate
            self.inputSchemaUpdate = inputSchemaUpdate
            self.kinesisFirehoseInputUpdate = kinesisFirehoseInputUpdate
            self.kinesisStreamsInputUpdate = kinesisStreamsInputUpdate
            self.namePrefixUpdate = namePrefixUpdate
        }

        public func validate(name: String) throws {
            try validate(inputId, name:"inputId", parent: name, max: 50)
            try validate(inputId, name:"inputId", parent: name, min: 1)
            try validate(inputId, name:"inputId", parent: name, pattern: "[a-zA-Z0-9_.-]+")
            try inputParallelismUpdate?.validate(name: "\(name).inputParallelismUpdate")
            try inputProcessingConfigurationUpdate?.validate(name: "\(name).inputProcessingConfigurationUpdate")
            try inputSchemaUpdate?.validate(name: "\(name).inputSchemaUpdate")
            try kinesisFirehoseInputUpdate?.validate(name: "\(name).kinesisFirehoseInputUpdate")
            try kinesisStreamsInputUpdate?.validate(name: "\(name).kinesisStreamsInputUpdate")
            try validate(namePrefixUpdate, name:"namePrefixUpdate", parent: name, max: 32)
            try validate(namePrefixUpdate, name:"namePrefixUpdate", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case inputId = "InputId"
            case inputParallelismUpdate = "InputParallelismUpdate"
            case inputProcessingConfigurationUpdate = "InputProcessingConfigurationUpdate"
            case inputSchemaUpdate = "InputSchemaUpdate"
            case kinesisFirehoseInputUpdate = "KinesisFirehoseInputUpdate"
            case kinesisStreamsInputUpdate = "KinesisStreamsInputUpdate"
            case namePrefixUpdate = "NamePrefixUpdate"
        }
    }

    public struct JSONMappingParameters: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "RecordRowPath", required: true, type: .string)
        ]

        /// The path to the top-level parent that contains the records.
        public let recordRowPath: String

        public init(recordRowPath: String) {
            self.recordRowPath = recordRowPath
        }

        public func validate(name: String) throws {
            try validate(recordRowPath, name:"recordRowPath", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case recordRowPath = "RecordRowPath"
        }
    }

    public struct KinesisFirehoseInput: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "ResourceARN", required: true, type: .string)
        ]

        /// The Amazon Resource Name (ARN) of the delivery stream.
        public let resourceARN: String

        public init(resourceARN: String) {
            self.resourceARN = resourceARN
        }

        public func validate(name: String) throws {
            try validate(resourceARN, name:"resourceARN", parent: name, max: 2048)
            try validate(resourceARN, name:"resourceARN", parent: name, min: 1)
            try validate(resourceARN, name:"resourceARN", parent: name, pattern: "arn:.*")
        }

        private enum CodingKeys: String, CodingKey {
            case resourceARN = "ResourceARN"
        }
    }

    public struct KinesisFirehoseInputDescription: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "ResourceARN", required: true, type: .string), 
            AWSShapeMember(label: "RoleARN", required: false, type: .string)
        ]

        /// The Amazon Resource Name (ARN) of the delivery stream.
        public let resourceARN: String
        /// The ARN of the IAM role that Kinesis Data Analytics assumes to access the stream.  Provided for backward compatibility. Applications that are created with the current API version have an application-level service execution role rather than a resource-level role. 
        public let roleARN: String?

        public init(resourceARN: String, roleARN: String? = nil) {
            self.resourceARN = resourceARN
            self.roleARN = roleARN
        }

        private enum CodingKeys: String, CodingKey {
            case resourceARN = "ResourceARN"
            case roleARN = "RoleARN"
        }
    }

    public struct KinesisFirehoseInputUpdate: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "ResourceARNUpdate", required: true, type: .string)
        ]

        /// The Amazon Resource Name (ARN) of the input delivery stream to read.
        public let resourceARNUpdate: String

        public init(resourceARNUpdate: String) {
            self.resourceARNUpdate = resourceARNUpdate
        }

        public func validate(name: String) throws {
            try validate(resourceARNUpdate, name:"resourceARNUpdate", parent: name, max: 2048)
            try validate(resourceARNUpdate, name:"resourceARNUpdate", parent: name, min: 1)
            try validate(resourceARNUpdate, name:"resourceARNUpdate", parent: name, pattern: "arn:.*")
        }

        private enum CodingKeys: String, CodingKey {
            case resourceARNUpdate = "ResourceARNUpdate"
        }
    }

    public struct KinesisFirehoseOutput: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "ResourceARN", required: true, type: .string)
        ]

        /// The ARN of the destination delivery stream to write to.
        public let resourceARN: String

        public init(resourceARN: String) {
            self.resourceARN = resourceARN
        }

        public func validate(name: String) throws {
            try validate(resourceARN, name:"resourceARN", parent: name, max: 2048)
            try validate(resourceARN, name:"resourceARN", parent: name, min: 1)
            try validate(resourceARN, name:"resourceARN", parent: name, pattern: "arn:.*")
        }

        private enum CodingKeys: String, CodingKey {
            case resourceARN = "ResourceARN"
        }
    }

    public struct KinesisFirehoseOutputDescription: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "ResourceARN", required: true, type: .string), 
            AWSShapeMember(label: "RoleARN", required: false, type: .string)
        ]

        /// The Amazon Resource Name (ARN) of the delivery stream.
        public let resourceARN: String
        /// The ARN of the IAM role that Kinesis Data Analytics can assume to access the stream.  Provided for backward compatibility. Applications that are created with the current API version have an application-level service execution role rather than a resource-level role. 
        public let roleARN: String?

        public init(resourceARN: String, roleARN: String? = nil) {
            self.resourceARN = resourceARN
            self.roleARN = roleARN
        }

        private enum CodingKeys: String, CodingKey {
            case resourceARN = "ResourceARN"
            case roleARN = "RoleARN"
        }
    }

    public struct KinesisFirehoseOutputUpdate: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "ResourceARNUpdate", required: true, type: .string)
        ]

        /// The Amazon Resource Name (ARN) of the delivery stream to write to. 
        public let resourceARNUpdate: String

        public init(resourceARNUpdate: String) {
            self.resourceARNUpdate = resourceARNUpdate
        }

        public func validate(name: String) throws {
            try validate(resourceARNUpdate, name:"resourceARNUpdate", parent: name, max: 2048)
            try validate(resourceARNUpdate, name:"resourceARNUpdate", parent: name, min: 1)
            try validate(resourceARNUpdate, name:"resourceARNUpdate", parent: name, pattern: "arn:.*")
        }

        private enum CodingKeys: String, CodingKey {
            case resourceARNUpdate = "ResourceARNUpdate"
        }
    }

    public struct KinesisStreamsInput: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "ResourceARN", required: true, type: .string)
        ]

        /// The ARN of the input Kinesis data stream to read.
        public let resourceARN: String

        public init(resourceARN: String) {
            self.resourceARN = resourceARN
        }

        public func validate(name: String) throws {
            try validate(resourceARN, name:"resourceARN", parent: name, max: 2048)
            try validate(resourceARN, name:"resourceARN", parent: name, min: 1)
            try validate(resourceARN, name:"resourceARN", parent: name, pattern: "arn:.*")
        }

        private enum CodingKeys: String, CodingKey {
            case resourceARN = "ResourceARN"
        }
    }

    public struct KinesisStreamsInputDescription: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "ResourceARN", required: true, type: .string), 
            AWSShapeMember(label: "RoleARN", required: false, type: .string)
        ]

        /// The Amazon Resource Name (ARN) of the Kinesis data stream.
        public let resourceARN: String
        /// The ARN of the IAM role that Kinesis Data Analytics can assume to access the stream.  Provided for backward compatibility. Applications that are created with the current API version have an application-level service execution role rather than a resource-level role. 
        public let roleARN: String?

        public init(resourceARN: String, roleARN: String? = nil) {
            self.resourceARN = resourceARN
            self.roleARN = roleARN
        }

        private enum CodingKeys: String, CodingKey {
            case resourceARN = "ResourceARN"
            case roleARN = "RoleARN"
        }
    }

    public struct KinesisStreamsInputUpdate: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "ResourceARNUpdate", required: true, type: .string)
        ]

        /// The Amazon Resource Name (ARN) of the input Kinesis data stream to read.
        public let resourceARNUpdate: String

        public init(resourceARNUpdate: String) {
            self.resourceARNUpdate = resourceARNUpdate
        }

        public func validate(name: String) throws {
            try validate(resourceARNUpdate, name:"resourceARNUpdate", parent: name, max: 2048)
            try validate(resourceARNUpdate, name:"resourceARNUpdate", parent: name, min: 1)
            try validate(resourceARNUpdate, name:"resourceARNUpdate", parent: name, pattern: "arn:.*")
        }

        private enum CodingKeys: String, CodingKey {
            case resourceARNUpdate = "ResourceARNUpdate"
        }
    }

    public struct KinesisStreamsOutput: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "ResourceARN", required: true, type: .string)
        ]

        /// The ARN of the destination Kinesis data stream to write to.
        public let resourceARN: String

        public init(resourceARN: String) {
            self.resourceARN = resourceARN
        }

        public func validate(name: String) throws {
            try validate(resourceARN, name:"resourceARN", parent: name, max: 2048)
            try validate(resourceARN, name:"resourceARN", parent: name, min: 1)
            try validate(resourceARN, name:"resourceARN", parent: name, pattern: "arn:.*")
        }

        private enum CodingKeys: String, CodingKey {
            case resourceARN = "ResourceARN"
        }
    }

    public struct KinesisStreamsOutputDescription: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "ResourceARN", required: true, type: .string), 
            AWSShapeMember(label: "RoleARN", required: false, type: .string)
        ]

        /// The Amazon Resource Name (ARN) of the Kinesis data stream.
        public let resourceARN: String
        /// The ARN of the IAM role that Kinesis Data Analytics can assume to access the stream.  Provided for backward compatibility. Applications that are created with the current API version have an application-level service execution role rather than a resource-level role. 
        public let roleARN: String?

        public init(resourceARN: String, roleARN: String? = nil) {
            self.resourceARN = resourceARN
            self.roleARN = roleARN
        }

        private enum CodingKeys: String, CodingKey {
            case resourceARN = "ResourceARN"
            case roleARN = "RoleARN"
        }
    }

    public struct KinesisStreamsOutputUpdate: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "ResourceARNUpdate", required: true, type: .string)
        ]

        /// The Amazon Resource Name (ARN) of the Kinesis data stream where you want to write the output.
        public let resourceARNUpdate: String

        public init(resourceARNUpdate: String) {
            self.resourceARNUpdate = resourceARNUpdate
        }

        public func validate(name: String) throws {
            try validate(resourceARNUpdate, name:"resourceARNUpdate", parent: name, max: 2048)
            try validate(resourceARNUpdate, name:"resourceARNUpdate", parent: name, min: 1)
            try validate(resourceARNUpdate, name:"resourceARNUpdate", parent: name, pattern: "arn:.*")
        }

        private enum CodingKeys: String, CodingKey {
            case resourceARNUpdate = "ResourceARNUpdate"
        }
    }

    public struct LambdaOutput: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "ResourceARN", required: true, type: .string)
        ]

        /// The Amazon Resource Name (ARN) of the destination Lambda function to write to.  To specify an earlier version of the Lambda function than the latest, include the Lambda function version in the Lambda function ARN. For more information about Lambda ARNs, see Example ARNs: AWS Lambda  
        public let resourceARN: String

        public init(resourceARN: String) {
            self.resourceARN = resourceARN
        }

        public func validate(name: String) throws {
            try validate(resourceARN, name:"resourceARN", parent: name, max: 2048)
            try validate(resourceARN, name:"resourceARN", parent: name, min: 1)
            try validate(resourceARN, name:"resourceARN", parent: name, pattern: "arn:.*")
        }

        private enum CodingKeys: String, CodingKey {
            case resourceARN = "ResourceARN"
        }
    }

    public struct LambdaOutputDescription: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "ResourceARN", required: true, type: .string), 
            AWSShapeMember(label: "RoleARN", required: false, type: .string)
        ]

        /// The Amazon Resource Name (ARN) of the destination Lambda function.
        public let resourceARN: String
        /// The ARN of the IAM role that Kinesis Data Analytics can assume to write to the destination function.  Provided for backward compatibility. Applications that are created with the current API version have an application-level service execution role rather than a resource-level role. 
        public let roleARN: String?

        public init(resourceARN: String, roleARN: String? = nil) {
            self.resourceARN = resourceARN
            self.roleARN = roleARN
        }

        private enum CodingKeys: String, CodingKey {
            case resourceARN = "ResourceARN"
            case roleARN = "RoleARN"
        }
    }

    public struct LambdaOutputUpdate: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "ResourceARNUpdate", required: true, type: .string)
        ]

        /// The Amazon Resource Name (ARN) of the destination AWS Lambda function.  To specify an earlier version of the Lambda function than the latest, include the Lambda function version in the Lambda function ARN. For more information about Lambda ARNs, see Example ARNs: AWS Lambda  
        public let resourceARNUpdate: String

        public init(resourceARNUpdate: String) {
            self.resourceARNUpdate = resourceARNUpdate
        }

        public func validate(name: String) throws {
            try validate(resourceARNUpdate, name:"resourceARNUpdate", parent: name, max: 2048)
            try validate(resourceARNUpdate, name:"resourceARNUpdate", parent: name, min: 1)
            try validate(resourceARNUpdate, name:"resourceARNUpdate", parent: name, pattern: "arn:.*")
        }

        private enum CodingKeys: String, CodingKey {
            case resourceARNUpdate = "ResourceARNUpdate"
        }
    }

    public struct ListApplicationSnapshotsRequest: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "ApplicationName", required: true, type: .string), 
            AWSShapeMember(label: "Limit", required: false, type: .integer), 
            AWSShapeMember(label: "NextToken", required: false, type: .string)
        ]

        /// The name of an existing application.
        public let applicationName: String
        /// The maximum number of application snapshots to list.
        public let limit: Int?
        /// Use this parameter if you receive a NextToken response in a previous request that indicates that there is more output available. Set it to the value of the previous call's NextToken response to indicate where the output should continue from. 
        public let nextToken: String?

        public init(applicationName: String, limit: Int? = nil, nextToken: String? = nil) {
            self.applicationName = applicationName
            self.limit = limit
            self.nextToken = nextToken
        }

        public func validate(name: String) throws {
            try validate(applicationName, name:"applicationName", parent: name, max: 128)
            try validate(applicationName, name:"applicationName", parent: name, min: 1)
            try validate(applicationName, name:"applicationName", parent: name, pattern: "[a-zA-Z0-9_.-]+")
            try validate(limit, name:"limit", parent: name, max: 50)
            try validate(limit, name:"limit", parent: name, min: 1)
            try validate(nextToken, name:"nextToken", parent: name, max: 512)
            try validate(nextToken, name:"nextToken", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case applicationName = "ApplicationName"
            case limit = "Limit"
            case nextToken = "NextToken"
        }
    }

    public struct ListApplicationSnapshotsResponse: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "NextToken", required: false, type: .string), 
            AWSShapeMember(label: "SnapshotSummaries", required: false, type: .list)
        ]

        /// The token for the next set of results, or null if there are no additional results.
        public let nextToken: String?
        /// A collection of objects containing information about the application snapshots.
        public let snapshotSummaries: [SnapshotDetails]?

        public init(nextToken: String? = nil, snapshotSummaries: [SnapshotDetails]? = nil) {
            self.nextToken = nextToken
            self.snapshotSummaries = snapshotSummaries
        }

        private enum CodingKeys: String, CodingKey {
            case nextToken = "NextToken"
            case snapshotSummaries = "SnapshotSummaries"
        }
    }

    public struct ListApplicationsRequest: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "Limit", required: false, type: .integer), 
            AWSShapeMember(label: "NextToken", required: false, type: .string)
        ]

        /// The maximum number of applications to list.
        public let limit: Int?
        /// If a previous command returned a pagination token, pass it into this value to retrieve the next set of results. For more information about pagination, see Using the AWS Command Line Interface's Pagination Options.
        public let nextToken: String?

        public init(limit: Int? = nil, nextToken: String? = nil) {
            self.limit = limit
            self.nextToken = nextToken
        }

        public func validate(name: String) throws {
            try validate(limit, name:"limit", parent: name, max: 50)
            try validate(limit, name:"limit", parent: name, min: 1)
            try validate(nextToken, name:"nextToken", parent: name, max: 128)
            try validate(nextToken, name:"nextToken", parent: name, min: 1)
            try validate(nextToken, name:"nextToken", parent: name, pattern: "[a-zA-Z0-9_.-]+")
        }

        private enum CodingKeys: String, CodingKey {
            case limit = "Limit"
            case nextToken = "NextToken"
        }
    }

    public struct ListApplicationsResponse: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "ApplicationSummaries", required: true, type: .list), 
            AWSShapeMember(label: "NextToken", required: false, type: .string)
        ]

        /// A list of ApplicationSummary objects.
        public let applicationSummaries: [ApplicationSummary]
        /// The pagination token for the next set of results, or null if there are no additional results. Pass this token into a subsequent command to retrieve the next set of items For more information about pagination, see Using the AWS Command Line Interface's Pagination Options.
        public let nextToken: String?

        public init(applicationSummaries: [ApplicationSummary], nextToken: String? = nil) {
            self.applicationSummaries = applicationSummaries
            self.nextToken = nextToken
        }

        private enum CodingKeys: String, CodingKey {
            case applicationSummaries = "ApplicationSummaries"
            case nextToken = "NextToken"
        }
    }

    public struct ListTagsForResourceRequest: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "ResourceARN", required: true, type: .string)
        ]

        /// The ARN of the application for which to retrieve tags.
        public let resourceARN: String

        public init(resourceARN: String) {
            self.resourceARN = resourceARN
        }

        public func validate(name: String) throws {
            try validate(resourceARN, name:"resourceARN", parent: name, max: 2048)
            try validate(resourceARN, name:"resourceARN", parent: name, min: 1)
            try validate(resourceARN, name:"resourceARN", parent: name, pattern: "arn:aws:kinesisanalytics:[a-z]{2}-[a-z]+-\\d{1}+:\\d{12}+:application/[a-zA-Z0-9_.-]{1,128}")
        }

        private enum CodingKeys: String, CodingKey {
            case resourceARN = "ResourceARN"
        }
    }

    public struct ListTagsForResourceResponse: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "Tags", required: false, type: .list)
        ]

        /// The key-value tags assigned to the application.
        public let tags: [Tag]?

        public init(tags: [Tag]? = nil) {
            self.tags = tags
        }

        private enum CodingKeys: String, CodingKey {
            case tags = "Tags"
        }
    }

    public enum LogLevel: String, CustomStringConvertible, Codable {
        case info = "INFO"
        case warn = "WARN"
        case error = "ERROR"
        case debug = "DEBUG"
        public var description: String { return self.rawValue }
    }

    public struct MappingParameters: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "CSVMappingParameters", required: false, type: .structure), 
            AWSShapeMember(label: "JSONMappingParameters", required: false, type: .structure)
        ]

        /// Provides additional mapping information when the record format uses delimiters (for example, CSV).
        public let cSVMappingParameters: CSVMappingParameters?
        /// Provides additional mapping information when JSON is the record format on the streaming source.
        public let jSONMappingParameters: JSONMappingParameters?

        public init(cSVMappingParameters: CSVMappingParameters? = nil, jSONMappingParameters: JSONMappingParameters? = nil) {
            self.cSVMappingParameters = cSVMappingParameters
            self.jSONMappingParameters = jSONMappingParameters
        }

        public func validate(name: String) throws {
            try cSVMappingParameters?.validate(name: "\(name).cSVMappingParameters")
            try jSONMappingParameters?.validate(name: "\(name).jSONMappingParameters")
        }

        private enum CodingKeys: String, CodingKey {
            case cSVMappingParameters = "CSVMappingParameters"
            case jSONMappingParameters = "JSONMappingParameters"
        }
    }

    public enum MetricsLevel: String, CustomStringConvertible, Codable {
        case application = "APPLICATION"
        case task = "TASK"
        case `operator` = "OPERATOR"
        case parallelism = "PARALLELISM"
        public var description: String { return self.rawValue }
    }

    public struct MonitoringConfiguration: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "ConfigurationType", required: true, type: .enum), 
            AWSShapeMember(label: "LogLevel", required: false, type: .enum), 
            AWSShapeMember(label: "MetricsLevel", required: false, type: .enum)
        ]

        /// Describes whether to use the default CloudWatch logging configuration for an application.
        public let configurationType: ConfigurationType
        /// Describes the verbosity of the CloudWatch Logs for an application.
        public let logLevel: LogLevel?
        /// Describes the granularity of the CloudWatch Logs for an application.
        public let metricsLevel: MetricsLevel?

        public init(configurationType: ConfigurationType, logLevel: LogLevel? = nil, metricsLevel: MetricsLevel? = nil) {
            self.configurationType = configurationType
            self.logLevel = logLevel
            self.metricsLevel = metricsLevel
        }

        private enum CodingKeys: String, CodingKey {
            case configurationType = "ConfigurationType"
            case logLevel = "LogLevel"
            case metricsLevel = "MetricsLevel"
        }
    }

    public struct MonitoringConfigurationDescription: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "ConfigurationType", required: false, type: .enum), 
            AWSShapeMember(label: "LogLevel", required: false, type: .enum), 
            AWSShapeMember(label: "MetricsLevel", required: false, type: .enum)
        ]

        /// Describes whether to use the default CloudWatch logging configuration for an application.
        public let configurationType: ConfigurationType?
        /// Describes the verbosity of the CloudWatch Logs for an application.
        public let logLevel: LogLevel?
        /// Describes the granularity of the CloudWatch Logs for an application.
        public let metricsLevel: MetricsLevel?

        public init(configurationType: ConfigurationType? = nil, logLevel: LogLevel? = nil, metricsLevel: MetricsLevel? = nil) {
            self.configurationType = configurationType
            self.logLevel = logLevel
            self.metricsLevel = metricsLevel
        }

        private enum CodingKeys: String, CodingKey {
            case configurationType = "ConfigurationType"
            case logLevel = "LogLevel"
            case metricsLevel = "MetricsLevel"
        }
    }

    public struct MonitoringConfigurationUpdate: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "ConfigurationTypeUpdate", required: false, type: .enum), 
            AWSShapeMember(label: "LogLevelUpdate", required: false, type: .enum), 
            AWSShapeMember(label: "MetricsLevelUpdate", required: false, type: .enum)
        ]

        /// Describes updates to whether to use the default CloudWatch logging configuration for an application.
        public let configurationTypeUpdate: ConfigurationType?
        /// Describes updates to the verbosity of the CloudWatch Logs for an application.
        public let logLevelUpdate: LogLevel?
        /// Describes updates to the granularity of the CloudWatch Logs for an application.
        public let metricsLevelUpdate: MetricsLevel?

        public init(configurationTypeUpdate: ConfigurationType? = nil, logLevelUpdate: LogLevel? = nil, metricsLevelUpdate: MetricsLevel? = nil) {
            self.configurationTypeUpdate = configurationTypeUpdate
            self.logLevelUpdate = logLevelUpdate
            self.metricsLevelUpdate = metricsLevelUpdate
        }

        private enum CodingKeys: String, CodingKey {
            case configurationTypeUpdate = "ConfigurationTypeUpdate"
            case logLevelUpdate = "LogLevelUpdate"
            case metricsLevelUpdate = "MetricsLevelUpdate"
        }
    }

    public struct Output: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "DestinationSchema", required: true, type: .structure), 
            AWSShapeMember(label: "KinesisFirehoseOutput", required: false, type: .structure), 
            AWSShapeMember(label: "KinesisStreamsOutput", required: false, type: .structure), 
            AWSShapeMember(label: "LambdaOutput", required: false, type: .structure), 
            AWSShapeMember(label: "Name", required: true, type: .string)
        ]

        /// Describes the data format when records are written to the destination. 
        public let destinationSchema: DestinationSchema
        /// Identifies an Amazon Kinesis Data Firehose delivery stream as the destination.
        public let kinesisFirehoseOutput: KinesisFirehoseOutput?
        /// Identifies an Amazon Kinesis data stream as the destination.
        public let kinesisStreamsOutput: KinesisStreamsOutput?
        /// Identifies an AWS Lambda function as the destination.
        public let lambdaOutput: LambdaOutput?
        /// The name of the in-application stream.
        public let name: String

        public init(destinationSchema: DestinationSchema, kinesisFirehoseOutput: KinesisFirehoseOutput? = nil, kinesisStreamsOutput: KinesisStreamsOutput? = nil, lambdaOutput: LambdaOutput? = nil, name: String) {
            self.destinationSchema = destinationSchema
            self.kinesisFirehoseOutput = kinesisFirehoseOutput
            self.kinesisStreamsOutput = kinesisStreamsOutput
            self.lambdaOutput = lambdaOutput
            self.name = name
        }

        public func validate(name: String) throws {
            try kinesisFirehoseOutput?.validate(name: "\(name).kinesisFirehoseOutput")
            try kinesisStreamsOutput?.validate(name: "\(name).kinesisStreamsOutput")
            try lambdaOutput?.validate(name: "\(name).lambdaOutput")
            try validate(name, name:"name", parent: name, max: 32)
            try validate(name, name:"name", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case destinationSchema = "DestinationSchema"
            case kinesisFirehoseOutput = "KinesisFirehoseOutput"
            case kinesisStreamsOutput = "KinesisStreamsOutput"
            case lambdaOutput = "LambdaOutput"
            case name = "Name"
        }
    }

    public struct OutputDescription: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "DestinationSchema", required: false, type: .structure), 
            AWSShapeMember(label: "KinesisFirehoseOutputDescription", required: false, type: .structure), 
            AWSShapeMember(label: "KinesisStreamsOutputDescription", required: false, type: .structure), 
            AWSShapeMember(label: "LambdaOutputDescription", required: false, type: .structure), 
            AWSShapeMember(label: "Name", required: false, type: .string), 
            AWSShapeMember(label: "OutputId", required: false, type: .string)
        ]

        /// The data format used for writing data to the destination.
        public let destinationSchema: DestinationSchema?
        /// Describes the Kinesis Data Firehose delivery stream that is configured as the destination where output is written.
        public let kinesisFirehoseOutputDescription: KinesisFirehoseOutputDescription?
        /// Describes the Kinesis data stream that is configured as the destination where output is written.
        public let kinesisStreamsOutputDescription: KinesisStreamsOutputDescription?
        /// Describes the Lambda function that is configured as the destination where output is written.
        public let lambdaOutputDescription: LambdaOutputDescription?
        /// The name of the in-application stream that is configured as output.
        public let name: String?
        /// A unique identifier for the output configuration.
        public let outputId: String?

        public init(destinationSchema: DestinationSchema? = nil, kinesisFirehoseOutputDescription: KinesisFirehoseOutputDescription? = nil, kinesisStreamsOutputDescription: KinesisStreamsOutputDescription? = nil, lambdaOutputDescription: LambdaOutputDescription? = nil, name: String? = nil, outputId: String? = nil) {
            self.destinationSchema = destinationSchema
            self.kinesisFirehoseOutputDescription = kinesisFirehoseOutputDescription
            self.kinesisStreamsOutputDescription = kinesisStreamsOutputDescription
            self.lambdaOutputDescription = lambdaOutputDescription
            self.name = name
            self.outputId = outputId
        }

        private enum CodingKeys: String, CodingKey {
            case destinationSchema = "DestinationSchema"
            case kinesisFirehoseOutputDescription = "KinesisFirehoseOutputDescription"
            case kinesisStreamsOutputDescription = "KinesisStreamsOutputDescription"
            case lambdaOutputDescription = "LambdaOutputDescription"
            case name = "Name"
            case outputId = "OutputId"
        }
    }

    public struct OutputUpdate: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "DestinationSchemaUpdate", required: false, type: .structure), 
            AWSShapeMember(label: "KinesisFirehoseOutputUpdate", required: false, type: .structure), 
            AWSShapeMember(label: "KinesisStreamsOutputUpdate", required: false, type: .structure), 
            AWSShapeMember(label: "LambdaOutputUpdate", required: false, type: .structure), 
            AWSShapeMember(label: "NameUpdate", required: false, type: .string), 
            AWSShapeMember(label: "OutputId", required: true, type: .string)
        ]

        /// Describes the data format when records are written to the destination. 
        public let destinationSchemaUpdate: DestinationSchema?
        /// Describes a Kinesis Data Firehose delivery stream as the destination for the output.
        public let kinesisFirehoseOutputUpdate: KinesisFirehoseOutputUpdate?
        /// Describes a Kinesis data stream as the destination for the output.
        public let kinesisStreamsOutputUpdate: KinesisStreamsOutputUpdate?
        /// Describes an AWS Lambda function as the destination for the output.
        public let lambdaOutputUpdate: LambdaOutputUpdate?
        /// If you want to specify a different in-application stream for this output configuration, use this field to specify the new in-application stream name.
        public let nameUpdate: String?
        /// Identifies the specific output configuration that you want to update.
        public let outputId: String

        public init(destinationSchemaUpdate: DestinationSchema? = nil, kinesisFirehoseOutputUpdate: KinesisFirehoseOutputUpdate? = nil, kinesisStreamsOutputUpdate: KinesisStreamsOutputUpdate? = nil, lambdaOutputUpdate: LambdaOutputUpdate? = nil, nameUpdate: String? = nil, outputId: String) {
            self.destinationSchemaUpdate = destinationSchemaUpdate
            self.kinesisFirehoseOutputUpdate = kinesisFirehoseOutputUpdate
            self.kinesisStreamsOutputUpdate = kinesisStreamsOutputUpdate
            self.lambdaOutputUpdate = lambdaOutputUpdate
            self.nameUpdate = nameUpdate
            self.outputId = outputId
        }

        public func validate(name: String) throws {
            try kinesisFirehoseOutputUpdate?.validate(name: "\(name).kinesisFirehoseOutputUpdate")
            try kinesisStreamsOutputUpdate?.validate(name: "\(name).kinesisStreamsOutputUpdate")
            try lambdaOutputUpdate?.validate(name: "\(name).lambdaOutputUpdate")
            try validate(nameUpdate, name:"nameUpdate", parent: name, max: 32)
            try validate(nameUpdate, name:"nameUpdate", parent: name, min: 1)
            try validate(outputId, name:"outputId", parent: name, max: 50)
            try validate(outputId, name:"outputId", parent: name, min: 1)
            try validate(outputId, name:"outputId", parent: name, pattern: "[a-zA-Z0-9_.-]+")
        }

        private enum CodingKeys: String, CodingKey {
            case destinationSchemaUpdate = "DestinationSchemaUpdate"
            case kinesisFirehoseOutputUpdate = "KinesisFirehoseOutputUpdate"
            case kinesisStreamsOutputUpdate = "KinesisStreamsOutputUpdate"
            case lambdaOutputUpdate = "LambdaOutputUpdate"
            case nameUpdate = "NameUpdate"
            case outputId = "OutputId"
        }
    }

    public struct ParallelismConfiguration: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "AutoScalingEnabled", required: false, type: .boolean), 
            AWSShapeMember(label: "ConfigurationType", required: true, type: .enum), 
            AWSShapeMember(label: "Parallelism", required: false, type: .integer), 
            AWSShapeMember(label: "ParallelismPerKPU", required: false, type: .integer)
        ]

        /// Describes whether the Kinesis Data Analytics service can increase the parallelism of the application in response to increased throughput.
        public let autoScalingEnabled: Bool?
        /// Describes whether the application uses the default parallelism for the Kinesis Data Analytics service.
        public let configurationType: ConfigurationType
        /// Describes the initial number of parallel tasks that a Java-based Kinesis Data Analytics application can perform. The Kinesis Data Analytics service can increase this number automatically if ParallelismConfiguration$AutoScalingEnabled is set to true.
        public let parallelism: Int?
        /// Describes the number of parallel tasks that a Java-based Kinesis Data Analytics application can perform per Kinesis Processing Unit (KPU) used by the application. For more information about KPUs, see Amazon Kinesis Data Analytics Pricing.
        public let parallelismPerKPU: Int?

        public init(autoScalingEnabled: Bool? = nil, configurationType: ConfigurationType, parallelism: Int? = nil, parallelismPerKPU: Int? = nil) {
            self.autoScalingEnabled = autoScalingEnabled
            self.configurationType = configurationType
            self.parallelism = parallelism
            self.parallelismPerKPU = parallelismPerKPU
        }

        public func validate(name: String) throws {
            try validate(parallelism, name:"parallelism", parent: name, min: 1)
            try validate(parallelismPerKPU, name:"parallelismPerKPU", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case autoScalingEnabled = "AutoScalingEnabled"
            case configurationType = "ConfigurationType"
            case parallelism = "Parallelism"
            case parallelismPerKPU = "ParallelismPerKPU"
        }
    }

    public struct ParallelismConfigurationDescription: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "AutoScalingEnabled", required: false, type: .boolean), 
            AWSShapeMember(label: "ConfigurationType", required: false, type: .enum), 
            AWSShapeMember(label: "CurrentParallelism", required: false, type: .integer), 
            AWSShapeMember(label: "Parallelism", required: false, type: .integer), 
            AWSShapeMember(label: "ParallelismPerKPU", required: false, type: .integer)
        ]

        /// Describes whether the Kinesis Data Analytics service can increase the parallelism of the application in response to increased throughput.
        public let autoScalingEnabled: Bool?
        /// Describes whether the application uses the default parallelism for the Kinesis Data Analytics service. 
        public let configurationType: ConfigurationType?
        /// Describes the current number of parallel tasks that a Java-based Kinesis Data Analytics application can perform.
        public let currentParallelism: Int?
        /// Describes the initial number of parallel tasks that a Java-based Kinesis Data Analytics application can perform. 
        public let parallelism: Int?
        /// Describes the number of parallel tasks that a Java-based Kinesis Data Analytics application can perform per Kinesis Processing Unit (KPU) used by the application.
        public let parallelismPerKPU: Int?

        public init(autoScalingEnabled: Bool? = nil, configurationType: ConfigurationType? = nil, currentParallelism: Int? = nil, parallelism: Int? = nil, parallelismPerKPU: Int? = nil) {
            self.autoScalingEnabled = autoScalingEnabled
            self.configurationType = configurationType
            self.currentParallelism = currentParallelism
            self.parallelism = parallelism
            self.parallelismPerKPU = parallelismPerKPU
        }

        private enum CodingKeys: String, CodingKey {
            case autoScalingEnabled = "AutoScalingEnabled"
            case configurationType = "ConfigurationType"
            case currentParallelism = "CurrentParallelism"
            case parallelism = "Parallelism"
            case parallelismPerKPU = "ParallelismPerKPU"
        }
    }

    public struct ParallelismConfigurationUpdate: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "AutoScalingEnabledUpdate", required: false, type: .boolean), 
            AWSShapeMember(label: "ConfigurationTypeUpdate", required: false, type: .enum), 
            AWSShapeMember(label: "ParallelismPerKPUUpdate", required: false, type: .integer), 
            AWSShapeMember(label: "ParallelismUpdate", required: false, type: .integer)
        ]

        /// Describes updates to whether the Kinesis Data Analytics service can increase the parallelism of the application in response to increased throughput.
        public let autoScalingEnabledUpdate: Bool?
        /// Describes updates to whether the application uses the default parallelism for the Kinesis Data Analytics service, or if a custom parallelism is used.
        public let configurationTypeUpdate: ConfigurationType?
        /// Describes updates to the number of parallel tasks an application can perform per Kinesis Processing Unit (KPU) used by the application.
        public let parallelismPerKPUUpdate: Int?
        /// Describes updates to the initial number of parallel tasks an application can perform.
        public let parallelismUpdate: Int?

        public init(autoScalingEnabledUpdate: Bool? = nil, configurationTypeUpdate: ConfigurationType? = nil, parallelismPerKPUUpdate: Int? = nil, parallelismUpdate: Int? = nil) {
            self.autoScalingEnabledUpdate = autoScalingEnabledUpdate
            self.configurationTypeUpdate = configurationTypeUpdate
            self.parallelismPerKPUUpdate = parallelismPerKPUUpdate
            self.parallelismUpdate = parallelismUpdate
        }

        public func validate(name: String) throws {
            try validate(parallelismPerKPUUpdate, name:"parallelismPerKPUUpdate", parent: name, min: 1)
            try validate(parallelismUpdate, name:"parallelismUpdate", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case autoScalingEnabledUpdate = "AutoScalingEnabledUpdate"
            case configurationTypeUpdate = "ConfigurationTypeUpdate"
            case parallelismPerKPUUpdate = "ParallelismPerKPUUpdate"
            case parallelismUpdate = "ParallelismUpdate"
        }
    }

    public struct PropertyGroup: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "PropertyGroupId", required: true, type: .string), 
            AWSShapeMember(label: "PropertyMap", required: true, type: .map)
        ]

        /// Describes the key of an application execution property key-value pair.
        public let propertyGroupId: String
        /// Describes the value of an application execution property key-value pair.
        public let propertyMap: [String: String]

        public init(propertyGroupId: String, propertyMap: [String: String]) {
            self.propertyGroupId = propertyGroupId
            self.propertyMap = propertyMap
        }

        public func validate(name: String) throws {
            try validate(propertyGroupId, name:"propertyGroupId", parent: name, max: 50)
            try validate(propertyGroupId, name:"propertyGroupId", parent: name, min: 1)
            try validate(propertyGroupId, name:"propertyGroupId", parent: name, pattern: "[a-zA-Z0-9_.-]+")
            try propertyMap.forEach {
                try validate($0.key, name:"propertyMap.key", parent: name, max: 2048)
                try validate($0.key, name:"propertyMap.key", parent: name, min: 1)
                try validate($0.value, name:"propertyMap[\"\($0.key)\"]", parent: name, max: 2048)
                try validate($0.value, name:"propertyMap[\"\($0.key)\"]", parent: name, min: 1)
            }
        }

        private enum CodingKeys: String, CodingKey {
            case propertyGroupId = "PropertyGroupId"
            case propertyMap = "PropertyMap"
        }
    }

    public struct RecordColumn: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "Mapping", required: false, type: .string), 
            AWSShapeMember(label: "Name", required: true, type: .string), 
            AWSShapeMember(label: "SqlType", required: true, type: .string)
        ]

        /// A reference to the data element in the streaming input or the reference data source.
        public let mapping: String?
        /// The name of the column that is created in the in-application input stream or reference table.
        public let name: String
        /// The type of column created in the in-application input stream or reference table.
        public let sqlType: String

        public init(mapping: String? = nil, name: String, sqlType: String) {
            self.mapping = mapping
            self.name = name
            self.sqlType = sqlType
        }

        public func validate(name: String) throws {
            try validate(sqlType, name:"sqlType", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case mapping = "Mapping"
            case name = "Name"
            case sqlType = "SqlType"
        }
    }

    public struct RecordFormat: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "MappingParameters", required: false, type: .structure), 
            AWSShapeMember(label: "RecordFormatType", required: true, type: .enum)
        ]

        /// When you configure application input at the time of creating or updating an application, provides additional mapping information specific to the record format (such as JSON, CSV, or record fields delimited by some delimiter) on the streaming source.
        public let mappingParameters: MappingParameters?
        /// The type of record format.
        public let recordFormatType: RecordFormatType

        public init(mappingParameters: MappingParameters? = nil, recordFormatType: RecordFormatType) {
            self.mappingParameters = mappingParameters
            self.recordFormatType = recordFormatType
        }

        public func validate(name: String) throws {
            try mappingParameters?.validate(name: "\(name).mappingParameters")
        }

        private enum CodingKeys: String, CodingKey {
            case mappingParameters = "MappingParameters"
            case recordFormatType = "RecordFormatType"
        }
    }

    public enum RecordFormatType: String, CustomStringConvertible, Codable {
        case json = "JSON"
        case csv = "CSV"
        public var description: String { return self.rawValue }
    }

    public struct ReferenceDataSource: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "ReferenceSchema", required: true, type: .structure), 
            AWSShapeMember(label: "S3ReferenceDataSource", required: false, type: .structure), 
            AWSShapeMember(label: "TableName", required: true, type: .string)
        ]

        /// Describes the format of the data in the streaming source, and how each data element maps to corresponding columns created in the in-application stream.
        public let referenceSchema: SourceSchema
        /// Identifies the S3 bucket and object that contains the reference data. A Kinesis Data Analytics application loads reference data only once. If the data changes, you call the UpdateApplication operation to trigger reloading of data into your application. 
        public let s3ReferenceDataSource: S3ReferenceDataSource?
        /// The name of the in-application table to create.
        public let tableName: String

        public init(referenceSchema: SourceSchema, s3ReferenceDataSource: S3ReferenceDataSource? = nil, tableName: String) {
            self.referenceSchema = referenceSchema
            self.s3ReferenceDataSource = s3ReferenceDataSource
            self.tableName = tableName
        }

        public func validate(name: String) throws {
            try referenceSchema.validate(name: "\(name).referenceSchema")
            try s3ReferenceDataSource?.validate(name: "\(name).s3ReferenceDataSource")
            try validate(tableName, name:"tableName", parent: name, max: 32)
            try validate(tableName, name:"tableName", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case referenceSchema = "ReferenceSchema"
            case s3ReferenceDataSource = "S3ReferenceDataSource"
            case tableName = "TableName"
        }
    }

    public struct ReferenceDataSourceDescription: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "ReferenceId", required: true, type: .string), 
            AWSShapeMember(label: "ReferenceSchema", required: false, type: .structure), 
            AWSShapeMember(label: "S3ReferenceDataSourceDescription", required: true, type: .structure), 
            AWSShapeMember(label: "TableName", required: true, type: .string)
        ]

        /// The ID of the reference data source. This is the ID that Kinesis Data Analytics assigns when you add the reference data source to your application using the CreateApplication or UpdateApplication operation.
        public let referenceId: String
        /// Describes the format of the data in the streaming source, and how each data element maps to corresponding columns created in the in-application stream.
        public let referenceSchema: SourceSchema?
        /// Provides the Amazon S3 bucket name, the object key name that contains the reference data. 
        public let s3ReferenceDataSourceDescription: S3ReferenceDataSourceDescription
        /// The in-application table name created by the specific reference data source configuration.
        public let tableName: String

        public init(referenceId: String, referenceSchema: SourceSchema? = nil, s3ReferenceDataSourceDescription: S3ReferenceDataSourceDescription, tableName: String) {
            self.referenceId = referenceId
            self.referenceSchema = referenceSchema
            self.s3ReferenceDataSourceDescription = s3ReferenceDataSourceDescription
            self.tableName = tableName
        }

        private enum CodingKeys: String, CodingKey {
            case referenceId = "ReferenceId"
            case referenceSchema = "ReferenceSchema"
            case s3ReferenceDataSourceDescription = "S3ReferenceDataSourceDescription"
            case tableName = "TableName"
        }
    }

    public struct ReferenceDataSourceUpdate: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "ReferenceId", required: true, type: .string), 
            AWSShapeMember(label: "ReferenceSchemaUpdate", required: false, type: .structure), 
            AWSShapeMember(label: "S3ReferenceDataSourceUpdate", required: false, type: .structure), 
            AWSShapeMember(label: "TableNameUpdate", required: false, type: .string)
        ]

        /// The ID of the reference data source that is being updated. You can use the DescribeApplication operation to get this value.
        public let referenceId: String
        /// Describes the format of the data in the streaming source, and how each data element maps to corresponding columns created in the in-application stream. 
        public let referenceSchemaUpdate: SourceSchema?
        /// Describes the S3 bucket name, object key name, and IAM role that Kinesis Data Analytics can assume to read the Amazon S3 object on your behalf and populate the in-application reference table.
        public let s3ReferenceDataSourceUpdate: S3ReferenceDataSourceUpdate?
        /// The in-application table name that is created by this update.
        public let tableNameUpdate: String?

        public init(referenceId: String, referenceSchemaUpdate: SourceSchema? = nil, s3ReferenceDataSourceUpdate: S3ReferenceDataSourceUpdate? = nil, tableNameUpdate: String? = nil) {
            self.referenceId = referenceId
            self.referenceSchemaUpdate = referenceSchemaUpdate
            self.s3ReferenceDataSourceUpdate = s3ReferenceDataSourceUpdate
            self.tableNameUpdate = tableNameUpdate
        }

        public func validate(name: String) throws {
            try validate(referenceId, name:"referenceId", parent: name, max: 50)
            try validate(referenceId, name:"referenceId", parent: name, min: 1)
            try validate(referenceId, name:"referenceId", parent: name, pattern: "[a-zA-Z0-9_.-]+")
            try referenceSchemaUpdate?.validate(name: "\(name).referenceSchemaUpdate")
            try s3ReferenceDataSourceUpdate?.validate(name: "\(name).s3ReferenceDataSourceUpdate")
            try validate(tableNameUpdate, name:"tableNameUpdate", parent: name, max: 32)
            try validate(tableNameUpdate, name:"tableNameUpdate", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case referenceId = "ReferenceId"
            case referenceSchemaUpdate = "ReferenceSchemaUpdate"
            case s3ReferenceDataSourceUpdate = "S3ReferenceDataSourceUpdate"
            case tableNameUpdate = "TableNameUpdate"
        }
    }

    public struct RunConfiguration: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "ApplicationRestoreConfiguration", required: false, type: .structure), 
            AWSShapeMember(label: "SqlRunConfigurations", required: false, type: .list)
        ]

        /// Describes the restore behavior of a restarting application.
        public let applicationRestoreConfiguration: ApplicationRestoreConfiguration?
        /// Describes the starting parameters for an SQL-based Kinesis Data Analytics application.
        public let sqlRunConfigurations: [SqlRunConfiguration]?

        public init(applicationRestoreConfiguration: ApplicationRestoreConfiguration? = nil, sqlRunConfigurations: [SqlRunConfiguration]? = nil) {
            self.applicationRestoreConfiguration = applicationRestoreConfiguration
            self.sqlRunConfigurations = sqlRunConfigurations
        }

        public func validate(name: String) throws {
            try applicationRestoreConfiguration?.validate(name: "\(name).applicationRestoreConfiguration")
            try sqlRunConfigurations?.forEach {
                try $0.validate(name: "\(name).sqlRunConfigurations[]")
            }
        }

        private enum CodingKeys: String, CodingKey {
            case applicationRestoreConfiguration = "ApplicationRestoreConfiguration"
            case sqlRunConfigurations = "SqlRunConfigurations"
        }
    }

    public struct RunConfigurationDescription: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "ApplicationRestoreConfigurationDescription", required: false, type: .structure)
        ]

        /// Describes the restore behavior of a restarting application.
        public let applicationRestoreConfigurationDescription: ApplicationRestoreConfiguration?

        public init(applicationRestoreConfigurationDescription: ApplicationRestoreConfiguration? = nil) {
            self.applicationRestoreConfigurationDescription = applicationRestoreConfigurationDescription
        }

        private enum CodingKeys: String, CodingKey {
            case applicationRestoreConfigurationDescription = "ApplicationRestoreConfigurationDescription"
        }
    }

    public struct RunConfigurationUpdate: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "ApplicationRestoreConfiguration", required: false, type: .structure)
        ]

        /// Describes updates to the restore behavior of a restarting application.
        public let applicationRestoreConfiguration: ApplicationRestoreConfiguration?

        public init(applicationRestoreConfiguration: ApplicationRestoreConfiguration? = nil) {
            self.applicationRestoreConfiguration = applicationRestoreConfiguration
        }

        public func validate(name: String) throws {
            try applicationRestoreConfiguration?.validate(name: "\(name).applicationRestoreConfiguration")
        }

        private enum CodingKeys: String, CodingKey {
            case applicationRestoreConfiguration = "ApplicationRestoreConfiguration"
        }
    }

    public enum RuntimeEnvironment: String, CustomStringConvertible, Codable {
        case sql10 = "SQL-1_0"
        case flink16 = "FLINK-1_6"
        public var description: String { return self.rawValue }
    }

    public struct S3ApplicationCodeLocationDescription: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "BucketARN", required: true, type: .string), 
            AWSShapeMember(label: "FileKey", required: true, type: .string), 
            AWSShapeMember(label: "ObjectVersion", required: false, type: .string)
        ]

        /// The Amazon Resource Name (ARN) for the S3 bucket containing the application code.
        public let bucketARN: String
        /// The file key for the object containing the application code.
        public let fileKey: String
        /// The version of the object containing the application code.
        public let objectVersion: String?

        public init(bucketARN: String, fileKey: String, objectVersion: String? = nil) {
            self.bucketARN = bucketARN
            self.fileKey = fileKey
            self.objectVersion = objectVersion
        }

        private enum CodingKeys: String, CodingKey {
            case bucketARN = "BucketARN"
            case fileKey = "FileKey"
            case objectVersion = "ObjectVersion"
        }
    }

    public struct S3Configuration: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "BucketARN", required: true, type: .string), 
            AWSShapeMember(label: "FileKey", required: true, type: .string)
        ]

        /// The ARN of the S3 bucket that contains the data.
        public let bucketARN: String
        /// The name of the object that contains the data.
        public let fileKey: String

        public init(bucketARN: String, fileKey: String) {
            self.bucketARN = bucketARN
            self.fileKey = fileKey
        }

        public func validate(name: String) throws {
            try validate(bucketARN, name:"bucketARN", parent: name, max: 2048)
            try validate(bucketARN, name:"bucketARN", parent: name, min: 1)
            try validate(bucketARN, name:"bucketARN", parent: name, pattern: "arn:.*")
            try validate(fileKey, name:"fileKey", parent: name, max: 1024)
            try validate(fileKey, name:"fileKey", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case bucketARN = "BucketARN"
            case fileKey = "FileKey"
        }
    }

    public struct S3ContentLocation: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "BucketARN", required: true, type: .string), 
            AWSShapeMember(label: "FileKey", required: true, type: .string), 
            AWSShapeMember(label: "ObjectVersion", required: false, type: .string)
        ]

        /// The Amazon Resource Name (ARN) for the S3 bucket containing the application code.
        public let bucketARN: String
        /// The file key for the object containing the application code.
        public let fileKey: String
        /// The version of the object containing the application code.
        public let objectVersion: String?

        public init(bucketARN: String, fileKey: String, objectVersion: String? = nil) {
            self.bucketARN = bucketARN
            self.fileKey = fileKey
            self.objectVersion = objectVersion
        }

        public func validate(name: String) throws {
            try validate(bucketARN, name:"bucketARN", parent: name, max: 2048)
            try validate(bucketARN, name:"bucketARN", parent: name, min: 1)
            try validate(bucketARN, name:"bucketARN", parent: name, pattern: "arn:.*")
            try validate(fileKey, name:"fileKey", parent: name, max: 1024)
            try validate(fileKey, name:"fileKey", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case bucketARN = "BucketARN"
            case fileKey = "FileKey"
            case objectVersion = "ObjectVersion"
        }
    }

    public struct S3ContentLocationUpdate: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "BucketARNUpdate", required: false, type: .string), 
            AWSShapeMember(label: "FileKeyUpdate", required: false, type: .string), 
            AWSShapeMember(label: "ObjectVersionUpdate", required: false, type: .string)
        ]

        /// The new Amazon Resource Name (ARN) for the S3 bucket containing the application code.
        public let bucketARNUpdate: String?
        /// The new file key for the object containing the application code.
        public let fileKeyUpdate: String?
        /// The new version of the object containing the application code.
        public let objectVersionUpdate: String?

        public init(bucketARNUpdate: String? = nil, fileKeyUpdate: String? = nil, objectVersionUpdate: String? = nil) {
            self.bucketARNUpdate = bucketARNUpdate
            self.fileKeyUpdate = fileKeyUpdate
            self.objectVersionUpdate = objectVersionUpdate
        }

        public func validate(name: String) throws {
            try validate(bucketARNUpdate, name:"bucketARNUpdate", parent: name, max: 2048)
            try validate(bucketARNUpdate, name:"bucketARNUpdate", parent: name, min: 1)
            try validate(bucketARNUpdate, name:"bucketARNUpdate", parent: name, pattern: "arn:.*")
            try validate(fileKeyUpdate, name:"fileKeyUpdate", parent: name, max: 1024)
            try validate(fileKeyUpdate, name:"fileKeyUpdate", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case bucketARNUpdate = "BucketARNUpdate"
            case fileKeyUpdate = "FileKeyUpdate"
            case objectVersionUpdate = "ObjectVersionUpdate"
        }
    }

    public struct S3ReferenceDataSource: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "BucketARN", required: false, type: .string), 
            AWSShapeMember(label: "FileKey", required: false, type: .string)
        ]

        /// The Amazon Resource Name (ARN) of the S3 bucket.
        public let bucketARN: String?
        /// The object key name containing the reference data.
        public let fileKey: String?

        public init(bucketARN: String? = nil, fileKey: String? = nil) {
            self.bucketARN = bucketARN
            self.fileKey = fileKey
        }

        public func validate(name: String) throws {
            try validate(bucketARN, name:"bucketARN", parent: name, max: 2048)
            try validate(bucketARN, name:"bucketARN", parent: name, min: 1)
            try validate(bucketARN, name:"bucketARN", parent: name, pattern: "arn:.*")
            try validate(fileKey, name:"fileKey", parent: name, max: 1024)
            try validate(fileKey, name:"fileKey", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case bucketARN = "BucketARN"
            case fileKey = "FileKey"
        }
    }

    public struct S3ReferenceDataSourceDescription: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "BucketARN", required: true, type: .string), 
            AWSShapeMember(label: "FileKey", required: true, type: .string), 
            AWSShapeMember(label: "ReferenceRoleARN", required: false, type: .string)
        ]

        /// The Amazon Resource Name (ARN) of the S3 bucket.
        public let bucketARN: String
        /// Amazon S3 object key name.
        public let fileKey: String
        /// The ARN of the IAM role that Kinesis Data Analytics can assume to read the Amazon S3 object on your behalf to populate the in-application reference table.   Provided for backward compatibility. Applications that are created with the current API version have an application-level service execution role rather than a resource-level role. 
        public let referenceRoleARN: String?

        public init(bucketARN: String, fileKey: String, referenceRoleARN: String? = nil) {
            self.bucketARN = bucketARN
            self.fileKey = fileKey
            self.referenceRoleARN = referenceRoleARN
        }

        private enum CodingKeys: String, CodingKey {
            case bucketARN = "BucketARN"
            case fileKey = "FileKey"
            case referenceRoleARN = "ReferenceRoleARN"
        }
    }

    public struct S3ReferenceDataSourceUpdate: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "BucketARNUpdate", required: false, type: .string), 
            AWSShapeMember(label: "FileKeyUpdate", required: false, type: .string)
        ]

        /// The Amazon Resource Name (ARN) of the S3 bucket.
        public let bucketARNUpdate: String?
        /// The object key name.
        public let fileKeyUpdate: String?

        public init(bucketARNUpdate: String? = nil, fileKeyUpdate: String? = nil) {
            self.bucketARNUpdate = bucketARNUpdate
            self.fileKeyUpdate = fileKeyUpdate
        }

        public func validate(name: String) throws {
            try validate(bucketARNUpdate, name:"bucketARNUpdate", parent: name, max: 2048)
            try validate(bucketARNUpdate, name:"bucketARNUpdate", parent: name, min: 1)
            try validate(bucketARNUpdate, name:"bucketARNUpdate", parent: name, pattern: "arn:.*")
            try validate(fileKeyUpdate, name:"fileKeyUpdate", parent: name, max: 1024)
            try validate(fileKeyUpdate, name:"fileKeyUpdate", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case bucketARNUpdate = "BucketARNUpdate"
            case fileKeyUpdate = "FileKeyUpdate"
        }
    }

    public struct SnapshotDetails: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "ApplicationVersionId", required: true, type: .long), 
            AWSShapeMember(label: "SnapshotCreationTimestamp", required: false, type: .timestamp), 
            AWSShapeMember(label: "SnapshotName", required: true, type: .string), 
            AWSShapeMember(label: "SnapshotStatus", required: true, type: .enum)
        ]

        /// The current application version ID when the snapshot was created.
        public let applicationVersionId: Int64
        /// The timestamp of the application snapshot.
        public let snapshotCreationTimestamp: TimeStamp?
        /// The identifier for the application snapshot.
        public let snapshotName: String
        /// The status of the application snapshot.
        public let snapshotStatus: SnapshotStatus

        public init(applicationVersionId: Int64, snapshotCreationTimestamp: TimeStamp? = nil, snapshotName: String, snapshotStatus: SnapshotStatus) {
            self.applicationVersionId = applicationVersionId
            self.snapshotCreationTimestamp = snapshotCreationTimestamp
            self.snapshotName = snapshotName
            self.snapshotStatus = snapshotStatus
        }

        private enum CodingKeys: String, CodingKey {
            case applicationVersionId = "ApplicationVersionId"
            case snapshotCreationTimestamp = "SnapshotCreationTimestamp"
            case snapshotName = "SnapshotName"
            case snapshotStatus = "SnapshotStatus"
        }
    }

    public enum SnapshotStatus: String, CustomStringConvertible, Codable {
        case creating = "CREATING"
        case ready = "READY"
        case deleting = "DELETING"
        case failed = "FAILED"
        public var description: String { return self.rawValue }
    }

    public struct SourceSchema: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "RecordColumns", required: true, type: .list), 
            AWSShapeMember(label: "RecordEncoding", required: false, type: .string), 
            AWSShapeMember(label: "RecordFormat", required: true, type: .structure)
        ]

        /// A list of RecordColumn objects. 
        public let recordColumns: [RecordColumn]
        /// Specifies the encoding of the records in the streaming source. For example, UTF-8.
        public let recordEncoding: String?
        /// Specifies the format of the records on the streaming source.
        public let recordFormat: RecordFormat

        public init(recordColumns: [RecordColumn], recordEncoding: String? = nil, recordFormat: RecordFormat) {
            self.recordColumns = recordColumns
            self.recordEncoding = recordEncoding
            self.recordFormat = recordFormat
        }

        public func validate(name: String) throws {
            try recordColumns.forEach {
                try $0.validate(name: "\(name).recordColumns[]")
            }
            try validate(recordColumns, name:"recordColumns", parent: name, max: 1000)
            try validate(recordColumns, name:"recordColumns", parent: name, min: 1)
            try validate(recordEncoding, name:"recordEncoding", parent: name, pattern: "UTF-8")
            try recordFormat.validate(name: "\(name).recordFormat")
        }

        private enum CodingKeys: String, CodingKey {
            case recordColumns = "RecordColumns"
            case recordEncoding = "RecordEncoding"
            case recordFormat = "RecordFormat"
        }
    }

    public struct SqlApplicationConfiguration: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "Inputs", required: false, type: .list), 
            AWSShapeMember(label: "Outputs", required: false, type: .list), 
            AWSShapeMember(label: "ReferenceDataSources", required: false, type: .list)
        ]

        /// The array of Input objects describing the input streams used by the application.
        public let inputs: [Input]?
        /// The array of Output objects describing the destination streams used by the application.
        public let outputs: [Output]?
        /// The array of ReferenceDataSource objects describing the reference data sources used by the application.
        public let referenceDataSources: [ReferenceDataSource]?

        public init(inputs: [Input]? = nil, outputs: [Output]? = nil, referenceDataSources: [ReferenceDataSource]? = nil) {
            self.inputs = inputs
            self.outputs = outputs
            self.referenceDataSources = referenceDataSources
        }

        public func validate(name: String) throws {
            try inputs?.forEach {
                try $0.validate(name: "\(name).inputs[]")
            }
            try outputs?.forEach {
                try $0.validate(name: "\(name).outputs[]")
            }
            try referenceDataSources?.forEach {
                try $0.validate(name: "\(name).referenceDataSources[]")
            }
        }

        private enum CodingKeys: String, CodingKey {
            case inputs = "Inputs"
            case outputs = "Outputs"
            case referenceDataSources = "ReferenceDataSources"
        }
    }

    public struct SqlApplicationConfigurationDescription: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "InputDescriptions", required: false, type: .list), 
            AWSShapeMember(label: "OutputDescriptions", required: false, type: .list), 
            AWSShapeMember(label: "ReferenceDataSourceDescriptions", required: false, type: .list)
        ]

        /// The array of InputDescription objects describing the input streams used by the application.
        public let inputDescriptions: [InputDescription]?
        /// The array of OutputDescription objects describing the destination streams used by the application.
        public let outputDescriptions: [OutputDescription]?
        /// The array of ReferenceDataSourceDescription objects describing the reference data sources used by the application.
        public let referenceDataSourceDescriptions: [ReferenceDataSourceDescription]?

        public init(inputDescriptions: [InputDescription]? = nil, outputDescriptions: [OutputDescription]? = nil, referenceDataSourceDescriptions: [ReferenceDataSourceDescription]? = nil) {
            self.inputDescriptions = inputDescriptions
            self.outputDescriptions = outputDescriptions
            self.referenceDataSourceDescriptions = referenceDataSourceDescriptions
        }

        private enum CodingKeys: String, CodingKey {
            case inputDescriptions = "InputDescriptions"
            case outputDescriptions = "OutputDescriptions"
            case referenceDataSourceDescriptions = "ReferenceDataSourceDescriptions"
        }
    }

    public struct SqlApplicationConfigurationUpdate: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "InputUpdates", required: false, type: .list), 
            AWSShapeMember(label: "OutputUpdates", required: false, type: .list), 
            AWSShapeMember(label: "ReferenceDataSourceUpdates", required: false, type: .list)
        ]

        /// The array of InputUpdate objects describing the new input streams used by the application.
        public let inputUpdates: [InputUpdate]?
        /// The array of OutputUpdate objects describing the new destination streams used by the application.
        public let outputUpdates: [OutputUpdate]?
        /// The array of ReferenceDataSourceUpdate objects describing the new reference data sources used by the application.
        public let referenceDataSourceUpdates: [ReferenceDataSourceUpdate]?

        public init(inputUpdates: [InputUpdate]? = nil, outputUpdates: [OutputUpdate]? = nil, referenceDataSourceUpdates: [ReferenceDataSourceUpdate]? = nil) {
            self.inputUpdates = inputUpdates
            self.outputUpdates = outputUpdates
            self.referenceDataSourceUpdates = referenceDataSourceUpdates
        }

        public func validate(name: String) throws {
            try inputUpdates?.forEach {
                try $0.validate(name: "\(name).inputUpdates[]")
            }
            try outputUpdates?.forEach {
                try $0.validate(name: "\(name).outputUpdates[]")
            }
            try referenceDataSourceUpdates?.forEach {
                try $0.validate(name: "\(name).referenceDataSourceUpdates[]")
            }
        }

        private enum CodingKeys: String, CodingKey {
            case inputUpdates = "InputUpdates"
            case outputUpdates = "OutputUpdates"
            case referenceDataSourceUpdates = "ReferenceDataSourceUpdates"
        }
    }

    public struct SqlRunConfiguration: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "InputId", required: true, type: .string), 
            AWSShapeMember(label: "InputStartingPositionConfiguration", required: true, type: .structure)
        ]

        /// The input source ID. You can get this ID by calling the DescribeApplication operation. 
        public let inputId: String
        /// The point at which you want the application to start processing records from the streaming source. 
        public let inputStartingPositionConfiguration: InputStartingPositionConfiguration

        public init(inputId: String, inputStartingPositionConfiguration: InputStartingPositionConfiguration) {
            self.inputId = inputId
            self.inputStartingPositionConfiguration = inputStartingPositionConfiguration
        }

        public func validate(name: String) throws {
            try validate(inputId, name:"inputId", parent: name, max: 50)
            try validate(inputId, name:"inputId", parent: name, min: 1)
            try validate(inputId, name:"inputId", parent: name, pattern: "[a-zA-Z0-9_.-]+")
        }

        private enum CodingKeys: String, CodingKey {
            case inputId = "InputId"
            case inputStartingPositionConfiguration = "InputStartingPositionConfiguration"
        }
    }

    public struct StartApplicationRequest: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "ApplicationName", required: true, type: .string), 
            AWSShapeMember(label: "RunConfiguration", required: true, type: .structure)
        ]

        /// The name of the application.
        public let applicationName: String
        /// Identifies the run configuration (start parameters) of a Kinesis Data Analytics application.
        public let runConfiguration: RunConfiguration

        public init(applicationName: String, runConfiguration: RunConfiguration) {
            self.applicationName = applicationName
            self.runConfiguration = runConfiguration
        }

        public func validate(name: String) throws {
            try validate(applicationName, name:"applicationName", parent: name, max: 128)
            try validate(applicationName, name:"applicationName", parent: name, min: 1)
            try validate(applicationName, name:"applicationName", parent: name, pattern: "[a-zA-Z0-9_.-]+")
            try runConfiguration.validate(name: "\(name).runConfiguration")
        }

        private enum CodingKeys: String, CodingKey {
            case applicationName = "ApplicationName"
            case runConfiguration = "RunConfiguration"
        }
    }

    public struct StartApplicationResponse: AWSShape {


        public init() {
        }

    }

    public struct StopApplicationRequest: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "ApplicationName", required: true, type: .string)
        ]

        /// The name of the running application to stop.
        public let applicationName: String

        public init(applicationName: String) {
            self.applicationName = applicationName
        }

        public func validate(name: String) throws {
            try validate(applicationName, name:"applicationName", parent: name, max: 128)
            try validate(applicationName, name:"applicationName", parent: name, min: 1)
            try validate(applicationName, name:"applicationName", parent: name, pattern: "[a-zA-Z0-9_.-]+")
        }

        private enum CodingKeys: String, CodingKey {
            case applicationName = "ApplicationName"
        }
    }

    public struct StopApplicationResponse: AWSShape {


        public init() {
        }

    }

    public struct Tag: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "Key", required: true, type: .string), 
            AWSShapeMember(label: "Value", required: false, type: .string)
        ]

        /// The key of the key-value tag.
        public let key: String
        /// The value of the key-value tag. The value is optional.
        public let value: String?

        public init(key: String, value: String? = nil) {
            self.key = key
            self.value = value
        }

        public func validate(name: String) throws {
            try validate(key, name:"key", parent: name, max: 128)
            try validate(key, name:"key", parent: name, min: 1)
            try validate(value, name:"value", parent: name, max: 256)
            try validate(value, name:"value", parent: name, min: 0)
        }

        private enum CodingKeys: String, CodingKey {
            case key = "Key"
            case value = "Value"
        }
    }

    public struct TagResourceRequest: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "ResourceARN", required: true, type: .string), 
            AWSShapeMember(label: "Tags", required: true, type: .list)
        ]

        /// The ARN of the application to assign the tags.
        public let resourceARN: String
        /// The key-value tags to assign to the application.
        public let tags: [Tag]

        public init(resourceARN: String, tags: [Tag]) {
            self.resourceARN = resourceARN
            self.tags = tags
        }

        public func validate(name: String) throws {
            try validate(resourceARN, name:"resourceARN", parent: name, max: 2048)
            try validate(resourceARN, name:"resourceARN", parent: name, min: 1)
            try validate(resourceARN, name:"resourceARN", parent: name, pattern: "arn:aws:kinesisanalytics:[a-z]{2}-[a-z]+-\\d{1}+:\\d{12}+:application/[a-zA-Z0-9_.-]{1,128}")
            try tags.forEach {
                try $0.validate(name: "\(name).tags[]")
            }
            try validate(tags, name:"tags", parent: name, max: 200)
            try validate(tags, name:"tags", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case resourceARN = "ResourceARN"
            case tags = "Tags"
        }
    }

    public struct TagResourceResponse: AWSShape {


        public init() {
        }

    }

    public struct UntagResourceRequest: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "ResourceARN", required: true, type: .string), 
            AWSShapeMember(label: "TagKeys", required: true, type: .list)
        ]

        /// The ARN of the Kinesis Analytics application from which to remove the tags.
        public let resourceARN: String
        /// A list of keys of tags to remove from the specified application.
        public let tagKeys: [String]

        public init(resourceARN: String, tagKeys: [String]) {
            self.resourceARN = resourceARN
            self.tagKeys = tagKeys
        }

        public func validate(name: String) throws {
            try validate(resourceARN, name:"resourceARN", parent: name, max: 2048)
            try validate(resourceARN, name:"resourceARN", parent: name, min: 1)
            try validate(resourceARN, name:"resourceARN", parent: name, pattern: "arn:aws:kinesisanalytics:[a-z]{2}-[a-z]+-\\d{1}+:\\d{12}+:application/[a-zA-Z0-9_.-]{1,128}")
            try tagKeys.forEach {
                try validate($0, name: "tagKeys[]", parent: name, max: 128)
                try validate($0, name: "tagKeys[]", parent: name, min: 1)
            }
            try validate(tagKeys, name:"tagKeys", parent: name, max: 200)
            try validate(tagKeys, name:"tagKeys", parent: name, min: 1)
        }

        private enum CodingKeys: String, CodingKey {
            case resourceARN = "ResourceARN"
            case tagKeys = "TagKeys"
        }
    }

    public struct UntagResourceResponse: AWSShape {


        public init() {
        }

    }

    public struct UpdateApplicationRequest: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "ApplicationConfigurationUpdate", required: false, type: .structure), 
            AWSShapeMember(label: "ApplicationName", required: true, type: .string), 
            AWSShapeMember(label: "CloudWatchLoggingOptionUpdates", required: false, type: .list), 
            AWSShapeMember(label: "CurrentApplicationVersionId", required: true, type: .long), 
            AWSShapeMember(label: "RunConfigurationUpdate", required: false, type: .structure), 
            AWSShapeMember(label: "ServiceExecutionRoleUpdate", required: false, type: .string)
        ]

        /// Describes application configuration updates.
        public let applicationConfigurationUpdate: ApplicationConfigurationUpdate?
        /// The name of the application to update.
        public let applicationName: String
        /// Describes application Amazon CloudWatch logging option updates. You can only update existing CloudWatch logging options with this action. To add a new CloudWatch logging option, use AddApplicationCloudWatchLoggingOption.
        public let cloudWatchLoggingOptionUpdates: [CloudWatchLoggingOptionUpdate]?
        /// The current application version ID. You can retrieve the application version ID using DescribeApplication.
        public let currentApplicationVersionId: Int64
        /// Describes updates to the application's starting parameters.
        public let runConfigurationUpdate: RunConfigurationUpdate?
        /// Describes updates to the service execution role.
        public let serviceExecutionRoleUpdate: String?

        public init(applicationConfigurationUpdate: ApplicationConfigurationUpdate? = nil, applicationName: String, cloudWatchLoggingOptionUpdates: [CloudWatchLoggingOptionUpdate]? = nil, currentApplicationVersionId: Int64, runConfigurationUpdate: RunConfigurationUpdate? = nil, serviceExecutionRoleUpdate: String? = nil) {
            self.applicationConfigurationUpdate = applicationConfigurationUpdate
            self.applicationName = applicationName
            self.cloudWatchLoggingOptionUpdates = cloudWatchLoggingOptionUpdates
            self.currentApplicationVersionId = currentApplicationVersionId
            self.runConfigurationUpdate = runConfigurationUpdate
            self.serviceExecutionRoleUpdate = serviceExecutionRoleUpdate
        }

        public func validate(name: String) throws {
            try applicationConfigurationUpdate?.validate(name: "\(name).applicationConfigurationUpdate")
            try validate(applicationName, name:"applicationName", parent: name, max: 128)
            try validate(applicationName, name:"applicationName", parent: name, min: 1)
            try validate(applicationName, name:"applicationName", parent: name, pattern: "[a-zA-Z0-9_.-]+")
            try cloudWatchLoggingOptionUpdates?.forEach {
                try $0.validate(name: "\(name).cloudWatchLoggingOptionUpdates[]")
            }
            try validate(currentApplicationVersionId, name:"currentApplicationVersionId", parent: name, max: 999999999)
            try validate(currentApplicationVersionId, name:"currentApplicationVersionId", parent: name, min: 1)
            try runConfigurationUpdate?.validate(name: "\(name).runConfigurationUpdate")
            try validate(serviceExecutionRoleUpdate, name:"serviceExecutionRoleUpdate", parent: name, max: 2048)
            try validate(serviceExecutionRoleUpdate, name:"serviceExecutionRoleUpdate", parent: name, min: 1)
            try validate(serviceExecutionRoleUpdate, name:"serviceExecutionRoleUpdate", parent: name, pattern: "arn:aws:iam::\\d{12}:role/?[a-zA-Z_0-9+=,.@\\-_/]+")
        }

        private enum CodingKeys: String, CodingKey {
            case applicationConfigurationUpdate = "ApplicationConfigurationUpdate"
            case applicationName = "ApplicationName"
            case cloudWatchLoggingOptionUpdates = "CloudWatchLoggingOptionUpdates"
            case currentApplicationVersionId = "CurrentApplicationVersionId"
            case runConfigurationUpdate = "RunConfigurationUpdate"
            case serviceExecutionRoleUpdate = "ServiceExecutionRoleUpdate"
        }
    }

    public struct UpdateApplicationResponse: AWSShape {
        public static var _members: [AWSShapeMember] = [
            AWSShapeMember(label: "ApplicationDetail", required: true, type: .structure)
        ]

        /// Describes application updates.
        public let applicationDetail: ApplicationDetail

        public init(applicationDetail: ApplicationDetail) {
            self.applicationDetail = applicationDetail
        }

        private enum CodingKeys: String, CodingKey {
            case applicationDetail = "ApplicationDetail"
        }
    }
}
