type ApplicationCodeConfiguration struct {

	// Specifies whether the code content is in text or zip format.
	//
	// This member is required.
	CodeContentType CodeContentType

	// The location and type of the application code.
	CodeContent *CodeContent
}

type ApplicationCodeConfigurationDescription struct {

	// Specifies whether the code content is in text or zip format.
	//
	// This member is required.
	CodeContentType CodeContentType

	// Describes details about the location and format of the application code.
	CodeContentDescription *CodeContentDescription
}

type ApplicationCodeConfigurationUpdate struct {

	// Describes updates to the code content type.
	CodeContentTypeUpdate CodeContentType

	// Describes updates to the code content of an application.
	CodeContentUpdate *CodeContentUpdate
}

type ApplicationConfiguration struct {

	// The code location and type parameters for a Flink-based Kinesis Data Analytics
	// application.
	ApplicationCodeConfiguration *ApplicationCodeConfiguration

	// Describes whether snapshots are enabled for a Flink-based Kinesis Data Analytics
	// application.
	ApplicationSnapshotConfiguration *ApplicationSnapshotConfiguration

	// Describes execution properties for a Flink-based Kinesis Data Analytics
	// application.
	EnvironmentProperties *EnvironmentProperties

	// The creation and update parameters for a Flink-based Kinesis Data Analytics
	// application.
	FlinkApplicationConfiguration *FlinkApplicationConfiguration

	// The creation and update parameters for a SQL-based Kinesis Data Analytics
	// application.
	SqlApplicationConfiguration *SqlApplicationConfiguration

	// The array of descriptions of VPC configurations available to the application.
	VpcConfigurations []VpcConfiguration

	// The configuration parameters for a Kinesis Data Analytics Studio notebook.
	ZeppelinApplicationConfiguration *ZeppelinApplicationConfiguration
}

type ApplicationConfigurationDescription struct {

	// The details about the application code for a Flink-based Kinesis Data Analytics
	// application.
	ApplicationCodeConfigurationDescription *ApplicationCodeConfigurationDescription

	// Describes whether snapshots are enabled for a Flink-based Kinesis Data Analytics
	// application.
	ApplicationSnapshotConfigurationDescription *ApplicationSnapshotConfigurationDescription

	// Describes execution properties for a Flink-based Kinesis Data Analytics
	// application.
	EnvironmentPropertyDescriptions *EnvironmentPropertyDescriptions

	// The details about a Flink-based Kinesis Data Analytics application.
	FlinkApplicationConfigurationDescription *FlinkApplicationConfigurationDescription

	// The details about the starting properties for a Kinesis Data Analytics
	// application.
	RunConfigurationDescription *RunConfigurationDescription

	// The details about inputs, outputs, and reference data sources for a SQL-based
	// Kinesis Data Analytics application.
	SqlApplicationConfigurationDescription *SqlApplicationConfigurationDescription

	// The array of descriptions of VPC configurations available to the application.
	VpcConfigurationDescriptions []VpcConfigurationDescription

	// The configuration parameters for a Kinesis Data Analytics Studio notebook.
	ZeppelinApplicationConfigurationDescription *ZeppelinApplicationConfigurationDescription
}

type ApplicationConfigurationUpdate struct {

	// Describes updates to an application's code configuration.
	ApplicationCodeConfigurationUpdate *ApplicationCodeConfigurationUpdate

	// Describes whether snapshots are enabled for a Flink-based Kinesis Data Analytics
	// application.
	ApplicationSnapshotConfigurationUpdate *ApplicationSnapshotConfigurationUpdate

	// Describes updates to the environment properties for a Flink-based Kinesis Data
	// Analytics application.
	EnvironmentPropertyUpdates *EnvironmentPropertyUpdates

	// Describes updates to a Flink-based Kinesis Data Analytics application's
	// configuration.
	FlinkApplicationConfigurationUpdate *FlinkApplicationConfigurationUpdate

	// Describes updates to a SQL-based Kinesis Data Analytics application's
	// configuration.
	SqlApplicationConfigurationUpdate *SqlApplicationConfigurationUpdate

	// Updates to the array of descriptions of VPC configurations available to the
	// application.
	VpcConfigurationUpdates []VpcConfigurationUpdate

	// Updates to the configuration of a Kinesis Data Analytics Studio notebook.
	ZeppelinApplicationConfigurationUpdate *ZeppelinApplicationConfigurationUpdate
}

type ApplicationDetail struct {

	// The ARN of the application.
	//
	// This member is required.
	ApplicationARN *string

	// The name of the application.
	//
	// This member is required.
	ApplicationName *string

	// The status of the application.
	//
	// This member is required.
	ApplicationStatus ApplicationStatus

	// Provides the current application version. Kinesis Data Analytics updates the
	// ApplicationVersionId each time you update the application.
	//
	// This member is required.
	ApplicationVersionId *int64

	// The runtime environment for the application (SQL-1_0, FLINK-1_6, FLINK-1_8, or
	// FLINK-1_11).
	//
	// This member is required.
	RuntimeEnvironment RuntimeEnvironment

	// Describes details about the application code and starting parameters for a
	// Kinesis Data Analytics application.
	ApplicationConfigurationDescription *ApplicationConfigurationDescription

	// The description of the application.
	ApplicationDescription *string

	// The details of the maintenance configuration for the application.
	ApplicationMaintenanceConfigurationDescription *ApplicationMaintenanceConfigurationDescription

	// To create a Kinesis Data Analytics Studio notebook, you must set the mode to
	// INTERACTIVE. However, for a Kinesis Data Analytics for Apache Flink application,
	// the mode is optional.
	ApplicationMode ApplicationMode

	// If you reverted the application using RollbackApplication, the application
	// version when RollbackApplication was called.
	ApplicationVersionRolledBackFrom *int64

	// The version to which you want to roll back the application.
	ApplicationVersionRolledBackTo *int64

	// The previous application version before the latest application update.
	// RollbackApplication reverts the application to this version.
	ApplicationVersionUpdatedFrom *int64

	// Describes the application Amazon CloudWatch logging options.
	CloudWatchLoggingOptionDescriptions []CloudWatchLoggingOptionDescription

	// A value you use to implement strong concurrency for application updates.
	ConditionalToken *string

	// The current timestamp when the application was created.
	CreateTimestamp *time.Time

	// The current timestamp when the application was last updated.
	LastUpdateTimestamp *time.Time

	// Specifies the IAM role that the application uses to access external resources.
	ServiceExecutionRole *string
}

type ApplicationMaintenanceConfigurationDescription struct {

	// The end time for the maintenance window.
	//
	// This member is required.
	ApplicationMaintenanceWindowEndTime *string

	// The start time for the maintenance window.
	//
	// This member is required.
	ApplicationMaintenanceWindowStartTime *string
}

type ApplicationMaintenanceConfigurationUpdate struct {

	// The updated start time for the maintenance window.
	//
	// This member is required.
	ApplicationMaintenanceWindowStartTimeUpdate *string
}

type ApplicationMode string

const (
	ApplicationModeStreaming   ApplicationMode = "STREAMING"
	ApplicationModeInteractive ApplicationMode = "INTERACTIVE"
)

type ApplicationRestoreConfiguration struct {

	// Specifies how the application should be restored.
	//
	// This member is required.
	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.
	SnapshotName *string
}

type ApplicationRestoreType string

const (
	ApplicationRestoreTypeSkipRestoreFromSnapshot   ApplicationRestoreType = "SKIP_RESTORE_FROM_SNAPSHOT"
	ApplicationRestoreTypeRestoreFromLatestSnapshot ApplicationRestoreType = "RESTORE_FROM_LATEST_SNAPSHOT"
	ApplicationRestoreTypeRestoreFromCustomSnapshot ApplicationRestoreType = "RESTORE_FROM_CUSTOM_SNAPSHOT"
)

type ApplicationSnapshotConfiguration struct {

	// Describes whether snapshots are enabled for a Flink-based Kinesis Data Analytics
	// application.
	//
	// This member is required.
	SnapshotsEnabled *bool
}

type ApplicationSnapshotConfigurationDescription struct {

	// Describes whether snapshots are enabled for a Flink-based Kinesis Data Analytics
	// application.
	//
	// This member is required.
	SnapshotsEnabled *bool
}

type ApplicationSnapshotConfigurationUpdate struct {

	// Describes updates to whether snapshots are enabled for an application.
	//
	// This member is required.
	SnapshotsEnabledUpdate *bool
}

type ApplicationStatus string

const (
	ApplicationStatusDeleting      ApplicationStatus = "DELETING"
	ApplicationStatusStarting      ApplicationStatus = "STARTING"
	ApplicationStatusStopping      ApplicationStatus = "STOPPING"
	ApplicationStatusReady         ApplicationStatus = "READY"
	ApplicationStatusRunning       ApplicationStatus = "RUNNING"
	ApplicationStatusUpdating      ApplicationStatus = "UPDATING"
	ApplicationStatusAutoscaling   ApplicationStatus = "AUTOSCALING"
	ApplicationStatusForceStopping ApplicationStatus = "FORCE_STOPPING"
	ApplicationStatusMaintenance   ApplicationStatus = "MAINTENANCE"
	ApplicationStatusRollingBack   ApplicationStatus = "ROLLING_BACK"
	ApplicationStatusRolledBack    ApplicationStatus = "ROLLED_BACK"
)

type ApplicationSummary struct {

	// The ARN of the application.
	//
	// This member is required.
	ApplicationARN *string

	// The name of the application.
	//
	// This member is required.
	ApplicationName *string

	// The status of the application.
	//
	// This member is required.
	ApplicationStatus ApplicationStatus

	// Provides the current application version.
	//
	// This member is required.
	ApplicationVersionId *int64

	// The runtime environment for the application.
	//
	// This member is required.
	RuntimeEnvironment RuntimeEnvironment

	// For a Kinesis Data Analytics for Apache Flink application, the mode is
	// STREAMING. For a Kinesis Data Analytics Studio notebook, it is INTERACTIVE.
	ApplicationMode ApplicationMode
}

type ApplicationVersionSummary struct {

	// The status of the application.
	//
	// This member is required.
	ApplicationStatus ApplicationStatus

	// The ID of the application version. Kinesis Data Analytics updates the
	// ApplicationVersionId each time you update the application.
	//
	// This member is required.
	ApplicationVersionId *int64
}

type ArtifactType string

const (
	ArtifactTypeUdf           ArtifactType = "UDF"
	ArtifactTypeDependencyJar ArtifactType = "DEPENDENCY_JAR"
)

type CSVMappingParameters struct {

	// The column delimiter. For example, in a CSV format, a comma (",") is the typical
	// column delimiter.
	//
	// This member is required.
	RecordColumnDelimiter *string

	// The row delimiter. For example, in a CSV format, '\n' is the typical row
	// delimiter.
	//
	// This member is required.
	RecordRowDelimiter *string
}

type CatalogConfiguration struct {

	// The configuration parameters for the default AWS Glue database. You use this
	// database for Apache Flink SQL queries and table API transforms that you write in
	// a Kinesis Data Analytics Studio notebook.
	//
	// This member is required.
	GlueDataCatalogConfiguration *GlueDataCatalogConfiguration
}

type CatalogConfigurationDescription struct {

	// The configuration parameters for the default AWS Glue database. You use this
	// database for SQL queries that you write in a Kinesis Data Analytics Studio
	// notebook.
	//
	// This member is required.
	GlueDataCatalogConfigurationDescription *GlueDataCatalogConfigurationDescription
}

type CatalogConfigurationUpdate struct {

	// Updates to the configuration parameters for the default AWS Glue database. You
	// use this database for SQL queries that you write in a Kinesis Data Analytics
	// Studio notebook.
	//
	// This member is required.
	GlueDataCatalogConfigurationUpdate *GlueDataCatalogConfigurationUpdate
}

type CheckpointConfiguration struct {

	// Describes whether the application uses Kinesis Data Analytics' default
	// checkpointing behavior. You must set this property to CUSTOM in order to set the
	// CheckpointingEnabled, CheckpointInterval, or MinPauseBetweenCheckpoints
	// parameters. If this value is set to DEFAULT, the application will use the
	// following values, even if they are set to other values using APIs or application
	// code:
	//
	// * CheckpointingEnabled: true
	//
	// * CheckpointInterval: 60000
	//
	// *
	// MinPauseBetweenCheckpoints: 5000
	//
	// This member is required.
	ConfigurationType ConfigurationType

	// Describes the interval in milliseconds between checkpoint operations. If
	// CheckpointConfiguration.ConfigurationType is DEFAULT, the application will use a
	// CheckpointInterval value of 60000, even if this value is set to another value
	// using this API or in application code.
	CheckpointInterval *int64

	// Describes whether checkpointing is enabled for a Flink-based Kinesis Data
	// Analytics application. If CheckpointConfiguration.ConfigurationType is DEFAULT,
	// the application will use a CheckpointingEnabled value of true, even if this
	// value is set to another value using this API or in application code.
	CheckpointingEnabled *bool

	// 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
	// (https://ci.apache.org/projects/flink/flink-docs-release-1.8/ops/state/large_state_tuning.html#tuning-checkpointing)
	// in the Apache Flink Documentation
	// (https://ci.apache.org/projects/flink/flink-docs-release-1.8/). If
	// CheckpointConfiguration.ConfigurationType is DEFAULT, the application will use a
	// MinPauseBetweenCheckpoints value of 5000, even if this value is set using this
	// API or in application code.
	MinPauseBetweenCheckpoints *int64
}

type CheckpointConfigurationDescription struct {

	// Describes the interval in milliseconds between checkpoint operations. If
	// CheckpointConfiguration.ConfigurationType is DEFAULT, the application will use a
	// CheckpointInterval value of 60000, even if this value is set to another value
	// using this API or in application code.
	CheckpointInterval *int64

	// Describes whether checkpointing is enabled for a Flink-based Kinesis Data
	// Analytics application. If CheckpointConfiguration.ConfigurationType is DEFAULT,
	// the application will use a CheckpointingEnabled value of true, even if this
	// value is set to another value using this API or in application code.
	CheckpointingEnabled *bool

	// Describes whether the application uses the default checkpointing behavior in
	// Kinesis Data Analytics. If this value is set to DEFAULT, the application will
	// use the following values, even if they are set to other values using APIs or
	// application code:
	//
	// * CheckpointingEnabled: true
	//
	// * CheckpointInterval: 60000
	//
	// *
	// MinPauseBetweenCheckpoints: 5000
	ConfigurationType ConfigurationType

	// Describes the minimum time in milliseconds after a checkpoint operation
	// completes that a new checkpoint operation can start. If
	// CheckpointConfiguration.ConfigurationType is DEFAULT, the application will use a
	// MinPauseBetweenCheckpoints value of 5000, even if this value is set using this
	// API or in application code.
	MinPauseBetweenCheckpoints *int64
}

type CheckpointConfigurationUpdate struct {

	// Describes updates to the interval in milliseconds between checkpoint operations.
	// If CheckpointConfiguration.ConfigurationType is DEFAULT, the application will
	// use a CheckpointInterval value of 60000, even if this value is set to another
	// value using this API or in application code.
	CheckpointIntervalUpdate *int64

	// Describes updates to whether checkpointing is enabled for an application. If
	// CheckpointConfiguration.ConfigurationType is DEFAULT, the application will use a
	// CheckpointingEnabled value of true, even if this value is set to another value
	// using this API or in application code.
	CheckpointingEnabledUpdate *bool

	// Describes updates to whether the application uses the default checkpointing
	// behavior of Kinesis Data Analytics. You must set this property to CUSTOM in
	// order to set the CheckpointingEnabled, CheckpointInterval, or
	// MinPauseBetweenCheckpoints parameters. If this value is set to DEFAULT, the
	// application will use the following values, even if they are set to other values
	// using APIs or application code:
	//
	// * CheckpointingEnabled: true
	//
	// *
	// CheckpointInterval: 60000
	//
	// * MinPauseBetweenCheckpoints: 5000
	ConfigurationTypeUpdate ConfigurationType

	// Describes updates to the minimum time in milliseconds after a checkpoint
	// operation completes that a new checkpoint operation can start. If
	// CheckpointConfiguration.ConfigurationType is DEFAULT, the application will use a
	// MinPauseBetweenCheckpoints value of 5000, even if this value is set using this
	// API or in application code.
	MinPauseBetweenCheckpointsUpdate *int64
}

type CloudWatchLoggingOption struct {

	// The ARN of the CloudWatch log to receive application messages.
	//
	// This member is required.
	LogStreamARN *string
}

type CloudWatchLoggingOptionDescription struct {

	// The Amazon Resource Name (ARN) of the CloudWatch log to receive application
	// messages.
	//
	// This member is required.
	LogStreamARN *string

	// The ID of the CloudWatch logging option description.
	CloudWatchLoggingOptionId *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.
	RoleARN *string
}

type CloudWatchLoggingOptionUpdate struct {

	// The ID of the CloudWatch logging option to update
	//
	// This member is required.
	CloudWatchLoggingOptionId *string

	// The Amazon Resource Name (ARN) of the CloudWatch log to receive application
	// messages.
	LogStreamARNUpdate *string
}

type CodeContent struct {

	// Information about the Amazon S3 bucket that contains the application code.
	S3ContentLocation *S3ContentLocation

	// The text-format code for a Flink-based Kinesis Data Analytics application.
	TextContent *string

	// The zip-format code for a Flink-based Kinesis Data Analytics application.
	ZipFileContent []byte
}

type CodeContentDescription struct {

	// The checksum that can be used to validate zip-format code.
	CodeMD5 *string

	// The size in bytes of the application code. Can be used to validate zip-format
	// code.
	CodeSize *int64

	// The S3 bucket Amazon Resource Name (ARN), file key, and object version of the
	// application code stored in Amazon S3.
	S3ApplicationCodeLocationDescription *S3ApplicationCodeLocationDescription

	// The text-format code
	TextContent *string
}

type CodeContentType string

const (
	CodeContentTypePlaintext CodeContentType = "PLAINTEXT"
	CodeContentTypeZipfile   CodeContentType = "ZIPFILE"
)

type CodeContentUpdate struct {

	// Describes an update to the location of code for an application.
	S3ContentLocationUpdate *S3ContentLocationUpdate

	// Describes an update to the text code for an application.
	TextContentUpdate *string

	// Describes an update to the zipped code for an application.
	ZipFileContentUpdate []byte
}

type CodeValidationException struct {
	Message *string
}

type ConcurrentModificationException struct {
	Message *string
}

type ConfigurationType string

const (
	ConfigurationTypeDefault ConfigurationType = "DEFAULT"
	ConfigurationTypeCustom  ConfigurationType = "CUSTOM"
)

type CustomArtifactConfiguration struct {

	// UDF stands for user-defined functions. This type of artifact must be in an S3
	// bucket. A DEPENDENCY_JAR can be in either Maven or an S3 bucket.
	//
	// This member is required.
	ArtifactType ArtifactType

	// The parameters required to fully specify a Maven reference.
	MavenReference *MavenReference

	// For a Kinesis Data Analytics application provides a description of an Amazon S3
	// object, including the Amazon Resource Name (ARN) of the S3 bucket, the name of
	// the Amazon S3 object that contains the data, and the version number of the
	// Amazon S3 object that contains the data.
	S3ContentLocation *S3ContentLocation
}

type CustomArtifactConfigurationDescription struct {

	// UDF stands for user-defined functions. This type of artifact must be in an S3
	// bucket. A DEPENDENCY_JAR can be in either Maven or an S3 bucket.
	ArtifactType ArtifactType

	// The parameters that are required to specify a Maven dependency.
	MavenReferenceDescription *MavenReference

	// For a Kinesis Data Analytics application provides a description of an Amazon S3
	// object, including the Amazon Resource Name (ARN) of the S3 bucket, the name of
	// the Amazon S3 object that contains the data, and the version number of the
	// Amazon S3 object that contains the data.
	S3ContentLocationDescription *S3ContentLocation
}

type DeployAsApplicationConfiguration struct {

	// The description of an Amazon S3 object that contains the Amazon Data Analytics
	// application, including the Amazon Resource Name (ARN) of the S3 bucket, the name
	// of the Amazon S3 object that contains the data, and the version number of the
	// Amazon S3 object that contains the data.
	//
	// This member is required.
	S3ContentLocation *S3ContentBaseLocation
}

type DeployAsApplicationConfigurationDescription struct {

	// The location that holds the data required to specify an Amazon Data Analytics
	// application.
	//
	// This member is required.
	S3ContentLocationDescription *S3ContentBaseLocationDescription
}

type DeployAsApplicationConfigurationUpdate struct {

	// Updates to the location that holds the data required to specify an Amazon Data
	// Analytics application.
	//
	// This member is required.
	S3ContentLocationUpdate *S3ContentBaseLocationUpdate
}

type DestinationSchema struct {

	// Specifies the format of the records on the output stream.
	//
	// This member is required.
	RecordFormatType RecordFormatType
}

type EnvironmentProperties struct {

	// Describes the execution property groups.
	//
	// This member is required.
	PropertyGroups []PropertyGroup
}

type EnvironmentPropertyDescriptions struct {

	// Describes the execution property groups.
	PropertyGroupDescriptions []PropertyGroup
}

type EnvironmentPropertyUpdates struct {

	// Describes updates to the execution property groups.
	//
	// This member is required.
	PropertyGroups []PropertyGroup
}

type FlinkApplicationConfiguration struct {

	// 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
	// (https://ci.apache.org/projects/flink/flink-docs-release-1.8/concepts/programming-model.html#checkpoints-for-fault-tolerance)
	// in the Apache Flink Documentation
	// (https://ci.apache.org/projects/flink/flink-docs-release-1.8/).
	CheckpointConfiguration *CheckpointConfiguration

	// Describes configuration parameters for Amazon CloudWatch logging for an
	// application.
	MonitoringConfiguration *MonitoringConfiguration

	// Describes parameters for how an application executes multiple tasks
	// simultaneously.
	ParallelismConfiguration *ParallelismConfiguration
}

type FlinkApplicationConfigurationDescription struct {

	// Describes an application's checkpointing configuration. Checkpointing is the
	// process of persisting application state for fault tolerance.
	CheckpointConfigurationDescription *CheckpointConfigurationDescription

	// The job plan for an application. For more information about the job plan, see
	// Jobs and Scheduling
	// (https://ci.apache.org/projects/flink/flink-docs-release-1.8/internals/job_scheduling.html)
	// in the Apache Flink Documentation
	// (https://ci.apache.org/projects/flink/flink-docs-release-1.8/). To retrieve the
	// job plan for the application, use the
	// DescribeApplicationRequest$IncludeAdditionalDetails parameter of the
	// DescribeApplication operation.
	JobPlanDescription *string

	// Describes configuration parameters for Amazon CloudWatch logging for an
	// application.
	MonitoringConfigurationDescription *MonitoringConfigurationDescription

	// Describes parameters for how an application executes multiple tasks
	// simultaneously.
	ParallelismConfigurationDescription *ParallelismConfigurationDescription
}

type FlinkApplicationConfigurationUpdate struct {

	// Describes updates to an application's checkpointing configuration. Checkpointing
	// is the process of persisting application state for fault tolerance.
	CheckpointConfigurationUpdate *CheckpointConfigurationUpdate

	// Describes updates to the configuration parameters for Amazon CloudWatch logging
	// for an application.
	MonitoringConfigurationUpdate *MonitoringConfigurationUpdate

	// Describes updates to the parameters for how an application executes multiple
	// tasks simultaneously.
	ParallelismConfigurationUpdate *ParallelismConfigurationUpdate
}

type FlinkRunConfiguration struct {

	// When restoring from a snapshot, specifies whether the runtime is allowed to skip
	// a state that cannot be mapped to the new program. This will happen if the
	// program is updated between snapshots to remove stateful parameters, and state
	// data in the snapshot no longer corresponds to valid application data. For more
	// information, see  Allowing Non-Restored State
	// (https://ci.apache.org/projects/flink/flink-docs-release-1.8/ops/state/savepoints.html#allowing-non-restored-state)
	// in the Apache Flink documentation
	// (https://ci.apache.org/projects/flink/flink-docs-release-1.8/). This value
	// defaults to false. If you update your application without specifying this
	// parameter, AllowNonRestoredState will be set to false, even if it was previously
	// set to true.
	AllowNonRestoredState *bool
}

type GlueDataCatalogConfiguration struct {

	// The Amazon Resource Name (ARN) of the database.
	//
	// This member is required.
	DatabaseARN *string
}

type GlueDataCatalogConfigurationDescription struct {

	// The Amazon Resource Name (ARN) of the database.
	//
	// This member is required.
	DatabaseARN *string
}

type GlueDataCatalogConfigurationUpdate struct {

	// The updated Amazon Resource Name (ARN) of the database.
	DatabaseARNUpdate *string
}

type Input struct {

	// 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.
	//
	// This member is required.
	InputSchema *SourceSchema

	// 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.
	//
	// This member is required.
	NamePrefix *string

	// Describes the number of in-application streams to create.
	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.
	InputProcessingConfiguration *InputProcessingConfiguration

	// If the streaming source is an Amazon Kinesis Data Firehose delivery stream,
	// identifies the delivery stream's ARN.
	KinesisFirehoseInput *KinesisFirehoseInput

	// If the streaming source is an Amazon Kinesis data stream, identifies the
	// stream's Amazon Resource Name (ARN).
	KinesisStreamsInput *KinesisStreamsInput
}

type InputDescription struct {

	// Returns the in-application stream names that are mapped to the stream source.
	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.
	InputId *string

	// Describes the configured parallelism (number of in-application streams mapped to
	// the streaming source).
	InputParallelism *InputParallelism

	// The description of the preprocessor that executes on records in this input
	// before the application's code is run.
	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.
	InputSchema *SourceSchema

	// The point at which the application is configured to read from the input stream.
	InputStartingPositionConfiguration *InputStartingPositionConfiguration

	// If a Kinesis Data Firehose delivery stream is configured as a streaming source,
	// provides the delivery stream's ARN.
	KinesisFirehoseInputDescription *KinesisFirehoseInputDescription

	// If a Kinesis data stream is configured as a streaming source, provides the
	// Kinesis data stream's Amazon Resource Name (ARN).
	KinesisStreamsInputDescription *KinesisStreamsInputDescription

	// The in-application name prefix.
	NamePrefix *string
}

type InputLambdaProcessor struct {

	// 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
	// (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html#arn-syntax-lambda)
	//
	// This member is required.
	ResourceARN *string
}

type InputLambdaProcessorDescription struct {

	// 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
	// (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html#arn-syntax-lambda)
	//
	// This member is required.
	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.
	RoleARN *string
}

type InputLambdaProcessorUpdate struct {

	// 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
	// (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html#arn-syntax-lambda)
	//
	// This member is required.
	ResourceARNUpdate *string
}

type InputParallelism struct {

	// The number of in-application streams to create.
	Count *int32
}

type InputParallelismUpdate struct {

	// The number of in-application streams to create for the specified streaming
	// source.
	//
	// This member is required.
	CountUpdate *int32
}

type InputProcessingConfiguration struct {

	// The InputLambdaProcessor that is used to preprocess the records in the stream
	// before being processed by your application code.
	//
	// This member is required.
	InputLambdaProcessor *InputLambdaProcessor
}

type InputProcessingConfigurationDescription struct {

	// Provides configuration information about the associated
	// InputLambdaProcessorDescription
	InputLambdaProcessorDescription *InputLambdaProcessorDescription
}

type InputProcessingConfigurationUpdate struct {

	// Provides update information for an InputLambdaProcessor.
	//
	// This member is required.
	InputLambdaProcessorUpdate *InputLambdaProcessorUpdate
}

type InputSchemaUpdate struct {

	// A list of RecordColumn objects. Each object describes the mapping of the
	// streaming source element to the corresponding column in the in-application
	// stream.
	RecordColumnUpdates []RecordColumn

	// Specifies the encoding of the records in the streaming source; for example,
	// UTF-8.
	RecordEncodingUpdate *string

	// Specifies the format of the records on the streaming source.
	RecordFormatUpdate *RecordFormat
}

type InputStartingPosition string

const (
	InputStartingPositionNow              InputStartingPosition = "NOW"
	InputStartingPositionTrimHorizon      InputStartingPosition = "TRIM_HORIZON"
	InputStartingPositionLastStoppedPoint InputStartingPosition = "LAST_STOPPED_POINT"
)

type InputStartingPositionConfiguration struct {

	// 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.
	InputStartingPosition InputStartingPosition
}

type InputUpdate struct {

	// The input ID of the application input to be updated.
	//
	// This member is required.
	InputId *string

	// Describes the parallelism updates (the number of in-application streams Kinesis
	// Data Analytics creates for the specific streaming source).
	InputParallelismUpdate *InputParallelismUpdate

	// Describes updates to an InputProcessingConfiguration.
	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.
	InputSchemaUpdate *InputSchemaUpdate

	// If a Kinesis Data Firehose delivery stream is the streaming source to be
	// updated, provides an updated stream ARN.
	KinesisFirehoseInputUpdate *KinesisFirehoseInputUpdate

	// If a Kinesis data stream is the streaming source to be updated, provides an
	// updated stream Amazon Resource Name (ARN).
	KinesisStreamsInputUpdate *KinesisStreamsInputUpdate

	// The name prefix for in-application streams that Kinesis Data Analytics creates
	// for the specific streaming source.
	NamePrefixUpdate *string
}

type InvalidApplicationConfigurationException struct {
	Message *string
}

type InvalidArgumentException struct {
	Message *string
}

type InvalidRequestException struct {
	Message *string
}

type JSONMappingParameters struct {

	// The path to the top-level parent that contains the records.
	//
	// This member is required.
	RecordRowPath *string
}

type KinesisFirehoseInput struct {

	// The Amazon Resource Name (ARN) of the delivery stream.
	//
	// This member is required.
	ResourceARN *string
}

type KinesisFirehoseInputDescription struct {

	// The Amazon Resource Name (ARN) of the delivery stream.
	//
	// This member is required.
	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.
	RoleARN *string
}

type KinesisFirehoseInputUpdate struct {

	// The Amazon Resource Name (ARN) of the input delivery stream to read.
	//
	// This member is required.
	ResourceARNUpdate *string
}

type KinesisFirehoseOutput struct {

	// The ARN of the destination delivery stream to write to.
	//
	// This member is required.
	ResourceARN *string
}

type KinesisFirehoseOutputDescription struct {

	// The Amazon Resource Name (ARN) of the delivery stream.
	//
	// This member is required.
	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.
	RoleARN *string
}

type KinesisFirehoseOutputUpdate struct {

	// The Amazon Resource Name (ARN) of the delivery stream to write to.
	//
	// This member is required.
	ResourceARNUpdate *string
}

type KinesisStreamsInput struct {

	// The ARN of the input Kinesis data stream to read.
	//
	// This member is required.
	ResourceARN *string
}

type KinesisStreamsInputDescription struct {

	// The Amazon Resource Name (ARN) of the Kinesis data stream.
	//
	// This member is required.
	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.
	RoleARN *string
}

type KinesisStreamsInputUpdate struct {

	// The Amazon Resource Name (ARN) of the input Kinesis data stream to read.
	//
	// This member is required.
	ResourceARNUpdate *string
}

type KinesisStreamsOutput struct {

	// The ARN of the destination Kinesis data stream to write to.
	//
	// This member is required.
	ResourceARN *string
}

type KinesisStreamsOutputDescription struct {

	// The Amazon Resource Name (ARN) of the Kinesis data stream.
	//
	// This member is required.
	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.
	RoleARN *string
}

type KinesisStreamsOutputUpdate struct {

	// The Amazon Resource Name (ARN) of the Kinesis data stream where you want to
	// write the output.
	//
	// This member is required.
	ResourceARNUpdate *string
}

type LambdaOutput struct {

	// 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
	// (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html#arn-syntax-lambda)
	//
	// This member is required.
	ResourceARN *string
}

type LambdaOutputDescription struct {

	// The Amazon Resource Name (ARN) of the destination Lambda function.
	//
	// This member is required.
	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.
	RoleARN *string
}

type LambdaOutputUpdate struct {

	// 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
	// (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html#arn-syntax-lambda)
	//
	// This member is required.
	ResourceARNUpdate *string
}

type LimitExceededException struct {
	Message *string
}

type LogLevel string

const (
	LogLevelInfo  LogLevel = "INFO"
	LogLevelWarn  LogLevel = "WARN"
	LogLevelError LogLevel = "ERROR"
	LogLevelDebug LogLevel = "DEBUG"
)

type MappingParameters struct {

	// Provides additional mapping information when the record format uses delimiters
	// (for example, CSV).
	CSVMappingParameters *CSVMappingParameters

	// Provides additional mapping information when JSON is the record format on the
	// streaming source.
	JSONMappingParameters *JSONMappingParameters
}

type MavenReference struct {

	// The artifact ID of the Maven reference.
	//
	// This member is required.
	ArtifactId *string

	// The group ID of the Maven reference.
	//
	// This member is required.
	GroupId *string

	// The version of the Maven reference.
	//
	// This member is required.
	Version *string
}

type MetricsLevel string

const (
	MetricsLevelApplication MetricsLevel = "APPLICATION"
	MetricsLevelTask        MetricsLevel = "TASK"
	MetricsLevelOperator    MetricsLevel = "OPERATOR"
	MetricsLevelParallelism MetricsLevel = "PARALLELISM"
)

type MonitoringConfiguration struct {

	// Describes whether to use the default CloudWatch logging configuration for an
	// application. You must set this property to CUSTOM in order to set the LogLevel
	// or MetricsLevel parameters.
	//
	// This member is required.
	ConfigurationType ConfigurationType

	// Describes the verbosity of the CloudWatch Logs for an application.
	LogLevel LogLevel

	// Describes the granularity of the CloudWatch Logs for an application. The
	// Parallelism level is not recommended for applications with a Parallelism over 64
	// due to excessive costs.
	MetricsLevel MetricsLevel
}

type MonitoringConfigurationDescription struct {

	// Describes whether to use the default CloudWatch logging configuration for an
	// application.
	ConfigurationType ConfigurationType

	// Describes the verbosity of the CloudWatch Logs for an application.
	LogLevel LogLevel

	// Describes the granularity of the CloudWatch Logs for an application.
	MetricsLevel MetricsLevel
}

type MonitoringConfigurationUpdate struct {

	// Describes updates to whether to use the default CloudWatch logging configuration
	// for an application. You must set this property to CUSTOM in order to set the
	// LogLevel or MetricsLevel parameters.
	ConfigurationTypeUpdate ConfigurationType

	// Describes updates to the verbosity of the CloudWatch Logs for an application.
	LogLevelUpdate LogLevel

	// Describes updates to the granularity of the CloudWatch Logs for an application.
	// The Parallelism level is not recommended for applications with a Parallelism
	// over 64 due to excessive costs.
	MetricsLevelUpdate MetricsLevel
}

type Output struct {

	// Describes the data format when records are written to the destination.
	//
	// This member is required.
	DestinationSchema *DestinationSchema

	// The name of the in-application stream.
	//
	// This member is required.
	Name *string

	// Identifies a Kinesis Data Firehose delivery stream as the destination.
	KinesisFirehoseOutput *KinesisFirehoseOutput

	// Identifies a Kinesis data stream as the destination.
	KinesisStreamsOutput *KinesisStreamsOutput

	// Identifies an AWS Lambda function as the destination.
	LambdaOutput *LambdaOutput
}

type OutputDescription struct {

	// The data format used for writing data to the destination.
	DestinationSchema *DestinationSchema

	// Describes the Kinesis Data Firehose delivery stream that is configured as the
	// destination where output is written.
	KinesisFirehoseOutputDescription *KinesisFirehoseOutputDescription

	// Describes the Kinesis data stream that is configured as the destination where
	// output is written.
	KinesisStreamsOutputDescription *KinesisStreamsOutputDescription

	// Describes the Lambda function that is configured as the destination where output
	// is written.
	LambdaOutputDescription *LambdaOutputDescription

	// The name of the in-application stream that is configured as output.
	Name *string

	// A unique identifier for the output configuration.
	OutputId *string
}

type OutputUpdate struct {

	// Identifies the specific output configuration that you want to update.
	//
	// This member is required.
	OutputId *string

	// Describes the data format when records are written to the destination.
	DestinationSchemaUpdate *DestinationSchema

	// Describes a Kinesis Data Firehose delivery stream as the destination for the
	// output.
	KinesisFirehoseOutputUpdate *KinesisFirehoseOutputUpdate

	// Describes a Kinesis data stream as the destination for the output.
	KinesisStreamsOutputUpdate *KinesisStreamsOutputUpdate

	// Describes an AWS Lambda function as the destination for the output.
	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.
	NameUpdate *string
}

type ParallelismConfiguration struct {

	// Describes whether the application uses the default parallelism for the Kinesis
	// Data Analytics service. You must set this property to CUSTOM in order to change
	// your application's AutoScalingEnabled, Parallelism, or ParallelismPerKPU
	// properties.
	//
	// This member is required.
	ConfigurationType ConfigurationType

	// Describes whether the Kinesis Data Analytics service can increase the
	// parallelism of the application in response to increased throughput.
	AutoScalingEnabled *bool

	// Describes the initial number of parallel tasks that a Flink-based Kinesis Data
	// Analytics application can perform. If AutoScalingEnabled is set to True, Kinesis
	// Data Analytics increases the CurrentParallelism value in response to application
	// load. The service can increase the CurrentParallelism value up to the maximum
	// parallelism, which is ParalellismPerKPU times the maximum KPUs for the
	// application. The maximum KPUs for an application is 32 by default, and can be
	// increased by requesting a limit increase. If application load is reduced, the
	// service can reduce the CurrentParallelism value down to the Parallelism setting.
	Parallelism *int32

	// Describes the number of parallel tasks that a Flink-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 (http://aws.amazon.com/kinesis/data-analytics/pricing/).
	ParallelismPerKPU *int32
}

type ParallelismConfigurationDescription struct {

	// Describes whether the Kinesis Data Analytics service can increase the
	// parallelism of the application in response to increased throughput.
	AutoScalingEnabled *bool

	// Describes whether the application uses the default parallelism for the Kinesis
	// Data Analytics service.
	ConfigurationType ConfigurationType

	// Describes the current number of parallel tasks that a Flink-based Kinesis Data
	// Analytics application can perform. If AutoScalingEnabled is set to True, Kinesis
	// Data Analytics can increase this value in response to application load. The
	// service can increase this value up to the maximum parallelism, which is
	// ParalellismPerKPU times the maximum KPUs for the application. The maximum KPUs
	// for an application is 32 by default, and can be increased by requesting a limit
	// increase. If application load is reduced, the service can reduce the
	// CurrentParallelism value down to the Parallelism setting.
	CurrentParallelism *int32

	// Describes the initial number of parallel tasks that a Flink-based Kinesis Data
	// Analytics application can perform. If AutoScalingEnabled is set to True, then
	// Kinesis Data Analytics can increase the CurrentParallelism value in response to
	// application load. The service can increase CurrentParallelism up to the maximum
	// parallelism, which is ParalellismPerKPU times the maximum KPUs for the
	// application. The maximum KPUs for an application is 32 by default, and can be
	// increased by requesting a limit increase. If application load is reduced, the
	// service can reduce the CurrentParallelism value down to the Parallelism setting.
	Parallelism *int32

	// Describes the number of parallel tasks that a Flink-based Kinesis Data Analytics
	// application can perform per Kinesis Processing Unit (KPU) used by the
	// application.
	ParallelismPerKPU *int32
}

type ParallelismConfigurationUpdate struct {

	// Describes updates to whether the Kinesis Data Analytics service can increase the
	// parallelism of a Flink-based Kinesis Data Analytics application in response to
	// increased throughput.
	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. You must
	// set this property to CUSTOM in order to change your application's
	// AutoScalingEnabled, Parallelism, or ParallelismPerKPU properties.
	ConfigurationTypeUpdate ConfigurationType

	// Describes updates to the number of parallel tasks an application can perform per
	// Kinesis Processing Unit (KPU) used by the application.
	ParallelismPerKPUUpdate *int32

	// Describes updates to the initial number of parallel tasks an application can
	// perform. If AutoScalingEnabled is set to True, then Kinesis Data Analytics can
	// increase the CurrentParallelism value in response to application load. The
	// service can increase CurrentParallelism up to the maximum parallelism, which is
	// ParalellismPerKPU times the maximum KPUs for the application. The maximum KPUs
	// for an application is 32 by default, and can be increased by requesting a limit
	// increase. If application load is reduced, the service will reduce
	// CurrentParallelism down to the Parallelism setting.
	ParallelismUpdate *int32
}

type PropertyGroup struct {

	// Describes the key of an application execution property key-value pair.
	//
	// This member is required.
	PropertyGroupId *string

	// Describes the value of an application execution property key-value pair.
	//
	// This member is required.
	PropertyMap map[string]string
}

type RecordColumn struct {

	// The name of the column that is created in the in-application input stream or
	// reference table.
	//
	// This member is required.
	Name *string

	// The type of column created in the in-application input stream or reference
	// table.
	//
	// This member is required.
	SqlType *string

	// A reference to the data element in the streaming input or the reference data
	// source.
	Mapping *string
}

type RecordFormat struct {

	// The type of record format.
	//
	// This member is required.
	RecordFormatType RecordFormatType

	// 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.
	MappingParameters *MappingParameters
}

type RecordFormatType string

const (
	RecordFormatTypeJson RecordFormatType = "JSON"
	RecordFormatTypeCsv  RecordFormatType = "CSV"
)

type ReferenceDataSource struct {

	// 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.
	//
	// This member is required.
	ReferenceSchema *SourceSchema

	// The name of the in-application table to create.
	//
	// This member is required.
	TableName *string

	// 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.
	S3ReferenceDataSource *S3ReferenceDataSource
}

type ReferenceDataSourceDescription struct {

	// 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.
	//
	// This member is required.
	ReferenceId *string

	// Provides the Amazon S3 bucket name, the object key name that contains the
	// reference data.
	//
	// This member is required.
	S3ReferenceDataSourceDescription *S3ReferenceDataSourceDescription

	// The in-application table name created by the specific reference data source
	// configuration.
	//
	// This member is required.
	TableName *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.
	ReferenceSchema *SourceSchema
}

type ReferenceDataSourceUpdate struct {

	// The ID of the reference data source that is being updated. You can use the
	// DescribeApplication operation to get this value.
	//
	// This member is required.
	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.
	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.
	S3ReferenceDataSourceUpdate *S3ReferenceDataSourceUpdate

	// The in-application table name that is created by this update.
	TableNameUpdate *string
}

type ResourceInUseException struct {
	Message *string
}

type ResourceNotFoundException struct {
	Message *string
}

type ResourceProvisionedThroughputExceededException struct {
	Message *string
}

type RunConfiguration struct {

	// Describes the restore behavior of a restarting application.
	ApplicationRestoreConfiguration *ApplicationRestoreConfiguration

	// Describes the starting parameters for a Flink-based Kinesis Data Analytics
	// application.
	FlinkRunConfiguration *FlinkRunConfiguration

	// Describes the starting parameters for a SQL-based Kinesis Data Analytics
	// application application.
	SqlRunConfigurations []SqlRunConfiguration
}

type RunConfigurationDescription struct {

	// Describes the restore behavior of a restarting application.
	ApplicationRestoreConfigurationDescription *ApplicationRestoreConfiguration

	// Describes the starting parameters for a Flink-based Kinesis Data Analytics
	// application.
	FlinkRunConfigurationDescription *FlinkRunConfiguration
}

type RunConfigurationUpdate struct {

	// Describes updates to the restore behavior of a restarting application.
	ApplicationRestoreConfiguration *ApplicationRestoreConfiguration

	// Describes the starting parameters for a Flink-based Kinesis Data Analytics
	// application.
	FlinkRunConfiguration *FlinkRunConfiguration
}

type RuntimeEnvironment string

const (
	RuntimeEnvironmentSql10           RuntimeEnvironment = "SQL-1_0"
	RuntimeEnvironmentFlink16         RuntimeEnvironment = "FLINK-1_6"
	RuntimeEnvironmentFlink18         RuntimeEnvironment = "FLINK-1_8"
	RuntimeEnvironmentFlink111        RuntimeEnvironment = "FLINK-1_11"
	RuntimeEnvironmentZeppelinFlink10 RuntimeEnvironment = "ZEPPELIN-FLINK-1_0"
)

type S3ApplicationCodeLocationDescription struct {

	// The Amazon Resource Name (ARN) for the S3 bucket containing the application
	// code.
	//
	// This member is required.
	BucketARN *string

	// The file key for the object containing the application code.
	//
	// This member is required.
	FileKey *string

	// The version of the object containing the application code.
	ObjectVersion *string
}

type S3Configuration struct {

	// The ARN of the S3 bucket that contains the data.
	//
	// This member is required.
	BucketARN *string

	// The name of the object that contains the data.
	//
	// This member is required.
	FileKey *string
}

type S3ContentBaseLocation struct {

	// The Amazon Resource Name (ARN) of the S3 bucket.
	//
	// This member is required.
	BucketARN *string

	// The base path for the S3 bucket.
	BasePath *string
}

type S3ContentBaseLocationDescription struct {

	// The Amazon Resource Name (ARN) of the S3 bucket.
	//
	// This member is required.
	BucketARN *string

	// The base path for the S3 bucket.
	BasePath *string
}

type S3ContentBaseLocationUpdate struct {

	// The updated Amazon Resource Name (ARN) of the S3 bucket.
	//
	// This member is required.
	BucketARNUpdate *string

	// The updated S3 bucket path.
	BasePathUpdate *string
}

type S3ContentLocation struct {

	// The Amazon Resource Name (ARN) for the S3 bucket containing the application
	// code.
	//
	// This member is required.
	BucketARN *string

	// The file key for the object containing the application code.
	//
	// This member is required.
	FileKey *string

	// The version of the object containing the application code.
	ObjectVersion *string
}

type S3ContentLocationUpdate struct {

	// The new Amazon Resource Name (ARN) for the S3 bucket containing the application
	// code.
	BucketARNUpdate *string

	// The new file key for the object containing the application code.
	FileKeyUpdate *string

	// The new version of the object containing the application code.
	ObjectVersionUpdate *string
}

type S3ReferenceDataSource struct {

	// The Amazon Resource Name (ARN) of the S3 bucket.
	BucketARN *string

	// The object key name containing the reference data.
	FileKey *string
}

type S3ReferenceDataSourceDescription struct {

	// The Amazon Resource Name (ARN) of the S3 bucket.
	//
	// This member is required.
	BucketARN *string

	// Amazon S3 object key name.
	//
	// This member is required.
	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.
	ReferenceRoleARN *string
}

type S3ReferenceDataSourceUpdate struct {

	// The Amazon Resource Name (ARN) of the S3 bucket.
	BucketARNUpdate *string

	// The object key name.
	FileKeyUpdate *string
}

type ServiceUnavailableException struct {
	Message *string
}

type SnapshotDetails struct {

	// The current application version ID when the snapshot was created.
	//
	// This member is required.
	ApplicationVersionId *int64

	// The identifier for the application snapshot.
	//
	// This member is required.
	SnapshotName *string

	// The status of the application snapshot.
	//
	// This member is required.
	SnapshotStatus SnapshotStatus

	// The timestamp of the application snapshot.
	SnapshotCreationTimestamp *time.Time
}

type SnapshotStatus string

const (
	SnapshotStatusCreating SnapshotStatus = "CREATING"
	SnapshotStatusReady    SnapshotStatus = "READY"
	SnapshotStatusDeleting SnapshotStatus = "DELETING"
	SnapshotStatusFailed   SnapshotStatus = "FAILED"
)

type SourceSchema struct {

	// A list of RecordColumn objects.
	//
	// This member is required.
	RecordColumns []RecordColumn

	// Specifies the format of the records on the streaming source.
	//
	// This member is required.
	RecordFormat *RecordFormat

	// Specifies the encoding of the records in the streaming source. For example,
	// UTF-8.
	RecordEncoding *string
}

type SqlApplicationConfiguration struct {

	// The array of Input objects describing the input streams used by the application.
	Inputs []Input

	// The array of Output objects describing the destination streams used by the
	// application.
	Outputs []Output

	// The array of ReferenceDataSource objects describing the reference data sources
	// used by the application.
	ReferenceDataSources []ReferenceDataSource
}

type SqlApplicationConfigurationDescription struct {

	// The array of InputDescription objects describing the input streams used by the
	// application.
	InputDescriptions []InputDescription

	// The array of OutputDescription objects describing the destination streams used
	// by the application.
	OutputDescriptions []OutputDescription

	// The array of ReferenceDataSourceDescription objects describing the reference
	// data sources used by the application.
	ReferenceDataSourceDescriptions []ReferenceDataSourceDescription
}

type SqlApplicationConfigurationUpdate struct {

	// The array of InputUpdate objects describing the new input streams used by the
	// application.
	InputUpdates []InputUpdate

	// The array of OutputUpdate objects describing the new destination streams used by
	// the application.
	OutputUpdates []OutputUpdate

	// The array of ReferenceDataSourceUpdate objects describing the new reference data
	// sources used by the application.
	ReferenceDataSourceUpdates []ReferenceDataSourceUpdate
}

type SqlRunConfiguration struct {

	// The input source ID. You can get this ID by calling the DescribeApplication
	// operation.
	//
	// This member is required.
	InputId *string

	// The point at which you want the application to start processing records from the
	// streaming source.
	//
	// This member is required.
	InputStartingPositionConfiguration *InputStartingPositionConfiguration
}

type Tag struct {

	// The key of the key-value tag.
	//
	// This member is required.
	Key *string

	// The value of the key-value tag. The value is optional.
	Value *string
}

type TooManyTagsException struct {
	Message *string
}

type UnableToDetectSchemaException struct {
	Message *string

	RawInputRecords       []string
	ProcessedInputRecords []string
}

type UnsupportedOperationException struct {
	Message *string
}

type UrlType string

const (
	UrlTypeFlinkDashboardUrl UrlType = "FLINK_DASHBOARD_URL"
	UrlTypeZeppelinUiUrl     UrlType = "ZEPPELIN_UI_URL"
)

type VpcConfiguration struct {

	// The array of SecurityGroup
	// (https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_SecurityGroup.html)
	// IDs used by the VPC configuration.
	//
	// This member is required.
	SecurityGroupIds []string

	// The array of Subnet
	// (https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_Subnet.html) IDs
	// used by the VPC configuration.
	//
	// This member is required.
	SubnetIds []string
}

type VpcConfigurationDescription struct {

	// The array of SecurityGroup
	// (https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_SecurityGroup.html)
	// IDs used by the VPC configuration.
	//
	// This member is required.
	SecurityGroupIds []string

	// The array of Subnet
	// (https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_Subnet.html) IDs
	// used by the VPC configuration.
	//
	// This member is required.
	SubnetIds []string

	// The ID of the VPC configuration.
	//
	// This member is required.
	VpcConfigurationId *string

	// The ID of the associated VPC.
	//
	// This member is required.
	VpcId *string
}

type VpcConfigurationUpdate struct {

	// Describes an update to the ID of the VPC configuration.
	//
	// This member is required.
	VpcConfigurationId *string

	// Describes updates to the array of SecurityGroup
	// (https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_SecurityGroup.html)
	// IDs used by the VPC configuration.
	SecurityGroupIdUpdates []string

	// Describes updates to the array of Subnet
	// (https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_Subnet.html) IDs
	// used by the VPC configuration.
	SubnetIdUpdates []string
}

type ZeppelinApplicationConfiguration struct {

	// The AWS Glue Data Catalog that you use in queries in a Kinesis Data Analytics
	// Studio notebook.
	CatalogConfiguration *CatalogConfiguration

	// Custom artifacts are dependency JARs and user-defined functions (UDF).
	CustomArtifactsConfiguration []CustomArtifactConfiguration

	// The information required to deploy a Kinesis Data Analytics Studio notebook as
	// an application with durable state..
	DeployAsApplicationConfiguration *DeployAsApplicationConfiguration

	// The monitoring configuration of a Kinesis Data Analytics Studio notebook.
	MonitoringConfiguration *ZeppelinMonitoringConfiguration
}

type ZeppelinApplicationConfigurationDescription struct {

	// The monitoring configuration of a Kinesis Data Analytics Studio notebook.
	//
	// This member is required.
	MonitoringConfigurationDescription *ZeppelinMonitoringConfigurationDescription

	// The AWS Glue Data Catalog that is associated with the Kinesis Data Analytics
	// Studio notebook.
	CatalogConfigurationDescription *CatalogConfigurationDescription

	// Custom artifacts are dependency JARs and user-defined functions (UDF).
	CustomArtifactsConfigurationDescription []CustomArtifactConfigurationDescription

	// The parameters required to deploy a Kinesis Data Analytics Studio notebook as an
	// application with durable state..
	DeployAsApplicationConfigurationDescription *DeployAsApplicationConfigurationDescription
}

type ZeppelinApplicationConfigurationUpdate struct {

	// Updates to the configuration of the AWS Glue Data Catalog that is associated
	// with the Kinesis Data Analytics Studio notebook.
	CatalogConfigurationUpdate *CatalogConfigurationUpdate

	// Updates to the customer artifacts. Custom artifacts are dependency JAR files and
	// user-defined functions (UDF).
	CustomArtifactsConfigurationUpdate []CustomArtifactConfiguration

	// Updates to the configuration information required to deploy an Amazon Data
	// Analytics Studio notebook as an application with durable state..
	DeployAsApplicationConfigurationUpdate *DeployAsApplicationConfigurationUpdate

	// Updates to the monitoring configuration of a Kinesis Data Analytics Studio
	// notebook.
	MonitoringConfigurationUpdate *ZeppelinMonitoringConfigurationUpdate
}

type ZeppelinMonitoringConfiguration struct {

	// The verbosity of the CloudWatch Logs for an application.
	//
	// This member is required.
	LogLevel LogLevel
}

type ZeppelinMonitoringConfigurationDescription struct {

	// Describes the verbosity of the CloudWatch Logs for an application.
	LogLevel LogLevel
}

type ZeppelinMonitoringConfigurationUpdate struct {

	// Updates to the logging level for Apache Zeppelin within a Kinesis Data Analytics
	// Studio notebook.
	//
	// This member is required.
	LogLevelUpdate LogLevel
}