use std::error::Error;
use std::fmt;
use async_trait::async_trait;
use rusoto_core::credential::ProvideAwsCredentials;
use rusoto_core::region;
use rusoto_core::request::{BufferedHttpResponse, DispatchSignedRequest};
use rusoto_core::{Client, RusotoError};
use rusoto_core::proto;
use rusoto_core::signature::SignedRequest;
#[allow(unused_imports)]
use serde::{Deserialize, Serialize};
use serde_json;
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AddApplicationCloudWatchLoggingOptionRequest {
#[serde(rename = "ApplicationName")]
pub application_name: String,
#[serde(rename = "CloudWatchLoggingOption")]
pub cloud_watch_logging_option: CloudWatchLoggingOption,
#[serde(rename = "CurrentApplicationVersionId")]
pub current_application_version_id: i64,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AddApplicationCloudWatchLoggingOptionResponse {
#[serde(rename = "ApplicationARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_arn: Option<String>,
#[serde(rename = "ApplicationVersionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_version_id: Option<i64>,
#[serde(rename = "CloudWatchLoggingOptionDescriptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cloud_watch_logging_option_descriptions: Option<Vec<CloudWatchLoggingOptionDescription>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AddApplicationInputProcessingConfigurationRequest {
#[serde(rename = "ApplicationName")]
pub application_name: String,
#[serde(rename = "CurrentApplicationVersionId")]
pub current_application_version_id: i64,
#[serde(rename = "InputId")]
pub input_id: String,
#[serde(rename = "InputProcessingConfiguration")]
pub input_processing_configuration: InputProcessingConfiguration,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AddApplicationInputProcessingConfigurationResponse {
#[serde(rename = "ApplicationARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_arn: Option<String>,
#[serde(rename = "ApplicationVersionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_version_id: Option<i64>,
#[serde(rename = "InputId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub input_id: Option<String>,
#[serde(rename = "InputProcessingConfigurationDescription")]
#[serde(skip_serializing_if = "Option::is_none")]
pub input_processing_configuration_description: Option<InputProcessingConfigurationDescription>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AddApplicationInputRequest {
#[serde(rename = "ApplicationName")]
pub application_name: String,
#[serde(rename = "CurrentApplicationVersionId")]
pub current_application_version_id: i64,
#[serde(rename = "Input")]
pub input: Input,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AddApplicationInputResponse {
#[serde(rename = "ApplicationARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_arn: Option<String>,
#[serde(rename = "ApplicationVersionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_version_id: Option<i64>,
#[serde(rename = "InputDescriptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub input_descriptions: Option<Vec<InputDescription>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AddApplicationOutputRequest {
#[serde(rename = "ApplicationName")]
pub application_name: String,
#[serde(rename = "CurrentApplicationVersionId")]
pub current_application_version_id: i64,
#[serde(rename = "Output")]
pub output: Output,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AddApplicationOutputResponse {
#[serde(rename = "ApplicationARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_arn: Option<String>,
#[serde(rename = "ApplicationVersionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_version_id: Option<i64>,
#[serde(rename = "OutputDescriptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub output_descriptions: Option<Vec<OutputDescription>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AddApplicationReferenceDataSourceRequest {
#[serde(rename = "ApplicationName")]
pub application_name: String,
#[serde(rename = "CurrentApplicationVersionId")]
pub current_application_version_id: i64,
#[serde(rename = "ReferenceDataSource")]
pub reference_data_source: ReferenceDataSource,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AddApplicationReferenceDataSourceResponse {
#[serde(rename = "ApplicationARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_arn: Option<String>,
#[serde(rename = "ApplicationVersionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_version_id: Option<i64>,
#[serde(rename = "ReferenceDataSourceDescriptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub reference_data_source_descriptions: Option<Vec<ReferenceDataSourceDescription>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AddApplicationVpcConfigurationRequest {
#[serde(rename = "ApplicationName")]
pub application_name: String,
#[serde(rename = "CurrentApplicationVersionId")]
pub current_application_version_id: i64,
#[serde(rename = "VpcConfiguration")]
pub vpc_configuration: VpcConfiguration,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AddApplicationVpcConfigurationResponse {
#[serde(rename = "ApplicationARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_arn: Option<String>,
#[serde(rename = "ApplicationVersionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_version_id: Option<i64>,
#[serde(rename = "VpcConfigurationDescription")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpc_configuration_description: Option<VpcConfigurationDescription>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ApplicationCodeConfiguration {
#[serde(rename = "CodeContent")]
#[serde(skip_serializing_if = "Option::is_none")]
pub code_content: Option<CodeContent>,
#[serde(rename = "CodeContentType")]
pub code_content_type: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ApplicationCodeConfigurationDescription {
#[serde(rename = "CodeContentDescription")]
#[serde(skip_serializing_if = "Option::is_none")]
pub code_content_description: Option<CodeContentDescription>,
#[serde(rename = "CodeContentType")]
pub code_content_type: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ApplicationCodeConfigurationUpdate {
#[serde(rename = "CodeContentTypeUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub code_content_type_update: Option<String>,
#[serde(rename = "CodeContentUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub code_content_update: Option<CodeContentUpdate>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ApplicationConfiguration {
#[serde(rename = "ApplicationCodeConfiguration")]
pub application_code_configuration: ApplicationCodeConfiguration,
#[serde(rename = "ApplicationSnapshotConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_snapshot_configuration: Option<ApplicationSnapshotConfiguration>,
#[serde(rename = "EnvironmentProperties")]
#[serde(skip_serializing_if = "Option::is_none")]
pub environment_properties: Option<EnvironmentProperties>,
#[serde(rename = "FlinkApplicationConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub flink_application_configuration: Option<FlinkApplicationConfiguration>,
#[serde(rename = "SqlApplicationConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sql_application_configuration: Option<SqlApplicationConfiguration>,
#[serde(rename = "VpcConfigurations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpc_configurations: Option<Vec<VpcConfiguration>>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ApplicationConfigurationDescription {
#[serde(rename = "ApplicationCodeConfigurationDescription")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_code_configuration_description: Option<ApplicationCodeConfigurationDescription>,
#[serde(rename = "ApplicationSnapshotConfigurationDescription")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_snapshot_configuration_description:
Option<ApplicationSnapshotConfigurationDescription>,
#[serde(rename = "EnvironmentPropertyDescriptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub environment_property_descriptions: Option<EnvironmentPropertyDescriptions>,
#[serde(rename = "FlinkApplicationConfigurationDescription")]
#[serde(skip_serializing_if = "Option::is_none")]
pub flink_application_configuration_description:
Option<FlinkApplicationConfigurationDescription>,
#[serde(rename = "RunConfigurationDescription")]
#[serde(skip_serializing_if = "Option::is_none")]
pub run_configuration_description: Option<RunConfigurationDescription>,
#[serde(rename = "SqlApplicationConfigurationDescription")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sql_application_configuration_description: Option<SqlApplicationConfigurationDescription>,
#[serde(rename = "VpcConfigurationDescriptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpc_configuration_descriptions: Option<Vec<VpcConfigurationDescription>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ApplicationConfigurationUpdate {
#[serde(rename = "ApplicationCodeConfigurationUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_code_configuration_update: Option<ApplicationCodeConfigurationUpdate>,
#[serde(rename = "ApplicationSnapshotConfigurationUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_snapshot_configuration_update: Option<ApplicationSnapshotConfigurationUpdate>,
#[serde(rename = "EnvironmentPropertyUpdates")]
#[serde(skip_serializing_if = "Option::is_none")]
pub environment_property_updates: Option<EnvironmentPropertyUpdates>,
#[serde(rename = "FlinkApplicationConfigurationUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub flink_application_configuration_update: Option<FlinkApplicationConfigurationUpdate>,
#[serde(rename = "SqlApplicationConfigurationUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sql_application_configuration_update: Option<SqlApplicationConfigurationUpdate>,
#[serde(rename = "VpcConfigurationUpdates")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpc_configuration_updates: Option<Vec<VpcConfigurationUpdate>>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ApplicationDetail {
#[serde(rename = "ApplicationARN")]
pub application_arn: String,
#[serde(rename = "ApplicationConfigurationDescription")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_configuration_description: Option<ApplicationConfigurationDescription>,
#[serde(rename = "ApplicationDescription")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_description: Option<String>,
#[serde(rename = "ApplicationName")]
pub application_name: String,
#[serde(rename = "ApplicationStatus")]
pub application_status: String,
#[serde(rename = "ApplicationVersionId")]
pub application_version_id: i64,
#[serde(rename = "CloudWatchLoggingOptionDescriptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cloud_watch_logging_option_descriptions: Option<Vec<CloudWatchLoggingOptionDescription>>,
#[serde(rename = "CreateTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub create_timestamp: Option<f64>,
#[serde(rename = "LastUpdateTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_update_timestamp: Option<f64>,
#[serde(rename = "RuntimeEnvironment")]
pub runtime_environment: String,
#[serde(rename = "ServiceExecutionRole")]
#[serde(skip_serializing_if = "Option::is_none")]
pub service_execution_role: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ApplicationRestoreConfiguration {
#[serde(rename = "ApplicationRestoreType")]
pub application_restore_type: String,
#[serde(rename = "SnapshotName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub snapshot_name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ApplicationSnapshotConfiguration {
#[serde(rename = "SnapshotsEnabled")]
pub snapshots_enabled: bool,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ApplicationSnapshotConfigurationDescription {
#[serde(rename = "SnapshotsEnabled")]
pub snapshots_enabled: bool,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ApplicationSnapshotConfigurationUpdate {
#[serde(rename = "SnapshotsEnabledUpdate")]
pub snapshots_enabled_update: bool,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ApplicationSummary {
#[serde(rename = "ApplicationARN")]
pub application_arn: String,
#[serde(rename = "ApplicationName")]
pub application_name: String,
#[serde(rename = "ApplicationStatus")]
pub application_status: String,
#[serde(rename = "ApplicationVersionId")]
pub application_version_id: i64,
#[serde(rename = "RuntimeEnvironment")]
pub runtime_environment: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CSVMappingParameters {
#[serde(rename = "RecordColumnDelimiter")]
pub record_column_delimiter: String,
#[serde(rename = "RecordRowDelimiter")]
pub record_row_delimiter: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CheckpointConfiguration {
#[serde(rename = "CheckpointInterval")]
#[serde(skip_serializing_if = "Option::is_none")]
pub checkpoint_interval: Option<i64>,
#[serde(rename = "CheckpointingEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub checkpointing_enabled: Option<bool>,
#[serde(rename = "ConfigurationType")]
pub configuration_type: String,
#[serde(rename = "MinPauseBetweenCheckpoints")]
#[serde(skip_serializing_if = "Option::is_none")]
pub min_pause_between_checkpoints: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CheckpointConfigurationDescription {
#[serde(rename = "CheckpointInterval")]
#[serde(skip_serializing_if = "Option::is_none")]
pub checkpoint_interval: Option<i64>,
#[serde(rename = "CheckpointingEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub checkpointing_enabled: Option<bool>,
#[serde(rename = "ConfigurationType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub configuration_type: Option<String>,
#[serde(rename = "MinPauseBetweenCheckpoints")]
#[serde(skip_serializing_if = "Option::is_none")]
pub min_pause_between_checkpoints: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CheckpointConfigurationUpdate {
#[serde(rename = "CheckpointIntervalUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub checkpoint_interval_update: Option<i64>,
#[serde(rename = "CheckpointingEnabledUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub checkpointing_enabled_update: Option<bool>,
#[serde(rename = "ConfigurationTypeUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub configuration_type_update: Option<String>,
#[serde(rename = "MinPauseBetweenCheckpointsUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub min_pause_between_checkpoints_update: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CloudWatchLoggingOption {
#[serde(rename = "LogStreamARN")]
pub log_stream_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CloudWatchLoggingOptionDescription {
#[serde(rename = "CloudWatchLoggingOptionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cloud_watch_logging_option_id: Option<String>,
#[serde(rename = "LogStreamARN")]
pub log_stream_arn: String,
#[serde(rename = "RoleARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub role_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CloudWatchLoggingOptionUpdate {
#[serde(rename = "CloudWatchLoggingOptionId")]
pub cloud_watch_logging_option_id: String,
#[serde(rename = "LogStreamARNUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub log_stream_arn_update: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CodeContent {
#[serde(rename = "S3ContentLocation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub s3_content_location: Option<S3ContentLocation>,
#[serde(rename = "TextContent")]
#[serde(skip_serializing_if = "Option::is_none")]
pub text_content: Option<String>,
#[serde(rename = "ZipFileContent")]
#[serde(
deserialize_with = "::rusoto_core::serialization::SerdeBlob::deserialize_blob",
serialize_with = "::rusoto_core::serialization::SerdeBlob::serialize_blob",
default
)]
#[serde(skip_serializing_if = "Option::is_none")]
pub zip_file_content: Option<bytes::Bytes>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CodeContentDescription {
#[serde(rename = "CodeMD5")]
#[serde(skip_serializing_if = "Option::is_none")]
pub code_md5: Option<String>,
#[serde(rename = "CodeSize")]
#[serde(skip_serializing_if = "Option::is_none")]
pub code_size: Option<i64>,
#[serde(rename = "S3ApplicationCodeLocationDescription")]
#[serde(skip_serializing_if = "Option::is_none")]
pub s3_application_code_location_description: Option<S3ApplicationCodeLocationDescription>,
#[serde(rename = "TextContent")]
#[serde(skip_serializing_if = "Option::is_none")]
pub text_content: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CodeContentUpdate {
#[serde(rename = "S3ContentLocationUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub s3_content_location_update: Option<S3ContentLocationUpdate>,
#[serde(rename = "TextContentUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub text_content_update: Option<String>,
#[serde(rename = "ZipFileContentUpdate")]
#[serde(
deserialize_with = "::rusoto_core::serialization::SerdeBlob::deserialize_blob",
serialize_with = "::rusoto_core::serialization::SerdeBlob::serialize_blob",
default
)]
#[serde(skip_serializing_if = "Option::is_none")]
pub zip_file_content_update: Option<bytes::Bytes>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateApplicationRequest {
#[serde(rename = "ApplicationConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_configuration: Option<ApplicationConfiguration>,
#[serde(rename = "ApplicationDescription")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_description: Option<String>,
#[serde(rename = "ApplicationName")]
pub application_name: String,
#[serde(rename = "CloudWatchLoggingOptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cloud_watch_logging_options: Option<Vec<CloudWatchLoggingOption>>,
#[serde(rename = "RuntimeEnvironment")]
pub runtime_environment: String,
#[serde(rename = "ServiceExecutionRole")]
pub service_execution_role: String,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateApplicationResponse {
#[serde(rename = "ApplicationDetail")]
pub application_detail: ApplicationDetail,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateApplicationSnapshotRequest {
#[serde(rename = "ApplicationName")]
pub application_name: String,
#[serde(rename = "SnapshotName")]
pub snapshot_name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateApplicationSnapshotResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteApplicationCloudWatchLoggingOptionRequest {
#[serde(rename = "ApplicationName")]
pub application_name: String,
#[serde(rename = "CloudWatchLoggingOptionId")]
pub cloud_watch_logging_option_id: String,
#[serde(rename = "CurrentApplicationVersionId")]
pub current_application_version_id: i64,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteApplicationCloudWatchLoggingOptionResponse {
#[serde(rename = "ApplicationARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_arn: Option<String>,
#[serde(rename = "ApplicationVersionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_version_id: Option<i64>,
#[serde(rename = "CloudWatchLoggingOptionDescriptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cloud_watch_logging_option_descriptions: Option<Vec<CloudWatchLoggingOptionDescription>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteApplicationInputProcessingConfigurationRequest {
#[serde(rename = "ApplicationName")]
pub application_name: String,
#[serde(rename = "CurrentApplicationVersionId")]
pub current_application_version_id: i64,
#[serde(rename = "InputId")]
pub input_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteApplicationInputProcessingConfigurationResponse {
#[serde(rename = "ApplicationARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_arn: Option<String>,
#[serde(rename = "ApplicationVersionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_version_id: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteApplicationOutputRequest {
#[serde(rename = "ApplicationName")]
pub application_name: String,
#[serde(rename = "CurrentApplicationVersionId")]
pub current_application_version_id: i64,
#[serde(rename = "OutputId")]
pub output_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteApplicationOutputResponse {
#[serde(rename = "ApplicationARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_arn: Option<String>,
#[serde(rename = "ApplicationVersionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_version_id: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteApplicationReferenceDataSourceRequest {
#[serde(rename = "ApplicationName")]
pub application_name: String,
#[serde(rename = "CurrentApplicationVersionId")]
pub current_application_version_id: i64,
#[serde(rename = "ReferenceId")]
pub reference_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteApplicationReferenceDataSourceResponse {
#[serde(rename = "ApplicationARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_arn: Option<String>,
#[serde(rename = "ApplicationVersionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_version_id: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteApplicationRequest {
#[serde(rename = "ApplicationName")]
pub application_name: String,
#[serde(rename = "CreateTimestamp")]
pub create_timestamp: f64,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteApplicationResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteApplicationSnapshotRequest {
#[serde(rename = "ApplicationName")]
pub application_name: String,
#[serde(rename = "SnapshotCreationTimestamp")]
pub snapshot_creation_timestamp: f64,
#[serde(rename = "SnapshotName")]
pub snapshot_name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteApplicationSnapshotResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteApplicationVpcConfigurationRequest {
#[serde(rename = "ApplicationName")]
pub application_name: String,
#[serde(rename = "CurrentApplicationVersionId")]
pub current_application_version_id: i64,
#[serde(rename = "VpcConfigurationId")]
pub vpc_configuration_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteApplicationVpcConfigurationResponse {
#[serde(rename = "ApplicationARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_arn: Option<String>,
#[serde(rename = "ApplicationVersionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_version_id: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeApplicationRequest {
#[serde(rename = "ApplicationName")]
pub application_name: String,
#[serde(rename = "IncludeAdditionalDetails")]
#[serde(skip_serializing_if = "Option::is_none")]
pub include_additional_details: Option<bool>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeApplicationResponse {
#[serde(rename = "ApplicationDetail")]
pub application_detail: ApplicationDetail,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeApplicationSnapshotRequest {
#[serde(rename = "ApplicationName")]
pub application_name: String,
#[serde(rename = "SnapshotName")]
pub snapshot_name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeApplicationSnapshotResponse {
#[serde(rename = "SnapshotDetails")]
pub snapshot_details: SnapshotDetails,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct DestinationSchema {
#[serde(rename = "RecordFormatType")]
pub record_format_type: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DiscoverInputSchemaRequest {
#[serde(rename = "InputProcessingConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub input_processing_configuration: Option<InputProcessingConfiguration>,
#[serde(rename = "InputStartingPositionConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub input_starting_position_configuration: Option<InputStartingPositionConfiguration>,
#[serde(rename = "ResourceARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_arn: Option<String>,
#[serde(rename = "S3Configuration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub s3_configuration: Option<S3Configuration>,
#[serde(rename = "ServiceExecutionRole")]
pub service_execution_role: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DiscoverInputSchemaResponse {
#[serde(rename = "InputSchema")]
#[serde(skip_serializing_if = "Option::is_none")]
pub input_schema: Option<SourceSchema>,
#[serde(rename = "ParsedInputRecords")]
#[serde(skip_serializing_if = "Option::is_none")]
pub parsed_input_records: Option<Vec<Vec<String>>>,
#[serde(rename = "ProcessedInputRecords")]
#[serde(skip_serializing_if = "Option::is_none")]
pub processed_input_records: Option<Vec<String>>,
#[serde(rename = "RawInputRecords")]
#[serde(skip_serializing_if = "Option::is_none")]
pub raw_input_records: Option<Vec<String>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct EnvironmentProperties {
#[serde(rename = "PropertyGroups")]
pub property_groups: Vec<PropertyGroup>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct EnvironmentPropertyDescriptions {
#[serde(rename = "PropertyGroupDescriptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub property_group_descriptions: Option<Vec<PropertyGroup>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct EnvironmentPropertyUpdates {
#[serde(rename = "PropertyGroups")]
pub property_groups: Vec<PropertyGroup>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct FlinkApplicationConfiguration {
#[serde(rename = "CheckpointConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub checkpoint_configuration: Option<CheckpointConfiguration>,
#[serde(rename = "MonitoringConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub monitoring_configuration: Option<MonitoringConfiguration>,
#[serde(rename = "ParallelismConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub parallelism_configuration: Option<ParallelismConfiguration>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct FlinkApplicationConfigurationDescription {
#[serde(rename = "CheckpointConfigurationDescription")]
#[serde(skip_serializing_if = "Option::is_none")]
pub checkpoint_configuration_description: Option<CheckpointConfigurationDescription>,
#[serde(rename = "JobPlanDescription")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_plan_description: Option<String>,
#[serde(rename = "MonitoringConfigurationDescription")]
#[serde(skip_serializing_if = "Option::is_none")]
pub monitoring_configuration_description: Option<MonitoringConfigurationDescription>,
#[serde(rename = "ParallelismConfigurationDescription")]
#[serde(skip_serializing_if = "Option::is_none")]
pub parallelism_configuration_description: Option<ParallelismConfigurationDescription>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct FlinkApplicationConfigurationUpdate {
#[serde(rename = "CheckpointConfigurationUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub checkpoint_configuration_update: Option<CheckpointConfigurationUpdate>,
#[serde(rename = "MonitoringConfigurationUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub monitoring_configuration_update: Option<MonitoringConfigurationUpdate>,
#[serde(rename = "ParallelismConfigurationUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub parallelism_configuration_update: Option<ParallelismConfigurationUpdate>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct FlinkRunConfiguration {
#[serde(rename = "AllowNonRestoredState")]
#[serde(skip_serializing_if = "Option::is_none")]
pub allow_non_restored_state: Option<bool>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct Input {
#[serde(rename = "InputParallelism")]
#[serde(skip_serializing_if = "Option::is_none")]
pub input_parallelism: Option<InputParallelism>,
#[serde(rename = "InputProcessingConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub input_processing_configuration: Option<InputProcessingConfiguration>,
#[serde(rename = "InputSchema")]
pub input_schema: SourceSchema,
#[serde(rename = "KinesisFirehoseInput")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kinesis_firehose_input: Option<KinesisFirehoseInput>,
#[serde(rename = "KinesisStreamsInput")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kinesis_streams_input: Option<KinesisStreamsInput>,
#[serde(rename = "NamePrefix")]
pub name_prefix: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct InputDescription {
#[serde(rename = "InAppStreamNames")]
#[serde(skip_serializing_if = "Option::is_none")]
pub in_app_stream_names: Option<Vec<String>>,
#[serde(rename = "InputId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub input_id: Option<String>,
#[serde(rename = "InputParallelism")]
#[serde(skip_serializing_if = "Option::is_none")]
pub input_parallelism: Option<InputParallelism>,
#[serde(rename = "InputProcessingConfigurationDescription")]
#[serde(skip_serializing_if = "Option::is_none")]
pub input_processing_configuration_description: Option<InputProcessingConfigurationDescription>,
#[serde(rename = "InputSchema")]
#[serde(skip_serializing_if = "Option::is_none")]
pub input_schema: Option<SourceSchema>,
#[serde(rename = "InputStartingPositionConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub input_starting_position_configuration: Option<InputStartingPositionConfiguration>,
#[serde(rename = "KinesisFirehoseInputDescription")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kinesis_firehose_input_description: Option<KinesisFirehoseInputDescription>,
#[serde(rename = "KinesisStreamsInputDescription")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kinesis_streams_input_description: Option<KinesisStreamsInputDescription>,
#[serde(rename = "NamePrefix")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name_prefix: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct InputLambdaProcessor {
#[serde(rename = "ResourceARN")]
pub resource_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct InputLambdaProcessorDescription {
#[serde(rename = "ResourceARN")]
pub resource_arn: String,
#[serde(rename = "RoleARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub role_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct InputLambdaProcessorUpdate {
#[serde(rename = "ResourceARNUpdate")]
pub resource_arn_update: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct InputParallelism {
#[serde(rename = "Count")]
#[serde(skip_serializing_if = "Option::is_none")]
pub count: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct InputParallelismUpdate {
#[serde(rename = "CountUpdate")]
pub count_update: i64,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct InputProcessingConfiguration {
#[serde(rename = "InputLambdaProcessor")]
pub input_lambda_processor: InputLambdaProcessor,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct InputProcessingConfigurationDescription {
#[serde(rename = "InputLambdaProcessorDescription")]
#[serde(skip_serializing_if = "Option::is_none")]
pub input_lambda_processor_description: Option<InputLambdaProcessorDescription>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct InputProcessingConfigurationUpdate {
#[serde(rename = "InputLambdaProcessorUpdate")]
pub input_lambda_processor_update: InputLambdaProcessorUpdate,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct InputSchemaUpdate {
#[serde(rename = "RecordColumnUpdates")]
#[serde(skip_serializing_if = "Option::is_none")]
pub record_column_updates: Option<Vec<RecordColumn>>,
#[serde(rename = "RecordEncodingUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub record_encoding_update: Option<String>,
#[serde(rename = "RecordFormatUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub record_format_update: Option<RecordFormat>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct InputStartingPositionConfiguration {
#[serde(rename = "InputStartingPosition")]
#[serde(skip_serializing_if = "Option::is_none")]
pub input_starting_position: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct InputUpdate {
#[serde(rename = "InputId")]
pub input_id: String,
#[serde(rename = "InputParallelismUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub input_parallelism_update: Option<InputParallelismUpdate>,
#[serde(rename = "InputProcessingConfigurationUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub input_processing_configuration_update: Option<InputProcessingConfigurationUpdate>,
#[serde(rename = "InputSchemaUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub input_schema_update: Option<InputSchemaUpdate>,
#[serde(rename = "KinesisFirehoseInputUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kinesis_firehose_input_update: Option<KinesisFirehoseInputUpdate>,
#[serde(rename = "KinesisStreamsInputUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kinesis_streams_input_update: Option<KinesisStreamsInputUpdate>,
#[serde(rename = "NamePrefixUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name_prefix_update: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct JSONMappingParameters {
#[serde(rename = "RecordRowPath")]
pub record_row_path: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct KinesisFirehoseInput {
#[serde(rename = "ResourceARN")]
pub resource_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct KinesisFirehoseInputDescription {
#[serde(rename = "ResourceARN")]
pub resource_arn: String,
#[serde(rename = "RoleARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub role_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct KinesisFirehoseInputUpdate {
#[serde(rename = "ResourceARNUpdate")]
pub resource_arn_update: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct KinesisFirehoseOutput {
#[serde(rename = "ResourceARN")]
pub resource_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct KinesisFirehoseOutputDescription {
#[serde(rename = "ResourceARN")]
pub resource_arn: String,
#[serde(rename = "RoleARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub role_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct KinesisFirehoseOutputUpdate {
#[serde(rename = "ResourceARNUpdate")]
pub resource_arn_update: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct KinesisStreamsInput {
#[serde(rename = "ResourceARN")]
pub resource_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct KinesisStreamsInputDescription {
#[serde(rename = "ResourceARN")]
pub resource_arn: String,
#[serde(rename = "RoleARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub role_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct KinesisStreamsInputUpdate {
#[serde(rename = "ResourceARNUpdate")]
pub resource_arn_update: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct KinesisStreamsOutput {
#[serde(rename = "ResourceARN")]
pub resource_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct KinesisStreamsOutputDescription {
#[serde(rename = "ResourceARN")]
pub resource_arn: String,
#[serde(rename = "RoleARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub role_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct KinesisStreamsOutputUpdate {
#[serde(rename = "ResourceARNUpdate")]
pub resource_arn_update: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct LambdaOutput {
#[serde(rename = "ResourceARN")]
pub resource_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct LambdaOutputDescription {
#[serde(rename = "ResourceARN")]
pub resource_arn: String,
#[serde(rename = "RoleARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub role_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct LambdaOutputUpdate {
#[serde(rename = "ResourceARNUpdate")]
pub resource_arn_update: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListApplicationSnapshotsRequest {
#[serde(rename = "ApplicationName")]
pub application_name: String,
#[serde(rename = "Limit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub limit: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListApplicationSnapshotsResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "SnapshotSummaries")]
#[serde(skip_serializing_if = "Option::is_none")]
pub snapshot_summaries: Option<Vec<SnapshotDetails>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListApplicationsRequest {
#[serde(rename = "Limit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub limit: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListApplicationsResponse {
#[serde(rename = "ApplicationSummaries")]
pub application_summaries: Vec<ApplicationSummary>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListTagsForResourceRequest {
#[serde(rename = "ResourceARN")]
pub resource_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListTagsForResourceResponse {
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct MappingParameters {
#[serde(rename = "CSVMappingParameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub csv_mapping_parameters: Option<CSVMappingParameters>,
#[serde(rename = "JSONMappingParameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub json_mapping_parameters: Option<JSONMappingParameters>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct MonitoringConfiguration {
#[serde(rename = "ConfigurationType")]
pub configuration_type: String,
#[serde(rename = "LogLevel")]
#[serde(skip_serializing_if = "Option::is_none")]
pub log_level: Option<String>,
#[serde(rename = "MetricsLevel")]
#[serde(skip_serializing_if = "Option::is_none")]
pub metrics_level: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct MonitoringConfigurationDescription {
#[serde(rename = "ConfigurationType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub configuration_type: Option<String>,
#[serde(rename = "LogLevel")]
#[serde(skip_serializing_if = "Option::is_none")]
pub log_level: Option<String>,
#[serde(rename = "MetricsLevel")]
#[serde(skip_serializing_if = "Option::is_none")]
pub metrics_level: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct MonitoringConfigurationUpdate {
#[serde(rename = "ConfigurationTypeUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub configuration_type_update: Option<String>,
#[serde(rename = "LogLevelUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub log_level_update: Option<String>,
#[serde(rename = "MetricsLevelUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub metrics_level_update: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct Output {
#[serde(rename = "DestinationSchema")]
pub destination_schema: DestinationSchema,
#[serde(rename = "KinesisFirehoseOutput")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kinesis_firehose_output: Option<KinesisFirehoseOutput>,
#[serde(rename = "KinesisStreamsOutput")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kinesis_streams_output: Option<KinesisStreamsOutput>,
#[serde(rename = "LambdaOutput")]
#[serde(skip_serializing_if = "Option::is_none")]
pub lambda_output: Option<LambdaOutput>,
#[serde(rename = "Name")]
pub name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct OutputDescription {
#[serde(rename = "DestinationSchema")]
#[serde(skip_serializing_if = "Option::is_none")]
pub destination_schema: Option<DestinationSchema>,
#[serde(rename = "KinesisFirehoseOutputDescription")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kinesis_firehose_output_description: Option<KinesisFirehoseOutputDescription>,
#[serde(rename = "KinesisStreamsOutputDescription")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kinesis_streams_output_description: Option<KinesisStreamsOutputDescription>,
#[serde(rename = "LambdaOutputDescription")]
#[serde(skip_serializing_if = "Option::is_none")]
pub lambda_output_description: Option<LambdaOutputDescription>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "OutputId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub output_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct OutputUpdate {
#[serde(rename = "DestinationSchemaUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub destination_schema_update: Option<DestinationSchema>,
#[serde(rename = "KinesisFirehoseOutputUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kinesis_firehose_output_update: Option<KinesisFirehoseOutputUpdate>,
#[serde(rename = "KinesisStreamsOutputUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kinesis_streams_output_update: Option<KinesisStreamsOutputUpdate>,
#[serde(rename = "LambdaOutputUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub lambda_output_update: Option<LambdaOutputUpdate>,
#[serde(rename = "NameUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name_update: Option<String>,
#[serde(rename = "OutputId")]
pub output_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ParallelismConfiguration {
#[serde(rename = "AutoScalingEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_scaling_enabled: Option<bool>,
#[serde(rename = "ConfigurationType")]
pub configuration_type: String,
#[serde(rename = "Parallelism")]
#[serde(skip_serializing_if = "Option::is_none")]
pub parallelism: Option<i64>,
#[serde(rename = "ParallelismPerKPU")]
#[serde(skip_serializing_if = "Option::is_none")]
pub parallelism_per_kpu: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ParallelismConfigurationDescription {
#[serde(rename = "AutoScalingEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_scaling_enabled: Option<bool>,
#[serde(rename = "ConfigurationType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub configuration_type: Option<String>,
#[serde(rename = "CurrentParallelism")]
#[serde(skip_serializing_if = "Option::is_none")]
pub current_parallelism: Option<i64>,
#[serde(rename = "Parallelism")]
#[serde(skip_serializing_if = "Option::is_none")]
pub parallelism: Option<i64>,
#[serde(rename = "ParallelismPerKPU")]
#[serde(skip_serializing_if = "Option::is_none")]
pub parallelism_per_kpu: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ParallelismConfigurationUpdate {
#[serde(rename = "AutoScalingEnabledUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_scaling_enabled_update: Option<bool>,
#[serde(rename = "ConfigurationTypeUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub configuration_type_update: Option<String>,
#[serde(rename = "ParallelismPerKPUUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub parallelism_per_kpu_update: Option<i64>,
#[serde(rename = "ParallelismUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub parallelism_update: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PropertyGroup {
#[serde(rename = "PropertyGroupId")]
pub property_group_id: String,
#[serde(rename = "PropertyMap")]
pub property_map: ::std::collections::HashMap<String, String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct RecordColumn {
#[serde(rename = "Mapping")]
#[serde(skip_serializing_if = "Option::is_none")]
pub mapping: Option<String>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "SqlType")]
pub sql_type: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct RecordFormat {
#[serde(rename = "MappingParameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub mapping_parameters: Option<MappingParameters>,
#[serde(rename = "RecordFormatType")]
pub record_format_type: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ReferenceDataSource {
#[serde(rename = "ReferenceSchema")]
pub reference_schema: SourceSchema,
#[serde(rename = "S3ReferenceDataSource")]
#[serde(skip_serializing_if = "Option::is_none")]
pub s3_reference_data_source: Option<S3ReferenceDataSource>,
#[serde(rename = "TableName")]
pub table_name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ReferenceDataSourceDescription {
#[serde(rename = "ReferenceId")]
pub reference_id: String,
#[serde(rename = "ReferenceSchema")]
#[serde(skip_serializing_if = "Option::is_none")]
pub reference_schema: Option<SourceSchema>,
#[serde(rename = "S3ReferenceDataSourceDescription")]
pub s3_reference_data_source_description: S3ReferenceDataSourceDescription,
#[serde(rename = "TableName")]
pub table_name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ReferenceDataSourceUpdate {
#[serde(rename = "ReferenceId")]
pub reference_id: String,
#[serde(rename = "ReferenceSchemaUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub reference_schema_update: Option<SourceSchema>,
#[serde(rename = "S3ReferenceDataSourceUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub s3_reference_data_source_update: Option<S3ReferenceDataSourceUpdate>,
#[serde(rename = "TableNameUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub table_name_update: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct RunConfiguration {
#[serde(rename = "ApplicationRestoreConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_restore_configuration: Option<ApplicationRestoreConfiguration>,
#[serde(rename = "FlinkRunConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub flink_run_configuration: Option<FlinkRunConfiguration>,
#[serde(rename = "SqlRunConfigurations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sql_run_configurations: Option<Vec<SqlRunConfiguration>>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RunConfigurationDescription {
#[serde(rename = "ApplicationRestoreConfigurationDescription")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_restore_configuration_description: Option<ApplicationRestoreConfiguration>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct RunConfigurationUpdate {
#[serde(rename = "ApplicationRestoreConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_restore_configuration: Option<ApplicationRestoreConfiguration>,
#[serde(rename = "FlinkRunConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub flink_run_configuration: Option<FlinkRunConfiguration>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct S3ApplicationCodeLocationDescription {
#[serde(rename = "BucketARN")]
pub bucket_arn: String,
#[serde(rename = "FileKey")]
pub file_key: String,
#[serde(rename = "ObjectVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub object_version: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct S3Configuration {
#[serde(rename = "BucketARN")]
pub bucket_arn: String,
#[serde(rename = "FileKey")]
pub file_key: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct S3ContentLocation {
#[serde(rename = "BucketARN")]
pub bucket_arn: String,
#[serde(rename = "FileKey")]
pub file_key: String,
#[serde(rename = "ObjectVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub object_version: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct S3ContentLocationUpdate {
#[serde(rename = "BucketARNUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bucket_arn_update: Option<String>,
#[serde(rename = "FileKeyUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub file_key_update: Option<String>,
#[serde(rename = "ObjectVersionUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub object_version_update: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct S3ReferenceDataSource {
#[serde(rename = "BucketARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bucket_arn: Option<String>,
#[serde(rename = "FileKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub file_key: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct S3ReferenceDataSourceDescription {
#[serde(rename = "BucketARN")]
pub bucket_arn: String,
#[serde(rename = "FileKey")]
pub file_key: String,
#[serde(rename = "ReferenceRoleARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub reference_role_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct S3ReferenceDataSourceUpdate {
#[serde(rename = "BucketARNUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bucket_arn_update: Option<String>,
#[serde(rename = "FileKeyUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub file_key_update: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct SnapshotDetails {
#[serde(rename = "ApplicationVersionId")]
pub application_version_id: i64,
#[serde(rename = "SnapshotCreationTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub snapshot_creation_timestamp: Option<f64>,
#[serde(rename = "SnapshotName")]
pub snapshot_name: String,
#[serde(rename = "SnapshotStatus")]
pub snapshot_status: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SourceSchema {
#[serde(rename = "RecordColumns")]
pub record_columns: Vec<RecordColumn>,
#[serde(rename = "RecordEncoding")]
#[serde(skip_serializing_if = "Option::is_none")]
pub record_encoding: Option<String>,
#[serde(rename = "RecordFormat")]
pub record_format: RecordFormat,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct SqlApplicationConfiguration {
#[serde(rename = "Inputs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub inputs: Option<Vec<Input>>,
#[serde(rename = "Outputs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub outputs: Option<Vec<Output>>,
#[serde(rename = "ReferenceDataSources")]
#[serde(skip_serializing_if = "Option::is_none")]
pub reference_data_sources: Option<Vec<ReferenceDataSource>>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct SqlApplicationConfigurationDescription {
#[serde(rename = "InputDescriptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub input_descriptions: Option<Vec<InputDescription>>,
#[serde(rename = "OutputDescriptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub output_descriptions: Option<Vec<OutputDescription>>,
#[serde(rename = "ReferenceDataSourceDescriptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub reference_data_source_descriptions: Option<Vec<ReferenceDataSourceDescription>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct SqlApplicationConfigurationUpdate {
#[serde(rename = "InputUpdates")]
#[serde(skip_serializing_if = "Option::is_none")]
pub input_updates: Option<Vec<InputUpdate>>,
#[serde(rename = "OutputUpdates")]
#[serde(skip_serializing_if = "Option::is_none")]
pub output_updates: Option<Vec<OutputUpdate>>,
#[serde(rename = "ReferenceDataSourceUpdates")]
#[serde(skip_serializing_if = "Option::is_none")]
pub reference_data_source_updates: Option<Vec<ReferenceDataSourceUpdate>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct SqlRunConfiguration {
#[serde(rename = "InputId")]
pub input_id: String,
#[serde(rename = "InputStartingPositionConfiguration")]
pub input_starting_position_configuration: InputStartingPositionConfiguration,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StartApplicationRequest {
#[serde(rename = "ApplicationName")]
pub application_name: String,
#[serde(rename = "RunConfiguration")]
pub run_configuration: RunConfiguration,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct StartApplicationResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StopApplicationRequest {
#[serde(rename = "ApplicationName")]
pub application_name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct StopApplicationResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Tag {
#[serde(rename = "Key")]
pub key: String,
#[serde(rename = "Value")]
#[serde(skip_serializing_if = "Option::is_none")]
pub value: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct TagResourceRequest {
#[serde(rename = "ResourceARN")]
pub resource_arn: String,
#[serde(rename = "Tags")]
pub tags: Vec<Tag>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct TagResourceResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UntagResourceRequest {
#[serde(rename = "ResourceARN")]
pub resource_arn: String,
#[serde(rename = "TagKeys")]
pub tag_keys: Vec<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UntagResourceResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateApplicationRequest {
#[serde(rename = "ApplicationConfigurationUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_configuration_update: Option<ApplicationConfigurationUpdate>,
#[serde(rename = "ApplicationName")]
pub application_name: String,
#[serde(rename = "CloudWatchLoggingOptionUpdates")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cloud_watch_logging_option_updates: Option<Vec<CloudWatchLoggingOptionUpdate>>,
#[serde(rename = "CurrentApplicationVersionId")]
pub current_application_version_id: i64,
#[serde(rename = "RunConfigurationUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub run_configuration_update: Option<RunConfigurationUpdate>,
#[serde(rename = "ServiceExecutionRoleUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub service_execution_role_update: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateApplicationResponse {
#[serde(rename = "ApplicationDetail")]
pub application_detail: ApplicationDetail,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct VpcConfiguration {
#[serde(rename = "SecurityGroupIds")]
pub security_group_ids: Vec<String>,
#[serde(rename = "SubnetIds")]
pub subnet_ids: Vec<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct VpcConfigurationDescription {
#[serde(rename = "SecurityGroupIds")]
pub security_group_ids: Vec<String>,
#[serde(rename = "SubnetIds")]
pub subnet_ids: Vec<String>,
#[serde(rename = "VpcConfigurationId")]
pub vpc_configuration_id: String,
#[serde(rename = "VpcId")]
pub vpc_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct VpcConfigurationUpdate {
#[serde(rename = "SecurityGroupIdUpdates")]
#[serde(skip_serializing_if = "Option::is_none")]
pub security_group_id_updates: Option<Vec<String>>,
#[serde(rename = "SubnetIdUpdates")]
#[serde(skip_serializing_if = "Option::is_none")]
pub subnet_id_updates: Option<Vec<String>>,
#[serde(rename = "VpcConfigurationId")]
pub vpc_configuration_id: String,
}
#[derive(Debug, PartialEq)]
pub enum AddApplicationCloudWatchLoggingOptionError {
ConcurrentModification(String),
InvalidApplicationConfiguration(String),
InvalidArgument(String),
InvalidRequest(String),
ResourceInUse(String),
ResourceNotFound(String),
}
impl AddApplicationCloudWatchLoggingOptionError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<AddApplicationCloudWatchLoggingOptionError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ConcurrentModificationException" => {
return RusotoError::Service(
AddApplicationCloudWatchLoggingOptionError::ConcurrentModification(err.msg),
)
}
"InvalidApplicationConfigurationException" => {
return RusotoError::Service(
AddApplicationCloudWatchLoggingOptionError::InvalidApplicationConfiguration(
err.msg,
),
)
}
"InvalidArgumentException" => {
return RusotoError::Service(
AddApplicationCloudWatchLoggingOptionError::InvalidArgument(err.msg),
)
}
"InvalidRequestException" => {
return RusotoError::Service(
AddApplicationCloudWatchLoggingOptionError::InvalidRequest(err.msg),
)
}
"ResourceInUseException" => {
return RusotoError::Service(
AddApplicationCloudWatchLoggingOptionError::ResourceInUse(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
AddApplicationCloudWatchLoggingOptionError::ResourceNotFound(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AddApplicationCloudWatchLoggingOptionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AddApplicationCloudWatchLoggingOptionError::ConcurrentModification(ref cause) => {
write!(f, "{}", cause)
}
AddApplicationCloudWatchLoggingOptionError::InvalidApplicationConfiguration(
ref cause,
) => write!(f, "{}", cause),
AddApplicationCloudWatchLoggingOptionError::InvalidArgument(ref cause) => {
write!(f, "{}", cause)
}
AddApplicationCloudWatchLoggingOptionError::InvalidRequest(ref cause) => {
write!(f, "{}", cause)
}
AddApplicationCloudWatchLoggingOptionError::ResourceInUse(ref cause) => {
write!(f, "{}", cause)
}
AddApplicationCloudWatchLoggingOptionError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for AddApplicationCloudWatchLoggingOptionError {}
#[derive(Debug, PartialEq)]
pub enum AddApplicationInputError {
CodeValidation(String),
ConcurrentModification(String),
InvalidArgument(String),
InvalidRequest(String),
ResourceInUse(String),
ResourceNotFound(String),
}
impl AddApplicationInputError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AddApplicationInputError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"CodeValidationException" => {
return RusotoError::Service(AddApplicationInputError::CodeValidation(err.msg))
}
"ConcurrentModificationException" => {
return RusotoError::Service(AddApplicationInputError::ConcurrentModification(
err.msg,
))
}
"InvalidArgumentException" => {
return RusotoError::Service(AddApplicationInputError::InvalidArgument(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(AddApplicationInputError::InvalidRequest(err.msg))
}
"ResourceInUseException" => {
return RusotoError::Service(AddApplicationInputError::ResourceInUse(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(AddApplicationInputError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AddApplicationInputError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AddApplicationInputError::CodeValidation(ref cause) => write!(f, "{}", cause),
AddApplicationInputError::ConcurrentModification(ref cause) => write!(f, "{}", cause),
AddApplicationInputError::InvalidArgument(ref cause) => write!(f, "{}", cause),
AddApplicationInputError::InvalidRequest(ref cause) => write!(f, "{}", cause),
AddApplicationInputError::ResourceInUse(ref cause) => write!(f, "{}", cause),
AddApplicationInputError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for AddApplicationInputError {}
#[derive(Debug, PartialEq)]
pub enum AddApplicationInputProcessingConfigurationError {
ConcurrentModification(String),
InvalidArgument(String),
InvalidRequest(String),
ResourceInUse(String),
ResourceNotFound(String),
}
impl AddApplicationInputProcessingConfigurationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<AddApplicationInputProcessingConfigurationError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ConcurrentModificationException" => {
return RusotoError::Service(
AddApplicationInputProcessingConfigurationError::ConcurrentModification(
err.msg,
),
)
}
"InvalidArgumentException" => {
return RusotoError::Service(
AddApplicationInputProcessingConfigurationError::InvalidArgument(err.msg),
)
}
"InvalidRequestException" => {
return RusotoError::Service(
AddApplicationInputProcessingConfigurationError::InvalidRequest(err.msg),
)
}
"ResourceInUseException" => {
return RusotoError::Service(
AddApplicationInputProcessingConfigurationError::ResourceInUse(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
AddApplicationInputProcessingConfigurationError::ResourceNotFound(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AddApplicationInputProcessingConfigurationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AddApplicationInputProcessingConfigurationError::ConcurrentModification(ref cause) => {
write!(f, "{}", cause)
}
AddApplicationInputProcessingConfigurationError::InvalidArgument(ref cause) => {
write!(f, "{}", cause)
}
AddApplicationInputProcessingConfigurationError::InvalidRequest(ref cause) => {
write!(f, "{}", cause)
}
AddApplicationInputProcessingConfigurationError::ResourceInUse(ref cause) => {
write!(f, "{}", cause)
}
AddApplicationInputProcessingConfigurationError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for AddApplicationInputProcessingConfigurationError {}
#[derive(Debug, PartialEq)]
pub enum AddApplicationOutputError {
ConcurrentModification(String),
InvalidArgument(String),
InvalidRequest(String),
ResourceInUse(String),
ResourceNotFound(String),
}
impl AddApplicationOutputError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AddApplicationOutputError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ConcurrentModificationException" => {
return RusotoError::Service(AddApplicationOutputError::ConcurrentModification(
err.msg,
))
}
"InvalidArgumentException" => {
return RusotoError::Service(AddApplicationOutputError::InvalidArgument(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(AddApplicationOutputError::InvalidRequest(err.msg))
}
"ResourceInUseException" => {
return RusotoError::Service(AddApplicationOutputError::ResourceInUse(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(AddApplicationOutputError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AddApplicationOutputError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AddApplicationOutputError::ConcurrentModification(ref cause) => write!(f, "{}", cause),
AddApplicationOutputError::InvalidArgument(ref cause) => write!(f, "{}", cause),
AddApplicationOutputError::InvalidRequest(ref cause) => write!(f, "{}", cause),
AddApplicationOutputError::ResourceInUse(ref cause) => write!(f, "{}", cause),
AddApplicationOutputError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for AddApplicationOutputError {}
#[derive(Debug, PartialEq)]
pub enum AddApplicationReferenceDataSourceError {
ConcurrentModification(String),
InvalidArgument(String),
InvalidRequest(String),
ResourceInUse(String),
ResourceNotFound(String),
}
impl AddApplicationReferenceDataSourceError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<AddApplicationReferenceDataSourceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ConcurrentModificationException" => {
return RusotoError::Service(
AddApplicationReferenceDataSourceError::ConcurrentModification(err.msg),
)
}
"InvalidArgumentException" => {
return RusotoError::Service(
AddApplicationReferenceDataSourceError::InvalidArgument(err.msg),
)
}
"InvalidRequestException" => {
return RusotoError::Service(
AddApplicationReferenceDataSourceError::InvalidRequest(err.msg),
)
}
"ResourceInUseException" => {
return RusotoError::Service(
AddApplicationReferenceDataSourceError::ResourceInUse(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
AddApplicationReferenceDataSourceError::ResourceNotFound(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AddApplicationReferenceDataSourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AddApplicationReferenceDataSourceError::ConcurrentModification(ref cause) => {
write!(f, "{}", cause)
}
AddApplicationReferenceDataSourceError::InvalidArgument(ref cause) => {
write!(f, "{}", cause)
}
AddApplicationReferenceDataSourceError::InvalidRequest(ref cause) => {
write!(f, "{}", cause)
}
AddApplicationReferenceDataSourceError::ResourceInUse(ref cause) => {
write!(f, "{}", cause)
}
AddApplicationReferenceDataSourceError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for AddApplicationReferenceDataSourceError {}
#[derive(Debug, PartialEq)]
pub enum AddApplicationVpcConfigurationError {
ConcurrentModification(String),
InvalidArgument(String),
ResourceInUse(String),
ResourceNotFound(String),
}
impl AddApplicationVpcConfigurationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<AddApplicationVpcConfigurationError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ConcurrentModificationException" => {
return RusotoError::Service(
AddApplicationVpcConfigurationError::ConcurrentModification(err.msg),
)
}
"InvalidArgumentException" => {
return RusotoError::Service(
AddApplicationVpcConfigurationError::InvalidArgument(err.msg),
)
}
"ResourceInUseException" => {
return RusotoError::Service(
AddApplicationVpcConfigurationError::ResourceInUse(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
AddApplicationVpcConfigurationError::ResourceNotFound(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AddApplicationVpcConfigurationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AddApplicationVpcConfigurationError::ConcurrentModification(ref cause) => {
write!(f, "{}", cause)
}
AddApplicationVpcConfigurationError::InvalidArgument(ref cause) => {
write!(f, "{}", cause)
}
AddApplicationVpcConfigurationError::ResourceInUse(ref cause) => write!(f, "{}", cause),
AddApplicationVpcConfigurationError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for AddApplicationVpcConfigurationError {}
#[derive(Debug, PartialEq)]
pub enum CreateApplicationError {
CodeValidation(String),
ConcurrentModification(String),
InvalidArgument(String),
InvalidRequest(String),
LimitExceeded(String),
ResourceInUse(String),
TooManyTags(String),
}
impl CreateApplicationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateApplicationError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"CodeValidationException" => {
return RusotoError::Service(CreateApplicationError::CodeValidation(err.msg))
}
"ConcurrentModificationException" => {
return RusotoError::Service(CreateApplicationError::ConcurrentModification(
err.msg,
))
}
"InvalidArgumentException" => {
return RusotoError::Service(CreateApplicationError::InvalidArgument(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(CreateApplicationError::InvalidRequest(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(CreateApplicationError::LimitExceeded(err.msg))
}
"ResourceInUseException" => {
return RusotoError::Service(CreateApplicationError::ResourceInUse(err.msg))
}
"TooManyTagsException" => {
return RusotoError::Service(CreateApplicationError::TooManyTags(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateApplicationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateApplicationError::CodeValidation(ref cause) => write!(f, "{}", cause),
CreateApplicationError::ConcurrentModification(ref cause) => write!(f, "{}", cause),
CreateApplicationError::InvalidArgument(ref cause) => write!(f, "{}", cause),
CreateApplicationError::InvalidRequest(ref cause) => write!(f, "{}", cause),
CreateApplicationError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreateApplicationError::ResourceInUse(ref cause) => write!(f, "{}", cause),
CreateApplicationError::TooManyTags(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateApplicationError {}
#[derive(Debug, PartialEq)]
pub enum CreateApplicationSnapshotError {
InvalidArgument(String),
InvalidRequest(String),
LimitExceeded(String),
ResourceInUse(String),
ResourceNotFound(String),
UnsupportedOperation(String),
}
impl CreateApplicationSnapshotError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateApplicationSnapshotError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidArgumentException" => {
return RusotoError::Service(CreateApplicationSnapshotError::InvalidArgument(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(CreateApplicationSnapshotError::InvalidRequest(
err.msg,
))
}
"LimitExceededException" => {
return RusotoError::Service(CreateApplicationSnapshotError::LimitExceeded(
err.msg,
))
}
"ResourceInUseException" => {
return RusotoError::Service(CreateApplicationSnapshotError::ResourceInUse(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(CreateApplicationSnapshotError::ResourceNotFound(
err.msg,
))
}
"UnsupportedOperationException" => {
return RusotoError::Service(
CreateApplicationSnapshotError::UnsupportedOperation(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateApplicationSnapshotError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateApplicationSnapshotError::InvalidArgument(ref cause) => write!(f, "{}", cause),
CreateApplicationSnapshotError::InvalidRequest(ref cause) => write!(f, "{}", cause),
CreateApplicationSnapshotError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreateApplicationSnapshotError::ResourceInUse(ref cause) => write!(f, "{}", cause),
CreateApplicationSnapshotError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
CreateApplicationSnapshotError::UnsupportedOperation(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for CreateApplicationSnapshotError {}
#[derive(Debug, PartialEq)]
pub enum DeleteApplicationError {
ConcurrentModification(String),
InvalidApplicationConfiguration(String),
InvalidArgument(String),
InvalidRequest(String),
ResourceInUse(String),
ResourceNotFound(String),
}
impl DeleteApplicationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteApplicationError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ConcurrentModificationException" => {
return RusotoError::Service(DeleteApplicationError::ConcurrentModification(
err.msg,
))
}
"InvalidApplicationConfigurationException" => {
return RusotoError::Service(
DeleteApplicationError::InvalidApplicationConfiguration(err.msg),
)
}
"InvalidArgumentException" => {
return RusotoError::Service(DeleteApplicationError::InvalidArgument(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(DeleteApplicationError::InvalidRequest(err.msg))
}
"ResourceInUseException" => {
return RusotoError::Service(DeleteApplicationError::ResourceInUse(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DeleteApplicationError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteApplicationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteApplicationError::ConcurrentModification(ref cause) => write!(f, "{}", cause),
DeleteApplicationError::InvalidApplicationConfiguration(ref cause) => {
write!(f, "{}", cause)
}
DeleteApplicationError::InvalidArgument(ref cause) => write!(f, "{}", cause),
DeleteApplicationError::InvalidRequest(ref cause) => write!(f, "{}", cause),
DeleteApplicationError::ResourceInUse(ref cause) => write!(f, "{}", cause),
DeleteApplicationError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteApplicationError {}
#[derive(Debug, PartialEq)]
pub enum DeleteApplicationCloudWatchLoggingOptionError {
ConcurrentModification(String),
InvalidApplicationConfiguration(String),
InvalidArgument(String),
InvalidRequest(String),
ResourceInUse(String),
ResourceNotFound(String),
}
impl DeleteApplicationCloudWatchLoggingOptionError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DeleteApplicationCloudWatchLoggingOptionError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ConcurrentModificationException" => {
return RusotoError::Service(
DeleteApplicationCloudWatchLoggingOptionError::ConcurrentModification(
err.msg,
),
)
}
"InvalidApplicationConfigurationException" => return RusotoError::Service(
DeleteApplicationCloudWatchLoggingOptionError::InvalidApplicationConfiguration(
err.msg,
),
),
"InvalidArgumentException" => {
return RusotoError::Service(
DeleteApplicationCloudWatchLoggingOptionError::InvalidArgument(err.msg),
)
}
"InvalidRequestException" => {
return RusotoError::Service(
DeleteApplicationCloudWatchLoggingOptionError::InvalidRequest(err.msg),
)
}
"ResourceInUseException" => {
return RusotoError::Service(
DeleteApplicationCloudWatchLoggingOptionError::ResourceInUse(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
DeleteApplicationCloudWatchLoggingOptionError::ResourceNotFound(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteApplicationCloudWatchLoggingOptionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteApplicationCloudWatchLoggingOptionError::ConcurrentModification(ref cause) => {
write!(f, "{}", cause)
}
DeleteApplicationCloudWatchLoggingOptionError::InvalidApplicationConfiguration(
ref cause,
) => write!(f, "{}", cause),
DeleteApplicationCloudWatchLoggingOptionError::InvalidArgument(ref cause) => {
write!(f, "{}", cause)
}
DeleteApplicationCloudWatchLoggingOptionError::InvalidRequest(ref cause) => {
write!(f, "{}", cause)
}
DeleteApplicationCloudWatchLoggingOptionError::ResourceInUse(ref cause) => {
write!(f, "{}", cause)
}
DeleteApplicationCloudWatchLoggingOptionError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DeleteApplicationCloudWatchLoggingOptionError {}
#[derive(Debug, PartialEq)]
pub enum DeleteApplicationInputProcessingConfigurationError {
ConcurrentModification(String),
InvalidArgument(String),
InvalidRequest(String),
ResourceInUse(String),
ResourceNotFound(String),
}
impl DeleteApplicationInputProcessingConfigurationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DeleteApplicationInputProcessingConfigurationError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ConcurrentModificationException" => {
return RusotoError::Service(
DeleteApplicationInputProcessingConfigurationError::ConcurrentModification(
err.msg,
),
)
}
"InvalidArgumentException" => {
return RusotoError::Service(
DeleteApplicationInputProcessingConfigurationError::InvalidArgument(
err.msg,
),
)
}
"InvalidRequestException" => {
return RusotoError::Service(
DeleteApplicationInputProcessingConfigurationError::InvalidRequest(err.msg),
)
}
"ResourceInUseException" => {
return RusotoError::Service(
DeleteApplicationInputProcessingConfigurationError::ResourceInUse(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
DeleteApplicationInputProcessingConfigurationError::ResourceNotFound(
err.msg,
),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteApplicationInputProcessingConfigurationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteApplicationInputProcessingConfigurationError::ConcurrentModification(
ref cause,
) => write!(f, "{}", cause),
DeleteApplicationInputProcessingConfigurationError::InvalidArgument(ref cause) => {
write!(f, "{}", cause)
}
DeleteApplicationInputProcessingConfigurationError::InvalidRequest(ref cause) => {
write!(f, "{}", cause)
}
DeleteApplicationInputProcessingConfigurationError::ResourceInUse(ref cause) => {
write!(f, "{}", cause)
}
DeleteApplicationInputProcessingConfigurationError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DeleteApplicationInputProcessingConfigurationError {}
#[derive(Debug, PartialEq)]
pub enum DeleteApplicationOutputError {
ConcurrentModification(String),
InvalidArgument(String),
InvalidRequest(String),
ResourceInUse(String),
ResourceNotFound(String),
}
impl DeleteApplicationOutputError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteApplicationOutputError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ConcurrentModificationException" => {
return RusotoError::Service(
DeleteApplicationOutputError::ConcurrentModification(err.msg),
)
}
"InvalidArgumentException" => {
return RusotoError::Service(DeleteApplicationOutputError::InvalidArgument(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(DeleteApplicationOutputError::InvalidRequest(
err.msg,
))
}
"ResourceInUseException" => {
return RusotoError::Service(DeleteApplicationOutputError::ResourceInUse(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DeleteApplicationOutputError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteApplicationOutputError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteApplicationOutputError::ConcurrentModification(ref cause) => {
write!(f, "{}", cause)
}
DeleteApplicationOutputError::InvalidArgument(ref cause) => write!(f, "{}", cause),
DeleteApplicationOutputError::InvalidRequest(ref cause) => write!(f, "{}", cause),
DeleteApplicationOutputError::ResourceInUse(ref cause) => write!(f, "{}", cause),
DeleteApplicationOutputError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteApplicationOutputError {}
#[derive(Debug, PartialEq)]
pub enum DeleteApplicationReferenceDataSourceError {
ConcurrentModification(String),
InvalidArgument(String),
InvalidRequest(String),
ResourceInUse(String),
ResourceNotFound(String),
}
impl DeleteApplicationReferenceDataSourceError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DeleteApplicationReferenceDataSourceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ConcurrentModificationException" => {
return RusotoError::Service(
DeleteApplicationReferenceDataSourceError::ConcurrentModification(err.msg),
)
}
"InvalidArgumentException" => {
return RusotoError::Service(
DeleteApplicationReferenceDataSourceError::InvalidArgument(err.msg),
)
}
"InvalidRequestException" => {
return RusotoError::Service(
DeleteApplicationReferenceDataSourceError::InvalidRequest(err.msg),
)
}
"ResourceInUseException" => {
return RusotoError::Service(
DeleteApplicationReferenceDataSourceError::ResourceInUse(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
DeleteApplicationReferenceDataSourceError::ResourceNotFound(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteApplicationReferenceDataSourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteApplicationReferenceDataSourceError::ConcurrentModification(ref cause) => {
write!(f, "{}", cause)
}
DeleteApplicationReferenceDataSourceError::InvalidArgument(ref cause) => {
write!(f, "{}", cause)
}
DeleteApplicationReferenceDataSourceError::InvalidRequest(ref cause) => {
write!(f, "{}", cause)
}
DeleteApplicationReferenceDataSourceError::ResourceInUse(ref cause) => {
write!(f, "{}", cause)
}
DeleteApplicationReferenceDataSourceError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DeleteApplicationReferenceDataSourceError {}
#[derive(Debug, PartialEq)]
pub enum DeleteApplicationSnapshotError {
InvalidArgument(String),
InvalidRequest(String),
ResourceInUse(String),
ResourceNotFound(String),
UnsupportedOperation(String),
}
impl DeleteApplicationSnapshotError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteApplicationSnapshotError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidArgumentException" => {
return RusotoError::Service(DeleteApplicationSnapshotError::InvalidArgument(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(DeleteApplicationSnapshotError::InvalidRequest(
err.msg,
))
}
"ResourceInUseException" => {
return RusotoError::Service(DeleteApplicationSnapshotError::ResourceInUse(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DeleteApplicationSnapshotError::ResourceNotFound(
err.msg,
))
}
"UnsupportedOperationException" => {
return RusotoError::Service(
DeleteApplicationSnapshotError::UnsupportedOperation(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteApplicationSnapshotError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteApplicationSnapshotError::InvalidArgument(ref cause) => write!(f, "{}", cause),
DeleteApplicationSnapshotError::InvalidRequest(ref cause) => write!(f, "{}", cause),
DeleteApplicationSnapshotError::ResourceInUse(ref cause) => write!(f, "{}", cause),
DeleteApplicationSnapshotError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DeleteApplicationSnapshotError::UnsupportedOperation(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DeleteApplicationSnapshotError {}
#[derive(Debug, PartialEq)]
pub enum DeleteApplicationVpcConfigurationError {
ConcurrentModification(String),
InvalidArgument(String),
ResourceInUse(String),
ResourceNotFound(String),
}
impl DeleteApplicationVpcConfigurationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DeleteApplicationVpcConfigurationError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ConcurrentModificationException" => {
return RusotoError::Service(
DeleteApplicationVpcConfigurationError::ConcurrentModification(err.msg),
)
}
"InvalidArgumentException" => {
return RusotoError::Service(
DeleteApplicationVpcConfigurationError::InvalidArgument(err.msg),
)
}
"ResourceInUseException" => {
return RusotoError::Service(
DeleteApplicationVpcConfigurationError::ResourceInUse(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
DeleteApplicationVpcConfigurationError::ResourceNotFound(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteApplicationVpcConfigurationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteApplicationVpcConfigurationError::ConcurrentModification(ref cause) => {
write!(f, "{}", cause)
}
DeleteApplicationVpcConfigurationError::InvalidArgument(ref cause) => {
write!(f, "{}", cause)
}
DeleteApplicationVpcConfigurationError::ResourceInUse(ref cause) => {
write!(f, "{}", cause)
}
DeleteApplicationVpcConfigurationError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DeleteApplicationVpcConfigurationError {}
#[derive(Debug, PartialEq)]
pub enum DescribeApplicationError {
InvalidArgument(String),
InvalidRequest(String),
ResourceNotFound(String),
}
impl DescribeApplicationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeApplicationError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidArgumentException" => {
return RusotoError::Service(DescribeApplicationError::InvalidArgument(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(DescribeApplicationError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeApplicationError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeApplicationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeApplicationError::InvalidArgument(ref cause) => write!(f, "{}", cause),
DescribeApplicationError::InvalidRequest(ref cause) => write!(f, "{}", cause),
DescribeApplicationError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeApplicationError {}
#[derive(Debug, PartialEq)]
pub enum DescribeApplicationSnapshotError {
InvalidArgument(String),
ResourceNotFound(String),
UnsupportedOperation(String),
}
impl DescribeApplicationSnapshotError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeApplicationSnapshotError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidArgumentException" => {
return RusotoError::Service(DescribeApplicationSnapshotError::InvalidArgument(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(
DescribeApplicationSnapshotError::ResourceNotFound(err.msg),
)
}
"UnsupportedOperationException" => {
return RusotoError::Service(
DescribeApplicationSnapshotError::UnsupportedOperation(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeApplicationSnapshotError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeApplicationSnapshotError::InvalidArgument(ref cause) => write!(f, "{}", cause),
DescribeApplicationSnapshotError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DescribeApplicationSnapshotError::UnsupportedOperation(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeApplicationSnapshotError {}
#[derive(Debug, PartialEq)]
pub enum DiscoverInputSchemaError {
InvalidArgument(String),
InvalidRequest(String),
ResourceProvisionedThroughputExceeded(String),
ServiceUnavailable(String),
UnableToDetectSchema(String),
}
impl DiscoverInputSchemaError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DiscoverInputSchemaError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidArgumentException" => {
return RusotoError::Service(DiscoverInputSchemaError::InvalidArgument(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(DiscoverInputSchemaError::InvalidRequest(err.msg))
}
"ResourceProvisionedThroughputExceededException" => {
return RusotoError::Service(
DiscoverInputSchemaError::ResourceProvisionedThroughputExceeded(err.msg),
)
}
"ServiceUnavailableException" => {
return RusotoError::Service(DiscoverInputSchemaError::ServiceUnavailable(
err.msg,
))
}
"UnableToDetectSchemaException" => {
return RusotoError::Service(DiscoverInputSchemaError::UnableToDetectSchema(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DiscoverInputSchemaError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DiscoverInputSchemaError::InvalidArgument(ref cause) => write!(f, "{}", cause),
DiscoverInputSchemaError::InvalidRequest(ref cause) => write!(f, "{}", cause),
DiscoverInputSchemaError::ResourceProvisionedThroughputExceeded(ref cause) => {
write!(f, "{}", cause)
}
DiscoverInputSchemaError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
DiscoverInputSchemaError::UnableToDetectSchema(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DiscoverInputSchemaError {}
#[derive(Debug, PartialEq)]
pub enum ListApplicationSnapshotsError {
InvalidArgument(String),
UnsupportedOperation(String),
}
impl ListApplicationSnapshotsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListApplicationSnapshotsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidArgumentException" => {
return RusotoError::Service(ListApplicationSnapshotsError::InvalidArgument(
err.msg,
))
}
"UnsupportedOperationException" => {
return RusotoError::Service(
ListApplicationSnapshotsError::UnsupportedOperation(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListApplicationSnapshotsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListApplicationSnapshotsError::InvalidArgument(ref cause) => write!(f, "{}", cause),
ListApplicationSnapshotsError::UnsupportedOperation(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ListApplicationSnapshotsError {}
#[derive(Debug, PartialEq)]
pub enum ListApplicationsError {
InvalidRequest(String),
}
impl ListApplicationsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListApplicationsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidRequestException" => {
return RusotoError::Service(ListApplicationsError::InvalidRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListApplicationsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListApplicationsError::InvalidRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListApplicationsError {}
#[derive(Debug, PartialEq)]
pub enum ListTagsForResourceError {
ConcurrentModification(String),
InvalidArgument(String),
ResourceNotFound(String),
}
impl ListTagsForResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListTagsForResourceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ConcurrentModificationException" => {
return RusotoError::Service(ListTagsForResourceError::ConcurrentModification(
err.msg,
))
}
"InvalidArgumentException" => {
return RusotoError::Service(ListTagsForResourceError::InvalidArgument(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListTagsForResourceError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListTagsForResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListTagsForResourceError::ConcurrentModification(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::InvalidArgument(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListTagsForResourceError {}
#[derive(Debug, PartialEq)]
pub enum StartApplicationError {
InvalidApplicationConfiguration(String),
InvalidArgument(String),
InvalidRequest(String),
ResourceInUse(String),
ResourceNotFound(String),
}
impl StartApplicationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StartApplicationError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidApplicationConfigurationException" => {
return RusotoError::Service(
StartApplicationError::InvalidApplicationConfiguration(err.msg),
)
}
"InvalidArgumentException" => {
return RusotoError::Service(StartApplicationError::InvalidArgument(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(StartApplicationError::InvalidRequest(err.msg))
}
"ResourceInUseException" => {
return RusotoError::Service(StartApplicationError::ResourceInUse(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(StartApplicationError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for StartApplicationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
StartApplicationError::InvalidApplicationConfiguration(ref cause) => {
write!(f, "{}", cause)
}
StartApplicationError::InvalidArgument(ref cause) => write!(f, "{}", cause),
StartApplicationError::InvalidRequest(ref cause) => write!(f, "{}", cause),
StartApplicationError::ResourceInUse(ref cause) => write!(f, "{}", cause),
StartApplicationError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for StartApplicationError {}
#[derive(Debug, PartialEq)]
pub enum StopApplicationError {
InvalidApplicationConfiguration(String),
InvalidArgument(String),
InvalidRequest(String),
ResourceInUse(String),
ResourceNotFound(String),
}
impl StopApplicationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StopApplicationError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidApplicationConfigurationException" => {
return RusotoError::Service(
StopApplicationError::InvalidApplicationConfiguration(err.msg),
)
}
"InvalidArgumentException" => {
return RusotoError::Service(StopApplicationError::InvalidArgument(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(StopApplicationError::InvalidRequest(err.msg))
}
"ResourceInUseException" => {
return RusotoError::Service(StopApplicationError::ResourceInUse(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(StopApplicationError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for StopApplicationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
StopApplicationError::InvalidApplicationConfiguration(ref cause) => {
write!(f, "{}", cause)
}
StopApplicationError::InvalidArgument(ref cause) => write!(f, "{}", cause),
StopApplicationError::InvalidRequest(ref cause) => write!(f, "{}", cause),
StopApplicationError::ResourceInUse(ref cause) => write!(f, "{}", cause),
StopApplicationError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for StopApplicationError {}
#[derive(Debug, PartialEq)]
pub enum TagResourceError {
ConcurrentModification(String),
InvalidArgument(String),
ResourceInUse(String),
ResourceNotFound(String),
TooManyTags(String),
}
impl TagResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<TagResourceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ConcurrentModificationException" => {
return RusotoError::Service(TagResourceError::ConcurrentModification(err.msg))
}
"InvalidArgumentException" => {
return RusotoError::Service(TagResourceError::InvalidArgument(err.msg))
}
"ResourceInUseException" => {
return RusotoError::Service(TagResourceError::ResourceInUse(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(TagResourceError::ResourceNotFound(err.msg))
}
"TooManyTagsException" => {
return RusotoError::Service(TagResourceError::TooManyTags(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for TagResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
TagResourceError::ConcurrentModification(ref cause) => write!(f, "{}", cause),
TagResourceError::InvalidArgument(ref cause) => write!(f, "{}", cause),
TagResourceError::ResourceInUse(ref cause) => write!(f, "{}", cause),
TagResourceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
TagResourceError::TooManyTags(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for TagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UntagResourceError {
ConcurrentModification(String),
InvalidArgument(String),
ResourceInUse(String),
ResourceNotFound(String),
TooManyTags(String),
}
impl UntagResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UntagResourceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ConcurrentModificationException" => {
return RusotoError::Service(UntagResourceError::ConcurrentModification(
err.msg,
))
}
"InvalidArgumentException" => {
return RusotoError::Service(UntagResourceError::InvalidArgument(err.msg))
}
"ResourceInUseException" => {
return RusotoError::Service(UntagResourceError::ResourceInUse(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UntagResourceError::ResourceNotFound(err.msg))
}
"TooManyTagsException" => {
return RusotoError::Service(UntagResourceError::TooManyTags(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UntagResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UntagResourceError::ConcurrentModification(ref cause) => write!(f, "{}", cause),
UntagResourceError::InvalidArgument(ref cause) => write!(f, "{}", cause),
UntagResourceError::ResourceInUse(ref cause) => write!(f, "{}", cause),
UntagResourceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
UntagResourceError::TooManyTags(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UntagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UpdateApplicationError {
CodeValidation(String),
ConcurrentModification(String),
InvalidApplicationConfiguration(String),
InvalidArgument(String),
InvalidRequest(String),
ResourceInUse(String),
ResourceNotFound(String),
}
impl UpdateApplicationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateApplicationError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"CodeValidationException" => {
return RusotoError::Service(UpdateApplicationError::CodeValidation(err.msg))
}
"ConcurrentModificationException" => {
return RusotoError::Service(UpdateApplicationError::ConcurrentModification(
err.msg,
))
}
"InvalidApplicationConfigurationException" => {
return RusotoError::Service(
UpdateApplicationError::InvalidApplicationConfiguration(err.msg),
)
}
"InvalidArgumentException" => {
return RusotoError::Service(UpdateApplicationError::InvalidArgument(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(UpdateApplicationError::InvalidRequest(err.msg))
}
"ResourceInUseException" => {
return RusotoError::Service(UpdateApplicationError::ResourceInUse(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UpdateApplicationError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateApplicationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateApplicationError::CodeValidation(ref cause) => write!(f, "{}", cause),
UpdateApplicationError::ConcurrentModification(ref cause) => write!(f, "{}", cause),
UpdateApplicationError::InvalidApplicationConfiguration(ref cause) => {
write!(f, "{}", cause)
}
UpdateApplicationError::InvalidArgument(ref cause) => write!(f, "{}", cause),
UpdateApplicationError::InvalidRequest(ref cause) => write!(f, "{}", cause),
UpdateApplicationError::ResourceInUse(ref cause) => write!(f, "{}", cause),
UpdateApplicationError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateApplicationError {}
#[async_trait]
pub trait KinesisAnalyticsV2 {
async fn add_application_cloud_watch_logging_option(
&self,
input: AddApplicationCloudWatchLoggingOptionRequest,
) -> Result<
AddApplicationCloudWatchLoggingOptionResponse,
RusotoError<AddApplicationCloudWatchLoggingOptionError>,
>;
async fn add_application_input(
&self,
input: AddApplicationInputRequest,
) -> Result<AddApplicationInputResponse, RusotoError<AddApplicationInputError>>;
async fn add_application_input_processing_configuration(
&self,
input: AddApplicationInputProcessingConfigurationRequest,
) -> Result<
AddApplicationInputProcessingConfigurationResponse,
RusotoError<AddApplicationInputProcessingConfigurationError>,
>;
async fn add_application_output(
&self,
input: AddApplicationOutputRequest,
) -> Result<AddApplicationOutputResponse, RusotoError<AddApplicationOutputError>>;
async fn add_application_reference_data_source(
&self,
input: AddApplicationReferenceDataSourceRequest,
) -> Result<
AddApplicationReferenceDataSourceResponse,
RusotoError<AddApplicationReferenceDataSourceError>,
>;
async fn add_application_vpc_configuration(
&self,
input: AddApplicationVpcConfigurationRequest,
) -> Result<
AddApplicationVpcConfigurationResponse,
RusotoError<AddApplicationVpcConfigurationError>,
>;
async fn create_application(
&self,
input: CreateApplicationRequest,
) -> Result<CreateApplicationResponse, RusotoError<CreateApplicationError>>;
async fn create_application_snapshot(
&self,
input: CreateApplicationSnapshotRequest,
) -> Result<CreateApplicationSnapshotResponse, RusotoError<CreateApplicationSnapshotError>>;
async fn delete_application(
&self,
input: DeleteApplicationRequest,
) -> Result<DeleteApplicationResponse, RusotoError<DeleteApplicationError>>;
async fn delete_application_cloud_watch_logging_option(
&self,
input: DeleteApplicationCloudWatchLoggingOptionRequest,
) -> Result<
DeleteApplicationCloudWatchLoggingOptionResponse,
RusotoError<DeleteApplicationCloudWatchLoggingOptionError>,
>;
async fn delete_application_input_processing_configuration(
&self,
input: DeleteApplicationInputProcessingConfigurationRequest,
) -> Result<
DeleteApplicationInputProcessingConfigurationResponse,
RusotoError<DeleteApplicationInputProcessingConfigurationError>,
>;
async fn delete_application_output(
&self,
input: DeleteApplicationOutputRequest,
) -> Result<DeleteApplicationOutputResponse, RusotoError<DeleteApplicationOutputError>>;
async fn delete_application_reference_data_source(
&self,
input: DeleteApplicationReferenceDataSourceRequest,
) -> Result<
DeleteApplicationReferenceDataSourceResponse,
RusotoError<DeleteApplicationReferenceDataSourceError>,
>;
async fn delete_application_snapshot(
&self,
input: DeleteApplicationSnapshotRequest,
) -> Result<DeleteApplicationSnapshotResponse, RusotoError<DeleteApplicationSnapshotError>>;
async fn delete_application_vpc_configuration(
&self,
input: DeleteApplicationVpcConfigurationRequest,
) -> Result<
DeleteApplicationVpcConfigurationResponse,
RusotoError<DeleteApplicationVpcConfigurationError>,
>;
async fn describe_application(
&self,
input: DescribeApplicationRequest,
) -> Result<DescribeApplicationResponse, RusotoError<DescribeApplicationError>>;
async fn describe_application_snapshot(
&self,
input: DescribeApplicationSnapshotRequest,
) -> Result<DescribeApplicationSnapshotResponse, RusotoError<DescribeApplicationSnapshotError>>;
async fn discover_input_schema(
&self,
input: DiscoverInputSchemaRequest,
) -> Result<DiscoverInputSchemaResponse, RusotoError<DiscoverInputSchemaError>>;
async fn list_application_snapshots(
&self,
input: ListApplicationSnapshotsRequest,
) -> Result<ListApplicationSnapshotsResponse, RusotoError<ListApplicationSnapshotsError>>;
async fn list_applications(
&self,
input: ListApplicationsRequest,
) -> Result<ListApplicationsResponse, RusotoError<ListApplicationsError>>;
async fn list_tags_for_resource(
&self,
input: ListTagsForResourceRequest,
) -> Result<ListTagsForResourceResponse, RusotoError<ListTagsForResourceError>>;
async fn start_application(
&self,
input: StartApplicationRequest,
) -> Result<StartApplicationResponse, RusotoError<StartApplicationError>>;
async fn stop_application(
&self,
input: StopApplicationRequest,
) -> Result<StopApplicationResponse, RusotoError<StopApplicationError>>;
async fn tag_resource(
&self,
input: TagResourceRequest,
) -> Result<TagResourceResponse, RusotoError<TagResourceError>>;
async fn untag_resource(
&self,
input: UntagResourceRequest,
) -> Result<UntagResourceResponse, RusotoError<UntagResourceError>>;
async fn update_application(
&self,
input: UpdateApplicationRequest,
) -> Result<UpdateApplicationResponse, RusotoError<UpdateApplicationError>>;
}
#[derive(Clone)]
pub struct KinesisAnalyticsV2Client {
client: Client,
region: region::Region,
}
impl KinesisAnalyticsV2Client {
pub fn new(region: region::Region) -> KinesisAnalyticsV2Client {
KinesisAnalyticsV2Client {
client: Client::shared(),
region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> KinesisAnalyticsV2Client
where
P: ProvideAwsCredentials + Send + Sync + 'static,
D: DispatchSignedRequest + Send + Sync + 'static,
{
KinesisAnalyticsV2Client {
client: Client::new_with(credentials_provider, request_dispatcher),
region,
}
}
pub fn new_with_client(client: Client, region: region::Region) -> KinesisAnalyticsV2Client {
KinesisAnalyticsV2Client { client, region }
}
}
#[async_trait]
impl KinesisAnalyticsV2 for KinesisAnalyticsV2Client {
async fn add_application_cloud_watch_logging_option(
&self,
input: AddApplicationCloudWatchLoggingOptionRequest,
) -> Result<
AddApplicationCloudWatchLoggingOptionResponse,
RusotoError<AddApplicationCloudWatchLoggingOptionError>,
> {
let mut request = SignedRequest::new("POST", "kinesisanalytics", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"KinesisAnalytics_20180523.AddApplicationCloudWatchLoggingOption",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<AddApplicationCloudWatchLoggingOptionResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(AddApplicationCloudWatchLoggingOptionError::from_response(
response,
))
}
}
async fn add_application_input(
&self,
input: AddApplicationInputRequest,
) -> Result<AddApplicationInputResponse, RusotoError<AddApplicationInputError>> {
let mut request = SignedRequest::new("POST", "kinesisanalytics", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"KinesisAnalytics_20180523.AddApplicationInput",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<AddApplicationInputResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(AddApplicationInputError::from_response(response))
}
}
async fn add_application_input_processing_configuration(
&self,
input: AddApplicationInputProcessingConfigurationRequest,
) -> Result<
AddApplicationInputProcessingConfigurationResponse,
RusotoError<AddApplicationInputProcessingConfigurationError>,
> {
let mut request = SignedRequest::new("POST", "kinesisanalytics", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"KinesisAnalytics_20180523.AddApplicationInputProcessingConfiguration",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<AddApplicationInputProcessingConfigurationResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(AddApplicationInputProcessingConfigurationError::from_response(response))
}
}
async fn add_application_output(
&self,
input: AddApplicationOutputRequest,
) -> Result<AddApplicationOutputResponse, RusotoError<AddApplicationOutputError>> {
let mut request = SignedRequest::new("POST", "kinesisanalytics", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"KinesisAnalytics_20180523.AddApplicationOutput",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<AddApplicationOutputResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(AddApplicationOutputError::from_response(response))
}
}
async fn add_application_reference_data_source(
&self,
input: AddApplicationReferenceDataSourceRequest,
) -> Result<
AddApplicationReferenceDataSourceResponse,
RusotoError<AddApplicationReferenceDataSourceError>,
> {
let mut request = SignedRequest::new("POST", "kinesisanalytics", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"KinesisAnalytics_20180523.AddApplicationReferenceDataSource",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<AddApplicationReferenceDataSourceResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(AddApplicationReferenceDataSourceError::from_response(
response,
))
}
}
async fn add_application_vpc_configuration(
&self,
input: AddApplicationVpcConfigurationRequest,
) -> Result<
AddApplicationVpcConfigurationResponse,
RusotoError<AddApplicationVpcConfigurationError>,
> {
let mut request = SignedRequest::new("POST", "kinesisanalytics", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"KinesisAnalytics_20180523.AddApplicationVpcConfiguration",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<AddApplicationVpcConfigurationResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(AddApplicationVpcConfigurationError::from_response(response))
}
}
async fn create_application(
&self,
input: CreateApplicationRequest,
) -> Result<CreateApplicationResponse, RusotoError<CreateApplicationError>> {
let mut request = SignedRequest::new("POST", "kinesisanalytics", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"KinesisAnalytics_20180523.CreateApplication",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<CreateApplicationResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(CreateApplicationError::from_response(response))
}
}
async fn create_application_snapshot(
&self,
input: CreateApplicationSnapshotRequest,
) -> Result<CreateApplicationSnapshotResponse, RusotoError<CreateApplicationSnapshotError>>
{
let mut request = SignedRequest::new("POST", "kinesisanalytics", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"KinesisAnalytics_20180523.CreateApplicationSnapshot",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<CreateApplicationSnapshotResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(CreateApplicationSnapshotError::from_response(response))
}
}
async fn delete_application(
&self,
input: DeleteApplicationRequest,
) -> Result<DeleteApplicationResponse, RusotoError<DeleteApplicationError>> {
let mut request = SignedRequest::new("POST", "kinesisanalytics", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"KinesisAnalytics_20180523.DeleteApplication",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteApplicationResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(DeleteApplicationError::from_response(response))
}
}
async fn delete_application_cloud_watch_logging_option(
&self,
input: DeleteApplicationCloudWatchLoggingOptionRequest,
) -> Result<
DeleteApplicationCloudWatchLoggingOptionResponse,
RusotoError<DeleteApplicationCloudWatchLoggingOptionError>,
> {
let mut request = SignedRequest::new("POST", "kinesisanalytics", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"KinesisAnalytics_20180523.DeleteApplicationCloudWatchLoggingOption",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteApplicationCloudWatchLoggingOptionResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(DeleteApplicationCloudWatchLoggingOptionError::from_response(response))
}
}
async fn delete_application_input_processing_configuration(
&self,
input: DeleteApplicationInputProcessingConfigurationRequest,
) -> Result<
DeleteApplicationInputProcessingConfigurationResponse,
RusotoError<DeleteApplicationInputProcessingConfigurationError>,
> {
let mut request = SignedRequest::new("POST", "kinesisanalytics", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"KinesisAnalytics_20180523.DeleteApplicationInputProcessingConfiguration",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteApplicationInputProcessingConfigurationResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(DeleteApplicationInputProcessingConfigurationError::from_response(response))
}
}
async fn delete_application_output(
&self,
input: DeleteApplicationOutputRequest,
) -> Result<DeleteApplicationOutputResponse, RusotoError<DeleteApplicationOutputError>> {
let mut request = SignedRequest::new("POST", "kinesisanalytics", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"KinesisAnalytics_20180523.DeleteApplicationOutput",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteApplicationOutputResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(DeleteApplicationOutputError::from_response(response))
}
}
async fn delete_application_reference_data_source(
&self,
input: DeleteApplicationReferenceDataSourceRequest,
) -> Result<
DeleteApplicationReferenceDataSourceResponse,
RusotoError<DeleteApplicationReferenceDataSourceError>,
> {
let mut request = SignedRequest::new("POST", "kinesisanalytics", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"KinesisAnalytics_20180523.DeleteApplicationReferenceDataSource",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteApplicationReferenceDataSourceResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(DeleteApplicationReferenceDataSourceError::from_response(
response,
))
}
}
async fn delete_application_snapshot(
&self,
input: DeleteApplicationSnapshotRequest,
) -> Result<DeleteApplicationSnapshotResponse, RusotoError<DeleteApplicationSnapshotError>>
{
let mut request = SignedRequest::new("POST", "kinesisanalytics", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"KinesisAnalytics_20180523.DeleteApplicationSnapshot",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteApplicationSnapshotResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(DeleteApplicationSnapshotError::from_response(response))
}
}
async fn delete_application_vpc_configuration(
&self,
input: DeleteApplicationVpcConfigurationRequest,
) -> Result<
DeleteApplicationVpcConfigurationResponse,
RusotoError<DeleteApplicationVpcConfigurationError>,
> {
let mut request = SignedRequest::new("POST", "kinesisanalytics", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"KinesisAnalytics_20180523.DeleteApplicationVpcConfiguration",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteApplicationVpcConfigurationResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(DeleteApplicationVpcConfigurationError::from_response(
response,
))
}
}
async fn describe_application(
&self,
input: DescribeApplicationRequest,
) -> Result<DescribeApplicationResponse, RusotoError<DescribeApplicationError>> {
let mut request = SignedRequest::new("POST", "kinesisanalytics", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"KinesisAnalytics_20180523.DescribeApplication",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeApplicationResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(DescribeApplicationError::from_response(response))
}
}
async fn describe_application_snapshot(
&self,
input: DescribeApplicationSnapshotRequest,
) -> Result<DescribeApplicationSnapshotResponse, RusotoError<DescribeApplicationSnapshotError>>
{
let mut request = SignedRequest::new("POST", "kinesisanalytics", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"KinesisAnalytics_20180523.DescribeApplicationSnapshot",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeApplicationSnapshotResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(DescribeApplicationSnapshotError::from_response(response))
}
}
async fn discover_input_schema(
&self,
input: DiscoverInputSchemaRequest,
) -> Result<DiscoverInputSchemaResponse, RusotoError<DiscoverInputSchemaError>> {
let mut request = SignedRequest::new("POST", "kinesisanalytics", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"KinesisAnalytics_20180523.DiscoverInputSchema",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DiscoverInputSchemaResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(DiscoverInputSchemaError::from_response(response))
}
}
async fn list_application_snapshots(
&self,
input: ListApplicationSnapshotsRequest,
) -> Result<ListApplicationSnapshotsResponse, RusotoError<ListApplicationSnapshotsError>> {
let mut request = SignedRequest::new("POST", "kinesisanalytics", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"KinesisAnalytics_20180523.ListApplicationSnapshots",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListApplicationSnapshotsResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(ListApplicationSnapshotsError::from_response(response))
}
}
async fn list_applications(
&self,
input: ListApplicationsRequest,
) -> Result<ListApplicationsResponse, RusotoError<ListApplicationsError>> {
let mut request = SignedRequest::new("POST", "kinesisanalytics", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "KinesisAnalytics_20180523.ListApplications");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListApplicationsResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(ListApplicationsError::from_response(response))
}
}
async fn list_tags_for_resource(
&self,
input: ListTagsForResourceRequest,
) -> Result<ListTagsForResourceResponse, RusotoError<ListTagsForResourceError>> {
let mut request = SignedRequest::new("POST", "kinesisanalytics", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"KinesisAnalytics_20180523.ListTagsForResource",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListTagsForResourceResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(ListTagsForResourceError::from_response(response))
}
}
async fn start_application(
&self,
input: StartApplicationRequest,
) -> Result<StartApplicationResponse, RusotoError<StartApplicationError>> {
let mut request = SignedRequest::new("POST", "kinesisanalytics", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "KinesisAnalytics_20180523.StartApplication");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<StartApplicationResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(StartApplicationError::from_response(response))
}
}
async fn stop_application(
&self,
input: StopApplicationRequest,
) -> Result<StopApplicationResponse, RusotoError<StopApplicationError>> {
let mut request = SignedRequest::new("POST", "kinesisanalytics", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "KinesisAnalytics_20180523.StopApplication");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<StopApplicationResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(StopApplicationError::from_response(response))
}
}
async fn tag_resource(
&self,
input: TagResourceRequest,
) -> Result<TagResourceResponse, RusotoError<TagResourceError>> {
let mut request = SignedRequest::new("POST", "kinesisanalytics", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "KinesisAnalytics_20180523.TagResource");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<TagResourceResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(TagResourceError::from_response(response))
}
}
async fn untag_resource(
&self,
input: UntagResourceRequest,
) -> Result<UntagResourceResponse, RusotoError<UntagResourceError>> {
let mut request = SignedRequest::new("POST", "kinesisanalytics", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "KinesisAnalytics_20180523.UntagResource");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<UntagResourceResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(UntagResourceError::from_response(response))
}
}
async fn update_application(
&self,
input: UpdateApplicationRequest,
) -> Result<UpdateApplicationResponse, RusotoError<UpdateApplicationError>> {
let mut request = SignedRequest::new("POST", "kinesisanalytics", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"KinesisAnalytics_20180523.UpdateApplication",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateApplicationResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(UpdateApplicationError::from_response(response))
}
}
}