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::param::{Params, ServiceParams};
use rusoto_core::proto;
use rusoto_core::signature::SignedRequest;
#[allow(unused_imports)]
use serde::{Deserialize, Serialize};
use serde_json;
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Ami {
#[serde(rename = "accountId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub account_id: Option<String>,
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "image")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image: Option<String>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "region")]
#[serde(skip_serializing_if = "Option::is_none")]
pub region: Option<String>,
#[serde(rename = "state")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state: Option<ImageState>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct AmiDistributionConfiguration {
#[serde(rename = "amiTags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ami_tags: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "kmsKeyId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kms_key_id: Option<String>,
#[serde(rename = "launchPermission")]
#[serde(skip_serializing_if = "Option::is_none")]
pub launch_permission: Option<LaunchPermissionConfiguration>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "targetAccountIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub target_account_ids: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CancelImageCreationRequest {
#[serde(rename = "clientToken")]
pub client_token: String,
#[serde(rename = "imageBuildVersionArn")]
pub image_build_version_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CancelImageCreationResponse {
#[serde(rename = "clientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_token: Option<String>,
#[serde(rename = "imageBuildVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_build_version_arn: Option<String>,
#[serde(rename = "requestId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub request_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Component {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "changeDescription")]
#[serde(skip_serializing_if = "Option::is_none")]
pub change_description: Option<String>,
#[serde(rename = "data")]
#[serde(skip_serializing_if = "Option::is_none")]
pub data: Option<String>,
#[serde(rename = "dateCreated")]
#[serde(skip_serializing_if = "Option::is_none")]
pub date_created: Option<String>,
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "encrypted")]
#[serde(skip_serializing_if = "Option::is_none")]
pub encrypted: Option<bool>,
#[serde(rename = "kmsKeyId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kms_key_id: Option<String>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "owner")]
#[serde(skip_serializing_if = "Option::is_none")]
pub owner: Option<String>,
#[serde(rename = "platform")]
#[serde(skip_serializing_if = "Option::is_none")]
pub platform: Option<String>,
#[serde(rename = "supportedOsVersions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub supported_os_versions: Option<Vec<String>>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
#[serde(rename = "version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ComponentConfiguration {
#[serde(rename = "componentArn")]
pub component_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ComponentSummary {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "changeDescription")]
#[serde(skip_serializing_if = "Option::is_none")]
pub change_description: Option<String>,
#[serde(rename = "dateCreated")]
#[serde(skip_serializing_if = "Option::is_none")]
pub date_created: Option<String>,
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "owner")]
#[serde(skip_serializing_if = "Option::is_none")]
pub owner: Option<String>,
#[serde(rename = "platform")]
#[serde(skip_serializing_if = "Option::is_none")]
pub platform: Option<String>,
#[serde(rename = "supportedOsVersions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub supported_os_versions: Option<Vec<String>>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
#[serde(rename = "version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ComponentVersion {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "dateCreated")]
#[serde(skip_serializing_if = "Option::is_none")]
pub date_created: Option<String>,
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "owner")]
#[serde(skip_serializing_if = "Option::is_none")]
pub owner: Option<String>,
#[serde(rename = "platform")]
#[serde(skip_serializing_if = "Option::is_none")]
pub platform: Option<String>,
#[serde(rename = "supportedOsVersions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub supported_os_versions: Option<Vec<String>>,
#[serde(rename = "type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
#[serde(rename = "version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Container {
#[serde(rename = "imageUris")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_uris: Option<Vec<String>>,
#[serde(rename = "region")]
#[serde(skip_serializing_if = "Option::is_none")]
pub region: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ContainerDistributionConfiguration {
#[serde(rename = "containerTags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub container_tags: Option<Vec<String>>,
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "targetRepository")]
pub target_repository: TargetContainerRepository,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ContainerRecipe {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "components")]
#[serde(skip_serializing_if = "Option::is_none")]
pub components: Option<Vec<ComponentConfiguration>>,
#[serde(rename = "containerType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub container_type: Option<String>,
#[serde(rename = "dateCreated")]
#[serde(skip_serializing_if = "Option::is_none")]
pub date_created: Option<String>,
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "dockerfileTemplateData")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dockerfile_template_data: Option<String>,
#[serde(rename = "encrypted")]
#[serde(skip_serializing_if = "Option::is_none")]
pub encrypted: Option<bool>,
#[serde(rename = "kmsKeyId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kms_key_id: Option<String>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "owner")]
#[serde(skip_serializing_if = "Option::is_none")]
pub owner: Option<String>,
#[serde(rename = "parentImage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub parent_image: Option<String>,
#[serde(rename = "platform")]
#[serde(skip_serializing_if = "Option::is_none")]
pub platform: Option<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "targetRepository")]
#[serde(skip_serializing_if = "Option::is_none")]
pub target_repository: Option<TargetContainerRepository>,
#[serde(rename = "version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
#[serde(rename = "workingDirectory")]
#[serde(skip_serializing_if = "Option::is_none")]
pub working_directory: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ContainerRecipeSummary {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "containerType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub container_type: Option<String>,
#[serde(rename = "dateCreated")]
#[serde(skip_serializing_if = "Option::is_none")]
pub date_created: Option<String>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "owner")]
#[serde(skip_serializing_if = "Option::is_none")]
pub owner: Option<String>,
#[serde(rename = "parentImage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub parent_image: Option<String>,
#[serde(rename = "platform")]
#[serde(skip_serializing_if = "Option::is_none")]
pub platform: Option<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateComponentRequest {
#[serde(rename = "changeDescription")]
#[serde(skip_serializing_if = "Option::is_none")]
pub change_description: Option<String>,
#[serde(rename = "clientToken")]
pub client_token: String,
#[serde(rename = "data")]
#[serde(skip_serializing_if = "Option::is_none")]
pub data: Option<String>,
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "kmsKeyId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kms_key_id: Option<String>,
#[serde(rename = "name")]
pub name: String,
#[serde(rename = "platform")]
pub platform: String,
#[serde(rename = "semanticVersion")]
pub semantic_version: String,
#[serde(rename = "supportedOsVersions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub supported_os_versions: Option<Vec<String>>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "uri")]
#[serde(skip_serializing_if = "Option::is_none")]
pub uri: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateComponentResponse {
#[serde(rename = "clientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_token: Option<String>,
#[serde(rename = "componentBuildVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub component_build_version_arn: Option<String>,
#[serde(rename = "requestId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub request_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateContainerRecipeRequest {
#[serde(rename = "clientToken")]
pub client_token: String,
#[serde(rename = "components")]
pub components: Vec<ComponentConfiguration>,
#[serde(rename = "containerType")]
pub container_type: String,
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "dockerfileTemplateData")]
pub dockerfile_template_data: String,
#[serde(rename = "dockerfileTemplateUri")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dockerfile_template_uri: Option<String>,
#[serde(rename = "imageOsVersionOverride")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_os_version_override: Option<String>,
#[serde(rename = "kmsKeyId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kms_key_id: Option<String>,
#[serde(rename = "name")]
pub name: String,
#[serde(rename = "parentImage")]
pub parent_image: String,
#[serde(rename = "platformOverride")]
#[serde(skip_serializing_if = "Option::is_none")]
pub platform_override: Option<String>,
#[serde(rename = "semanticVersion")]
pub semantic_version: String,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "targetRepository")]
pub target_repository: TargetContainerRepository,
#[serde(rename = "workingDirectory")]
#[serde(skip_serializing_if = "Option::is_none")]
pub working_directory: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateContainerRecipeResponse {
#[serde(rename = "clientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_token: Option<String>,
#[serde(rename = "containerRecipeArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub container_recipe_arn: Option<String>,
#[serde(rename = "requestId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub request_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateDistributionConfigurationRequest {
#[serde(rename = "clientToken")]
pub client_token: String,
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "distributions")]
pub distributions: Vec<Distribution>,
#[serde(rename = "name")]
pub name: String,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateDistributionConfigurationResponse {
#[serde(rename = "clientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_token: Option<String>,
#[serde(rename = "distributionConfigurationArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub distribution_configuration_arn: Option<String>,
#[serde(rename = "requestId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub request_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateImagePipelineRequest {
#[serde(rename = "clientToken")]
pub client_token: String,
#[serde(rename = "containerRecipeArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub container_recipe_arn: Option<String>,
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "distributionConfigurationArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub distribution_configuration_arn: Option<String>,
#[serde(rename = "enhancedImageMetadataEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enhanced_image_metadata_enabled: Option<bool>,
#[serde(rename = "imageRecipeArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_recipe_arn: Option<String>,
#[serde(rename = "imageTestsConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_tests_configuration: Option<ImageTestsConfiguration>,
#[serde(rename = "infrastructureConfigurationArn")]
pub infrastructure_configuration_arn: String,
#[serde(rename = "name")]
pub name: String,
#[serde(rename = "schedule")]
#[serde(skip_serializing_if = "Option::is_none")]
pub schedule: Option<Schedule>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateImagePipelineResponse {
#[serde(rename = "clientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_token: Option<String>,
#[serde(rename = "imagePipelineArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_pipeline_arn: Option<String>,
#[serde(rename = "requestId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub request_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateImageRecipeRequest {
#[serde(rename = "blockDeviceMappings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub block_device_mappings: Option<Vec<InstanceBlockDeviceMapping>>,
#[serde(rename = "clientToken")]
pub client_token: String,
#[serde(rename = "components")]
pub components: Vec<ComponentConfiguration>,
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "name")]
pub name: String,
#[serde(rename = "parentImage")]
pub parent_image: String,
#[serde(rename = "semanticVersion")]
pub semantic_version: String,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "workingDirectory")]
#[serde(skip_serializing_if = "Option::is_none")]
pub working_directory: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateImageRecipeResponse {
#[serde(rename = "clientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_token: Option<String>,
#[serde(rename = "imageRecipeArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_recipe_arn: Option<String>,
#[serde(rename = "requestId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub request_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateImageRequest {
#[serde(rename = "clientToken")]
pub client_token: String,
#[serde(rename = "containerRecipeArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub container_recipe_arn: Option<String>,
#[serde(rename = "distributionConfigurationArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub distribution_configuration_arn: Option<String>,
#[serde(rename = "enhancedImageMetadataEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enhanced_image_metadata_enabled: Option<bool>,
#[serde(rename = "imageRecipeArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_recipe_arn: Option<String>,
#[serde(rename = "imageTestsConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_tests_configuration: Option<ImageTestsConfiguration>,
#[serde(rename = "infrastructureConfigurationArn")]
pub infrastructure_configuration_arn: String,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateImageResponse {
#[serde(rename = "clientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_token: Option<String>,
#[serde(rename = "imageBuildVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_build_version_arn: Option<String>,
#[serde(rename = "requestId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub request_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateInfrastructureConfigurationRequest {
#[serde(rename = "clientToken")]
pub client_token: String,
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "instanceProfileName")]
pub instance_profile_name: String,
#[serde(rename = "instanceTypes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_types: Option<Vec<String>>,
#[serde(rename = "keyPair")]
#[serde(skip_serializing_if = "Option::is_none")]
pub key_pair: Option<String>,
#[serde(rename = "logging")]
#[serde(skip_serializing_if = "Option::is_none")]
pub logging: Option<Logging>,
#[serde(rename = "name")]
pub name: String,
#[serde(rename = "resourceTags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_tags: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "securityGroupIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub security_group_ids: Option<Vec<String>>,
#[serde(rename = "snsTopicArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sns_topic_arn: Option<String>,
#[serde(rename = "subnetId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub subnet_id: Option<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "terminateInstanceOnFailure")]
#[serde(skip_serializing_if = "Option::is_none")]
pub terminate_instance_on_failure: Option<bool>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateInfrastructureConfigurationResponse {
#[serde(rename = "clientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_token: Option<String>,
#[serde(rename = "infrastructureConfigurationArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub infrastructure_configuration_arn: Option<String>,
#[serde(rename = "requestId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub request_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteComponentRequest {
#[serde(rename = "componentBuildVersionArn")]
pub component_build_version_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteComponentResponse {
#[serde(rename = "componentBuildVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub component_build_version_arn: Option<String>,
#[serde(rename = "requestId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub request_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteContainerRecipeRequest {
#[serde(rename = "containerRecipeArn")]
pub container_recipe_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteContainerRecipeResponse {
#[serde(rename = "containerRecipeArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub container_recipe_arn: Option<String>,
#[serde(rename = "requestId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub request_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteDistributionConfigurationRequest {
#[serde(rename = "distributionConfigurationArn")]
pub distribution_configuration_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteDistributionConfigurationResponse {
#[serde(rename = "distributionConfigurationArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub distribution_configuration_arn: Option<String>,
#[serde(rename = "requestId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub request_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteImagePipelineRequest {
#[serde(rename = "imagePipelineArn")]
pub image_pipeline_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteImagePipelineResponse {
#[serde(rename = "imagePipelineArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_pipeline_arn: Option<String>,
#[serde(rename = "requestId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub request_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteImageRecipeRequest {
#[serde(rename = "imageRecipeArn")]
pub image_recipe_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteImageRecipeResponse {
#[serde(rename = "imageRecipeArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_recipe_arn: Option<String>,
#[serde(rename = "requestId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub request_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteImageRequest {
#[serde(rename = "imageBuildVersionArn")]
pub image_build_version_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteImageResponse {
#[serde(rename = "imageBuildVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_build_version_arn: Option<String>,
#[serde(rename = "requestId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub request_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteInfrastructureConfigurationRequest {
#[serde(rename = "infrastructureConfigurationArn")]
pub infrastructure_configuration_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteInfrastructureConfigurationResponse {
#[serde(rename = "infrastructureConfigurationArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub infrastructure_configuration_arn: Option<String>,
#[serde(rename = "requestId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub request_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct Distribution {
#[serde(rename = "amiDistributionConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ami_distribution_configuration: Option<AmiDistributionConfiguration>,
#[serde(rename = "containerDistributionConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub container_distribution_configuration: Option<ContainerDistributionConfiguration>,
#[serde(rename = "licenseConfigurationArns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub license_configuration_arns: Option<Vec<String>>,
#[serde(rename = "region")]
pub region: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DistributionConfiguration {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "dateCreated")]
#[serde(skip_serializing_if = "Option::is_none")]
pub date_created: Option<String>,
#[serde(rename = "dateUpdated")]
#[serde(skip_serializing_if = "Option::is_none")]
pub date_updated: Option<String>,
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "distributions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub distributions: Option<Vec<Distribution>>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "timeoutMinutes")]
pub timeout_minutes: i64,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DistributionConfigurationSummary {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "dateCreated")]
#[serde(skip_serializing_if = "Option::is_none")]
pub date_created: Option<String>,
#[serde(rename = "dateUpdated")]
#[serde(skip_serializing_if = "Option::is_none")]
pub date_updated: Option<String>,
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "regions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub regions: Option<Vec<String>>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct EbsInstanceBlockDeviceSpecification {
#[serde(rename = "deleteOnTermination")]
#[serde(skip_serializing_if = "Option::is_none")]
pub delete_on_termination: Option<bool>,
#[serde(rename = "encrypted")]
#[serde(skip_serializing_if = "Option::is_none")]
pub encrypted: Option<bool>,
#[serde(rename = "iops")]
#[serde(skip_serializing_if = "Option::is_none")]
pub iops: Option<i64>,
#[serde(rename = "kmsKeyId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kms_key_id: Option<String>,
#[serde(rename = "snapshotId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub snapshot_id: Option<String>,
#[serde(rename = "volumeSize")]
#[serde(skip_serializing_if = "Option::is_none")]
pub volume_size: Option<i64>,
#[serde(rename = "volumeType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub volume_type: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct Filter {
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "values")]
#[serde(skip_serializing_if = "Option::is_none")]
pub values: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetComponentPolicyRequest {
#[serde(rename = "componentArn")]
pub component_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetComponentPolicyResponse {
#[serde(rename = "policy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub policy: Option<String>,
#[serde(rename = "requestId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub request_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetComponentRequest {
#[serde(rename = "componentBuildVersionArn")]
pub component_build_version_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetComponentResponse {
#[serde(rename = "component")]
#[serde(skip_serializing_if = "Option::is_none")]
pub component: Option<Component>,
#[serde(rename = "requestId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub request_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetContainerRecipePolicyRequest {
#[serde(rename = "containerRecipeArn")]
pub container_recipe_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetContainerRecipePolicyResponse {
#[serde(rename = "policy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub policy: Option<String>,
#[serde(rename = "requestId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub request_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetContainerRecipeRequest {
#[serde(rename = "containerRecipeArn")]
pub container_recipe_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetContainerRecipeResponse {
#[serde(rename = "containerRecipe")]
#[serde(skip_serializing_if = "Option::is_none")]
pub container_recipe: Option<ContainerRecipe>,
#[serde(rename = "requestId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub request_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetDistributionConfigurationRequest {
#[serde(rename = "distributionConfigurationArn")]
pub distribution_configuration_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetDistributionConfigurationResponse {
#[serde(rename = "distributionConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub distribution_configuration: Option<DistributionConfiguration>,
#[serde(rename = "requestId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub request_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetImagePipelineRequest {
#[serde(rename = "imagePipelineArn")]
pub image_pipeline_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetImagePipelineResponse {
#[serde(rename = "imagePipeline")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_pipeline: Option<ImagePipeline>,
#[serde(rename = "requestId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub request_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetImagePolicyRequest {
#[serde(rename = "imageArn")]
pub image_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetImagePolicyResponse {
#[serde(rename = "policy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub policy: Option<String>,
#[serde(rename = "requestId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub request_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetImageRecipePolicyRequest {
#[serde(rename = "imageRecipeArn")]
pub image_recipe_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetImageRecipePolicyResponse {
#[serde(rename = "policy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub policy: Option<String>,
#[serde(rename = "requestId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub request_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetImageRecipeRequest {
#[serde(rename = "imageRecipeArn")]
pub image_recipe_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetImageRecipeResponse {
#[serde(rename = "imageRecipe")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_recipe: Option<ImageRecipe>,
#[serde(rename = "requestId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub request_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetImageRequest {
#[serde(rename = "imageBuildVersionArn")]
pub image_build_version_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetImageResponse {
#[serde(rename = "image")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image: Option<Image>,
#[serde(rename = "requestId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub request_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetInfrastructureConfigurationRequest {
#[serde(rename = "infrastructureConfigurationArn")]
pub infrastructure_configuration_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetInfrastructureConfigurationResponse {
#[serde(rename = "infrastructureConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub infrastructure_configuration: Option<InfrastructureConfiguration>,
#[serde(rename = "requestId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub request_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Image {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "containerRecipe")]
#[serde(skip_serializing_if = "Option::is_none")]
pub container_recipe: Option<ContainerRecipe>,
#[serde(rename = "dateCreated")]
#[serde(skip_serializing_if = "Option::is_none")]
pub date_created: Option<String>,
#[serde(rename = "distributionConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub distribution_configuration: Option<DistributionConfiguration>,
#[serde(rename = "enhancedImageMetadataEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enhanced_image_metadata_enabled: Option<bool>,
#[serde(rename = "imageRecipe")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_recipe: Option<ImageRecipe>,
#[serde(rename = "imageTestsConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_tests_configuration: Option<ImageTestsConfiguration>,
#[serde(rename = "infrastructureConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub infrastructure_configuration: Option<InfrastructureConfiguration>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "osVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub os_version: Option<String>,
#[serde(rename = "outputResources")]
#[serde(skip_serializing_if = "Option::is_none")]
pub output_resources: Option<OutputResources>,
#[serde(rename = "platform")]
#[serde(skip_serializing_if = "Option::is_none")]
pub platform: Option<String>,
#[serde(rename = "sourcePipelineArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_pipeline_arn: Option<String>,
#[serde(rename = "sourcePipelineName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_pipeline_name: Option<String>,
#[serde(rename = "state")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state: Option<ImageState>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
#[serde(rename = "version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ImagePipeline {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "containerRecipeArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub container_recipe_arn: Option<String>,
#[serde(rename = "dateCreated")]
#[serde(skip_serializing_if = "Option::is_none")]
pub date_created: Option<String>,
#[serde(rename = "dateLastRun")]
#[serde(skip_serializing_if = "Option::is_none")]
pub date_last_run: Option<String>,
#[serde(rename = "dateNextRun")]
#[serde(skip_serializing_if = "Option::is_none")]
pub date_next_run: Option<String>,
#[serde(rename = "dateUpdated")]
#[serde(skip_serializing_if = "Option::is_none")]
pub date_updated: Option<String>,
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "distributionConfigurationArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub distribution_configuration_arn: Option<String>,
#[serde(rename = "enhancedImageMetadataEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enhanced_image_metadata_enabled: Option<bool>,
#[serde(rename = "imageRecipeArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_recipe_arn: Option<String>,
#[serde(rename = "imageTestsConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_tests_configuration: Option<ImageTestsConfiguration>,
#[serde(rename = "infrastructureConfigurationArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub infrastructure_configuration_arn: Option<String>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "platform")]
#[serde(skip_serializing_if = "Option::is_none")]
pub platform: Option<String>,
#[serde(rename = "schedule")]
#[serde(skip_serializing_if = "Option::is_none")]
pub schedule: Option<Schedule>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ImageRecipe {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "blockDeviceMappings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub block_device_mappings: Option<Vec<InstanceBlockDeviceMapping>>,
#[serde(rename = "components")]
#[serde(skip_serializing_if = "Option::is_none")]
pub components: Option<Vec<ComponentConfiguration>>,
#[serde(rename = "dateCreated")]
#[serde(skip_serializing_if = "Option::is_none")]
pub date_created: Option<String>,
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "owner")]
#[serde(skip_serializing_if = "Option::is_none")]
pub owner: Option<String>,
#[serde(rename = "parentImage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub parent_image: Option<String>,
#[serde(rename = "platform")]
#[serde(skip_serializing_if = "Option::is_none")]
pub platform: Option<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
#[serde(rename = "version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
#[serde(rename = "workingDirectory")]
#[serde(skip_serializing_if = "Option::is_none")]
pub working_directory: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ImageRecipeSummary {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "dateCreated")]
#[serde(skip_serializing_if = "Option::is_none")]
pub date_created: Option<String>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "owner")]
#[serde(skip_serializing_if = "Option::is_none")]
pub owner: Option<String>,
#[serde(rename = "parentImage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub parent_image: Option<String>,
#[serde(rename = "platform")]
#[serde(skip_serializing_if = "Option::is_none")]
pub platform: Option<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ImageState {
#[serde(rename = "reason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub reason: Option<String>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ImageSummary {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "dateCreated")]
#[serde(skip_serializing_if = "Option::is_none")]
pub date_created: Option<String>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "osVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub os_version: Option<String>,
#[serde(rename = "outputResources")]
#[serde(skip_serializing_if = "Option::is_none")]
pub output_resources: Option<OutputResources>,
#[serde(rename = "owner")]
#[serde(skip_serializing_if = "Option::is_none")]
pub owner: Option<String>,
#[serde(rename = "platform")]
#[serde(skip_serializing_if = "Option::is_none")]
pub platform: Option<String>,
#[serde(rename = "state")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state: Option<ImageState>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
#[serde(rename = "version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ImageTestsConfiguration {
#[serde(rename = "imageTestsEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_tests_enabled: Option<bool>,
#[serde(rename = "timeoutMinutes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub timeout_minutes: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ImageVersion {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "dateCreated")]
#[serde(skip_serializing_if = "Option::is_none")]
pub date_created: Option<String>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "osVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub os_version: Option<String>,
#[serde(rename = "owner")]
#[serde(skip_serializing_if = "Option::is_none")]
pub owner: Option<String>,
#[serde(rename = "platform")]
#[serde(skip_serializing_if = "Option::is_none")]
pub platform: Option<String>,
#[serde(rename = "type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
#[serde(rename = "version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ImportComponentRequest {
#[serde(rename = "changeDescription")]
#[serde(skip_serializing_if = "Option::is_none")]
pub change_description: Option<String>,
#[serde(rename = "clientToken")]
pub client_token: String,
#[serde(rename = "data")]
#[serde(skip_serializing_if = "Option::is_none")]
pub data: Option<String>,
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "format")]
pub format: String,
#[serde(rename = "kmsKeyId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kms_key_id: Option<String>,
#[serde(rename = "name")]
pub name: String,
#[serde(rename = "platform")]
pub platform: String,
#[serde(rename = "semanticVersion")]
pub semantic_version: String,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "type")]
pub type_: String,
#[serde(rename = "uri")]
#[serde(skip_serializing_if = "Option::is_none")]
pub uri: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ImportComponentResponse {
#[serde(rename = "clientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_token: Option<String>,
#[serde(rename = "componentBuildVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub component_build_version_arn: Option<String>,
#[serde(rename = "requestId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub request_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct InfrastructureConfiguration {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "dateCreated")]
#[serde(skip_serializing_if = "Option::is_none")]
pub date_created: Option<String>,
#[serde(rename = "dateUpdated")]
#[serde(skip_serializing_if = "Option::is_none")]
pub date_updated: Option<String>,
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "instanceProfileName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_profile_name: Option<String>,
#[serde(rename = "instanceTypes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_types: Option<Vec<String>>,
#[serde(rename = "keyPair")]
#[serde(skip_serializing_if = "Option::is_none")]
pub key_pair: Option<String>,
#[serde(rename = "logging")]
#[serde(skip_serializing_if = "Option::is_none")]
pub logging: Option<Logging>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "resourceTags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_tags: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "securityGroupIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub security_group_ids: Option<Vec<String>>,
#[serde(rename = "snsTopicArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sns_topic_arn: Option<String>,
#[serde(rename = "subnetId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub subnet_id: Option<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "terminateInstanceOnFailure")]
#[serde(skip_serializing_if = "Option::is_none")]
pub terminate_instance_on_failure: Option<bool>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct InfrastructureConfigurationSummary {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "dateCreated")]
#[serde(skip_serializing_if = "Option::is_none")]
pub date_created: Option<String>,
#[serde(rename = "dateUpdated")]
#[serde(skip_serializing_if = "Option::is_none")]
pub date_updated: Option<String>,
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "resourceTags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_tags: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct InstanceBlockDeviceMapping {
#[serde(rename = "deviceName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub device_name: Option<String>,
#[serde(rename = "ebs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ebs: Option<EbsInstanceBlockDeviceSpecification>,
#[serde(rename = "noDevice")]
#[serde(skip_serializing_if = "Option::is_none")]
pub no_device: Option<String>,
#[serde(rename = "virtualName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub virtual_name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct LaunchPermissionConfiguration {
#[serde(rename = "userGroups")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_groups: Option<Vec<String>>,
#[serde(rename = "userIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_ids: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListComponentBuildVersionsRequest {
#[serde(rename = "componentVersionArn")]
pub component_version_arn: String,
#[serde(rename = "maxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListComponentBuildVersionsResponse {
#[serde(rename = "componentSummaryList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub component_summary_list: Option<Vec<ComponentSummary>>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "requestId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub request_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListComponentsRequest {
#[serde(rename = "byName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub by_name: Option<bool>,
#[serde(rename = "filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<Vec<Filter>>,
#[serde(rename = "maxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "owner")]
#[serde(skip_serializing_if = "Option::is_none")]
pub owner: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListComponentsResponse {
#[serde(rename = "componentVersionList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub component_version_list: Option<Vec<ComponentVersion>>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "requestId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub request_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListContainerRecipesRequest {
#[serde(rename = "filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<Vec<Filter>>,
#[serde(rename = "maxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "owner")]
#[serde(skip_serializing_if = "Option::is_none")]
pub owner: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListContainerRecipesResponse {
#[serde(rename = "containerRecipeSummaryList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub container_recipe_summary_list: Option<Vec<ContainerRecipeSummary>>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "requestId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub request_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListDistributionConfigurationsRequest {
#[serde(rename = "filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<Vec<Filter>>,
#[serde(rename = "maxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListDistributionConfigurationsResponse {
#[serde(rename = "distributionConfigurationSummaryList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub distribution_configuration_summary_list: Option<Vec<DistributionConfigurationSummary>>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "requestId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub request_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListImageBuildVersionsRequest {
#[serde(rename = "filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<Vec<Filter>>,
#[serde(rename = "imageVersionArn")]
pub image_version_arn: String,
#[serde(rename = "maxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListImageBuildVersionsResponse {
#[serde(rename = "imageSummaryList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_summary_list: Option<Vec<ImageSummary>>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "requestId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub request_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListImagePipelineImagesRequest {
#[serde(rename = "filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<Vec<Filter>>,
#[serde(rename = "imagePipelineArn")]
pub image_pipeline_arn: String,
#[serde(rename = "maxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListImagePipelineImagesResponse {
#[serde(rename = "imageSummaryList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_summary_list: Option<Vec<ImageSummary>>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "requestId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub request_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListImagePipelinesRequest {
#[serde(rename = "filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<Vec<Filter>>,
#[serde(rename = "maxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListImagePipelinesResponse {
#[serde(rename = "imagePipelineList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_pipeline_list: Option<Vec<ImagePipeline>>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "requestId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub request_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListImageRecipesRequest {
#[serde(rename = "filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<Vec<Filter>>,
#[serde(rename = "maxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "owner")]
#[serde(skip_serializing_if = "Option::is_none")]
pub owner: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListImageRecipesResponse {
#[serde(rename = "imageRecipeSummaryList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_recipe_summary_list: Option<Vec<ImageRecipeSummary>>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "requestId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub request_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListImagesRequest {
#[serde(rename = "byName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub by_name: Option<bool>,
#[serde(rename = "filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<Vec<Filter>>,
#[serde(rename = "includeDeprecated")]
#[serde(skip_serializing_if = "Option::is_none")]
pub include_deprecated: Option<bool>,
#[serde(rename = "maxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "owner")]
#[serde(skip_serializing_if = "Option::is_none")]
pub owner: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListImagesResponse {
#[serde(rename = "imageVersionList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_version_list: Option<Vec<ImageVersion>>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "requestId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub request_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListInfrastructureConfigurationsRequest {
#[serde(rename = "filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<Vec<Filter>>,
#[serde(rename = "maxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListInfrastructureConfigurationsResponse {
#[serde(rename = "infrastructureConfigurationSummaryList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub infrastructure_configuration_summary_list: Option<Vec<InfrastructureConfigurationSummary>>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "requestId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub request_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListTagsForResourceRequest {
#[serde(rename = "resourceArn")]
pub resource_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[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<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct Logging {
#[serde(rename = "s3Logs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub s_3_logs: Option<S3Logs>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct OutputResources {
#[serde(rename = "amis")]
#[serde(skip_serializing_if = "Option::is_none")]
pub amis: Option<Vec<Ami>>,
#[serde(rename = "containers")]
#[serde(skip_serializing_if = "Option::is_none")]
pub containers: Option<Vec<Container>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PutComponentPolicyRequest {
#[serde(rename = "componentArn")]
pub component_arn: String,
#[serde(rename = "policy")]
pub policy: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PutComponentPolicyResponse {
#[serde(rename = "componentArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub component_arn: Option<String>,
#[serde(rename = "requestId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub request_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PutContainerRecipePolicyRequest {
#[serde(rename = "containerRecipeArn")]
pub container_recipe_arn: String,
#[serde(rename = "policy")]
pub policy: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PutContainerRecipePolicyResponse {
#[serde(rename = "containerRecipeArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub container_recipe_arn: Option<String>,
#[serde(rename = "requestId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub request_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PutImagePolicyRequest {
#[serde(rename = "imageArn")]
pub image_arn: String,
#[serde(rename = "policy")]
pub policy: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PutImagePolicyResponse {
#[serde(rename = "imageArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_arn: Option<String>,
#[serde(rename = "requestId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub request_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PutImageRecipePolicyRequest {
#[serde(rename = "imageRecipeArn")]
pub image_recipe_arn: String,
#[serde(rename = "policy")]
pub policy: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PutImageRecipePolicyResponse {
#[serde(rename = "imageRecipeArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_recipe_arn: Option<String>,
#[serde(rename = "requestId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub request_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct S3Logs {
#[serde(rename = "s3BucketName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub s_3_bucket_name: Option<String>,
#[serde(rename = "s3KeyPrefix")]
#[serde(skip_serializing_if = "Option::is_none")]
pub s_3_key_prefix: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct Schedule {
#[serde(rename = "pipelineExecutionStartCondition")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pipeline_execution_start_condition: Option<String>,
#[serde(rename = "scheduleExpression")]
#[serde(skip_serializing_if = "Option::is_none")]
pub schedule_expression: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StartImagePipelineExecutionRequest {
#[serde(rename = "clientToken")]
pub client_token: String,
#[serde(rename = "imagePipelineArn")]
pub image_pipeline_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct StartImagePipelineExecutionResponse {
#[serde(rename = "clientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_token: Option<String>,
#[serde(rename = "imageBuildVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_build_version_arn: Option<String>,
#[serde(rename = "requestId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub request_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct TagResourceRequest {
#[serde(rename = "resourceArn")]
pub resource_arn: String,
#[serde(rename = "tags")]
pub tags: ::std::collections::HashMap<String, String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct TagResourceResponse {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct TargetContainerRepository {
#[serde(rename = "repositoryName")]
pub repository_name: String,
#[serde(rename = "service")]
pub service: String,
}
#[derive(Clone, Debug, Default, 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(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UntagResourceResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateDistributionConfigurationRequest {
#[serde(rename = "clientToken")]
pub client_token: String,
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "distributionConfigurationArn")]
pub distribution_configuration_arn: String,
#[serde(rename = "distributions")]
pub distributions: Vec<Distribution>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateDistributionConfigurationResponse {
#[serde(rename = "clientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_token: Option<String>,
#[serde(rename = "distributionConfigurationArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub distribution_configuration_arn: Option<String>,
#[serde(rename = "requestId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub request_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateImagePipelineRequest {
#[serde(rename = "clientToken")]
pub client_token: String,
#[serde(rename = "containerRecipeArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub container_recipe_arn: Option<String>,
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "distributionConfigurationArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub distribution_configuration_arn: Option<String>,
#[serde(rename = "enhancedImageMetadataEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enhanced_image_metadata_enabled: Option<bool>,
#[serde(rename = "imagePipelineArn")]
pub image_pipeline_arn: String,
#[serde(rename = "imageRecipeArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_recipe_arn: Option<String>,
#[serde(rename = "imageTestsConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_tests_configuration: Option<ImageTestsConfiguration>,
#[serde(rename = "infrastructureConfigurationArn")]
pub infrastructure_configuration_arn: String,
#[serde(rename = "schedule")]
#[serde(skip_serializing_if = "Option::is_none")]
pub schedule: Option<Schedule>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateImagePipelineResponse {
#[serde(rename = "clientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_token: Option<String>,
#[serde(rename = "imagePipelineArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_pipeline_arn: Option<String>,
#[serde(rename = "requestId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub request_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateInfrastructureConfigurationRequest {
#[serde(rename = "clientToken")]
pub client_token: String,
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "infrastructureConfigurationArn")]
pub infrastructure_configuration_arn: String,
#[serde(rename = "instanceProfileName")]
pub instance_profile_name: String,
#[serde(rename = "instanceTypes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_types: Option<Vec<String>>,
#[serde(rename = "keyPair")]
#[serde(skip_serializing_if = "Option::is_none")]
pub key_pair: Option<String>,
#[serde(rename = "logging")]
#[serde(skip_serializing_if = "Option::is_none")]
pub logging: Option<Logging>,
#[serde(rename = "resourceTags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_tags: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "securityGroupIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub security_group_ids: Option<Vec<String>>,
#[serde(rename = "snsTopicArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sns_topic_arn: Option<String>,
#[serde(rename = "subnetId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub subnet_id: Option<String>,
#[serde(rename = "terminateInstanceOnFailure")]
#[serde(skip_serializing_if = "Option::is_none")]
pub terminate_instance_on_failure: Option<bool>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateInfrastructureConfigurationResponse {
#[serde(rename = "clientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_token: Option<String>,
#[serde(rename = "infrastructureConfigurationArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub infrastructure_configuration_arn: Option<String>,
#[serde(rename = "requestId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub request_id: Option<String>,
}
#[derive(Debug, PartialEq)]
pub enum CancelImageCreationError {
CallRateLimitExceeded(String),
Client(String),
Forbidden(String),
IdempotentParameterMismatch(String),
InvalidRequest(String),
ResourceInUse(String),
Service(String),
ServiceUnavailable(String),
}
impl CancelImageCreationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CancelImageCreationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"CallRateLimitExceededException" => {
return RusotoError::Service(CancelImageCreationError::CallRateLimitExceeded(
err.msg,
))
}
"ClientException" => {
return RusotoError::Service(CancelImageCreationError::Client(err.msg))
}
"ForbiddenException" => {
return RusotoError::Service(CancelImageCreationError::Forbidden(err.msg))
}
"IdempotentParameterMismatchException" => {
return RusotoError::Service(
CancelImageCreationError::IdempotentParameterMismatch(err.msg),
)
}
"InvalidRequestException" => {
return RusotoError::Service(CancelImageCreationError::InvalidRequest(err.msg))
}
"ResourceInUseException" => {
return RusotoError::Service(CancelImageCreationError::ResourceInUse(err.msg))
}
"ServiceException" => {
return RusotoError::Service(CancelImageCreationError::Service(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(CancelImageCreationError::ServiceUnavailable(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CancelImageCreationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CancelImageCreationError::CallRateLimitExceeded(ref cause) => write!(f, "{}", cause),
CancelImageCreationError::Client(ref cause) => write!(f, "{}", cause),
CancelImageCreationError::Forbidden(ref cause) => write!(f, "{}", cause),
CancelImageCreationError::IdempotentParameterMismatch(ref cause) => {
write!(f, "{}", cause)
}
CancelImageCreationError::InvalidRequest(ref cause) => write!(f, "{}", cause),
CancelImageCreationError::ResourceInUse(ref cause) => write!(f, "{}", cause),
CancelImageCreationError::Service(ref cause) => write!(f, "{}", cause),
CancelImageCreationError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CancelImageCreationError {}
#[derive(Debug, PartialEq)]
pub enum CreateComponentError {
CallRateLimitExceeded(String),
Client(String),
Forbidden(String),
IdempotentParameterMismatch(String),
InvalidParameterCombination(String),
InvalidRequest(String),
InvalidVersionNumber(String),
ResourceInUse(String),
Service(String),
ServiceQuotaExceeded(String),
ServiceUnavailable(String),
}
impl CreateComponentError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateComponentError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"CallRateLimitExceededException" => {
return RusotoError::Service(CreateComponentError::CallRateLimitExceeded(
err.msg,
))
}
"ClientException" => {
return RusotoError::Service(CreateComponentError::Client(err.msg))
}
"ForbiddenException" => {
return RusotoError::Service(CreateComponentError::Forbidden(err.msg))
}
"IdempotentParameterMismatchException" => {
return RusotoError::Service(CreateComponentError::IdempotentParameterMismatch(
err.msg,
))
}
"InvalidParameterCombinationException" => {
return RusotoError::Service(CreateComponentError::InvalidParameterCombination(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(CreateComponentError::InvalidRequest(err.msg))
}
"InvalidVersionNumberException" => {
return RusotoError::Service(CreateComponentError::InvalidVersionNumber(
err.msg,
))
}
"ResourceInUseException" => {
return RusotoError::Service(CreateComponentError::ResourceInUse(err.msg))
}
"ServiceException" => {
return RusotoError::Service(CreateComponentError::Service(err.msg))
}
"ServiceQuotaExceededException" => {
return RusotoError::Service(CreateComponentError::ServiceQuotaExceeded(
err.msg,
))
}
"ServiceUnavailableException" => {
return RusotoError::Service(CreateComponentError::ServiceUnavailable(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateComponentError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateComponentError::CallRateLimitExceeded(ref cause) => write!(f, "{}", cause),
CreateComponentError::Client(ref cause) => write!(f, "{}", cause),
CreateComponentError::Forbidden(ref cause) => write!(f, "{}", cause),
CreateComponentError::IdempotentParameterMismatch(ref cause) => write!(f, "{}", cause),
CreateComponentError::InvalidParameterCombination(ref cause) => write!(f, "{}", cause),
CreateComponentError::InvalidRequest(ref cause) => write!(f, "{}", cause),
CreateComponentError::InvalidVersionNumber(ref cause) => write!(f, "{}", cause),
CreateComponentError::ResourceInUse(ref cause) => write!(f, "{}", cause),
CreateComponentError::Service(ref cause) => write!(f, "{}", cause),
CreateComponentError::ServiceQuotaExceeded(ref cause) => write!(f, "{}", cause),
CreateComponentError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateComponentError {}
#[derive(Debug, PartialEq)]
pub enum CreateContainerRecipeError {
CallRateLimitExceeded(String),
Client(String),
Forbidden(String),
IdempotentParameterMismatch(String),
InvalidRequest(String),
InvalidVersionNumber(String),
ResourceAlreadyExists(String),
ResourceInUse(String),
Service(String),
ServiceQuotaExceeded(String),
ServiceUnavailable(String),
}
impl CreateContainerRecipeError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateContainerRecipeError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"CallRateLimitExceededException" => {
return RusotoError::Service(CreateContainerRecipeError::CallRateLimitExceeded(
err.msg,
))
}
"ClientException" => {
return RusotoError::Service(CreateContainerRecipeError::Client(err.msg))
}
"ForbiddenException" => {
return RusotoError::Service(CreateContainerRecipeError::Forbidden(err.msg))
}
"IdempotentParameterMismatchException" => {
return RusotoError::Service(
CreateContainerRecipeError::IdempotentParameterMismatch(err.msg),
)
}
"InvalidRequestException" => {
return RusotoError::Service(CreateContainerRecipeError::InvalidRequest(
err.msg,
))
}
"InvalidVersionNumberException" => {
return RusotoError::Service(CreateContainerRecipeError::InvalidVersionNumber(
err.msg,
))
}
"ResourceAlreadyExistsException" => {
return RusotoError::Service(CreateContainerRecipeError::ResourceAlreadyExists(
err.msg,
))
}
"ResourceInUseException" => {
return RusotoError::Service(CreateContainerRecipeError::ResourceInUse(err.msg))
}
"ServiceException" => {
return RusotoError::Service(CreateContainerRecipeError::Service(err.msg))
}
"ServiceQuotaExceededException" => {
return RusotoError::Service(CreateContainerRecipeError::ServiceQuotaExceeded(
err.msg,
))
}
"ServiceUnavailableException" => {
return RusotoError::Service(CreateContainerRecipeError::ServiceUnavailable(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateContainerRecipeError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateContainerRecipeError::CallRateLimitExceeded(ref cause) => write!(f, "{}", cause),
CreateContainerRecipeError::Client(ref cause) => write!(f, "{}", cause),
CreateContainerRecipeError::Forbidden(ref cause) => write!(f, "{}", cause),
CreateContainerRecipeError::IdempotentParameterMismatch(ref cause) => {
write!(f, "{}", cause)
}
CreateContainerRecipeError::InvalidRequest(ref cause) => write!(f, "{}", cause),
CreateContainerRecipeError::InvalidVersionNumber(ref cause) => write!(f, "{}", cause),
CreateContainerRecipeError::ResourceAlreadyExists(ref cause) => write!(f, "{}", cause),
CreateContainerRecipeError::ResourceInUse(ref cause) => write!(f, "{}", cause),
CreateContainerRecipeError::Service(ref cause) => write!(f, "{}", cause),
CreateContainerRecipeError::ServiceQuotaExceeded(ref cause) => write!(f, "{}", cause),
CreateContainerRecipeError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateContainerRecipeError {}
#[derive(Debug, PartialEq)]
pub enum CreateDistributionConfigurationError {
CallRateLimitExceeded(String),
Client(String),
Forbidden(String),
IdempotentParameterMismatch(String),
InvalidParameterCombination(String),
InvalidRequest(String),
ResourceAlreadyExists(String),
ResourceInUse(String),
Service(String),
ServiceQuotaExceeded(String),
ServiceUnavailable(String),
}
impl CreateDistributionConfigurationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<CreateDistributionConfigurationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"CallRateLimitExceededException" => {
return RusotoError::Service(
CreateDistributionConfigurationError::CallRateLimitExceeded(err.msg),
)
}
"ClientException" => {
return RusotoError::Service(CreateDistributionConfigurationError::Client(
err.msg,
))
}
"ForbiddenException" => {
return RusotoError::Service(CreateDistributionConfigurationError::Forbidden(
err.msg,
))
}
"IdempotentParameterMismatchException" => {
return RusotoError::Service(
CreateDistributionConfigurationError::IdempotentParameterMismatch(err.msg),
)
}
"InvalidParameterCombinationException" => {
return RusotoError::Service(
CreateDistributionConfigurationError::InvalidParameterCombination(err.msg),
)
}
"InvalidRequestException" => {
return RusotoError::Service(
CreateDistributionConfigurationError::InvalidRequest(err.msg),
)
}
"ResourceAlreadyExistsException" => {
return RusotoError::Service(
CreateDistributionConfigurationError::ResourceAlreadyExists(err.msg),
)
}
"ResourceInUseException" => {
return RusotoError::Service(
CreateDistributionConfigurationError::ResourceInUse(err.msg),
)
}
"ServiceException" => {
return RusotoError::Service(CreateDistributionConfigurationError::Service(
err.msg,
))
}
"ServiceQuotaExceededException" => {
return RusotoError::Service(
CreateDistributionConfigurationError::ServiceQuotaExceeded(err.msg),
)
}
"ServiceUnavailableException" => {
return RusotoError::Service(
CreateDistributionConfigurationError::ServiceUnavailable(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateDistributionConfigurationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateDistributionConfigurationError::CallRateLimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
CreateDistributionConfigurationError::Client(ref cause) => write!(f, "{}", cause),
CreateDistributionConfigurationError::Forbidden(ref cause) => write!(f, "{}", cause),
CreateDistributionConfigurationError::IdempotentParameterMismatch(ref cause) => {
write!(f, "{}", cause)
}
CreateDistributionConfigurationError::InvalidParameterCombination(ref cause) => {
write!(f, "{}", cause)
}
CreateDistributionConfigurationError::InvalidRequest(ref cause) => {
write!(f, "{}", cause)
}
CreateDistributionConfigurationError::ResourceAlreadyExists(ref cause) => {
write!(f, "{}", cause)
}
CreateDistributionConfigurationError::ResourceInUse(ref cause) => {
write!(f, "{}", cause)
}
CreateDistributionConfigurationError::Service(ref cause) => write!(f, "{}", cause),
CreateDistributionConfigurationError::ServiceQuotaExceeded(ref cause) => {
write!(f, "{}", cause)
}
CreateDistributionConfigurationError::ServiceUnavailable(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for CreateDistributionConfigurationError {}
#[derive(Debug, PartialEq)]
pub enum CreateImageError {
CallRateLimitExceeded(String),
Client(String),
Forbidden(String),
IdempotentParameterMismatch(String),
InvalidRequest(String),
ResourceInUse(String),
Service(String),
ServiceQuotaExceeded(String),
ServiceUnavailable(String),
}
impl CreateImageError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateImageError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"CallRateLimitExceededException" => {
return RusotoError::Service(CreateImageError::CallRateLimitExceeded(err.msg))
}
"ClientException" => {
return RusotoError::Service(CreateImageError::Client(err.msg))
}
"ForbiddenException" => {
return RusotoError::Service(CreateImageError::Forbidden(err.msg))
}
"IdempotentParameterMismatchException" => {
return RusotoError::Service(CreateImageError::IdempotentParameterMismatch(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(CreateImageError::InvalidRequest(err.msg))
}
"ResourceInUseException" => {
return RusotoError::Service(CreateImageError::ResourceInUse(err.msg))
}
"ServiceException" => {
return RusotoError::Service(CreateImageError::Service(err.msg))
}
"ServiceQuotaExceededException" => {
return RusotoError::Service(CreateImageError::ServiceQuotaExceeded(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(CreateImageError::ServiceUnavailable(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateImageError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateImageError::CallRateLimitExceeded(ref cause) => write!(f, "{}", cause),
CreateImageError::Client(ref cause) => write!(f, "{}", cause),
CreateImageError::Forbidden(ref cause) => write!(f, "{}", cause),
CreateImageError::IdempotentParameterMismatch(ref cause) => write!(f, "{}", cause),
CreateImageError::InvalidRequest(ref cause) => write!(f, "{}", cause),
CreateImageError::ResourceInUse(ref cause) => write!(f, "{}", cause),
CreateImageError::Service(ref cause) => write!(f, "{}", cause),
CreateImageError::ServiceQuotaExceeded(ref cause) => write!(f, "{}", cause),
CreateImageError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateImageError {}
#[derive(Debug, PartialEq)]
pub enum CreateImagePipelineError {
CallRateLimitExceeded(String),
Client(String),
Forbidden(String),
IdempotentParameterMismatch(String),
InvalidRequest(String),
ResourceAlreadyExists(String),
ResourceInUse(String),
Service(String),
ServiceQuotaExceeded(String),
ServiceUnavailable(String),
}
impl CreateImagePipelineError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateImagePipelineError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"CallRateLimitExceededException" => {
return RusotoError::Service(CreateImagePipelineError::CallRateLimitExceeded(
err.msg,
))
}
"ClientException" => {
return RusotoError::Service(CreateImagePipelineError::Client(err.msg))
}
"ForbiddenException" => {
return RusotoError::Service(CreateImagePipelineError::Forbidden(err.msg))
}
"IdempotentParameterMismatchException" => {
return RusotoError::Service(
CreateImagePipelineError::IdempotentParameterMismatch(err.msg),
)
}
"InvalidRequestException" => {
return RusotoError::Service(CreateImagePipelineError::InvalidRequest(err.msg))
}
"ResourceAlreadyExistsException" => {
return RusotoError::Service(CreateImagePipelineError::ResourceAlreadyExists(
err.msg,
))
}
"ResourceInUseException" => {
return RusotoError::Service(CreateImagePipelineError::ResourceInUse(err.msg))
}
"ServiceException" => {
return RusotoError::Service(CreateImagePipelineError::Service(err.msg))
}
"ServiceQuotaExceededException" => {
return RusotoError::Service(CreateImagePipelineError::ServiceQuotaExceeded(
err.msg,
))
}
"ServiceUnavailableException" => {
return RusotoError::Service(CreateImagePipelineError::ServiceUnavailable(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateImagePipelineError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateImagePipelineError::CallRateLimitExceeded(ref cause) => write!(f, "{}", cause),
CreateImagePipelineError::Client(ref cause) => write!(f, "{}", cause),
CreateImagePipelineError::Forbidden(ref cause) => write!(f, "{}", cause),
CreateImagePipelineError::IdempotentParameterMismatch(ref cause) => {
write!(f, "{}", cause)
}
CreateImagePipelineError::InvalidRequest(ref cause) => write!(f, "{}", cause),
CreateImagePipelineError::ResourceAlreadyExists(ref cause) => write!(f, "{}", cause),
CreateImagePipelineError::ResourceInUse(ref cause) => write!(f, "{}", cause),
CreateImagePipelineError::Service(ref cause) => write!(f, "{}", cause),
CreateImagePipelineError::ServiceQuotaExceeded(ref cause) => write!(f, "{}", cause),
CreateImagePipelineError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateImagePipelineError {}
#[derive(Debug, PartialEq)]
pub enum CreateImageRecipeError {
CallRateLimitExceeded(String),
Client(String),
Forbidden(String),
IdempotentParameterMismatch(String),
InvalidRequest(String),
InvalidVersionNumber(String),
ResourceAlreadyExists(String),
ResourceInUse(String),
Service(String),
ServiceQuotaExceeded(String),
ServiceUnavailable(String),
}
impl CreateImageRecipeError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateImageRecipeError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"CallRateLimitExceededException" => {
return RusotoError::Service(CreateImageRecipeError::CallRateLimitExceeded(
err.msg,
))
}
"ClientException" => {
return RusotoError::Service(CreateImageRecipeError::Client(err.msg))
}
"ForbiddenException" => {
return RusotoError::Service(CreateImageRecipeError::Forbidden(err.msg))
}
"IdempotentParameterMismatchException" => {
return RusotoError::Service(
CreateImageRecipeError::IdempotentParameterMismatch(err.msg),
)
}
"InvalidRequestException" => {
return RusotoError::Service(CreateImageRecipeError::InvalidRequest(err.msg))
}
"InvalidVersionNumberException" => {
return RusotoError::Service(CreateImageRecipeError::InvalidVersionNumber(
err.msg,
))
}
"ResourceAlreadyExistsException" => {
return RusotoError::Service(CreateImageRecipeError::ResourceAlreadyExists(
err.msg,
))
}
"ResourceInUseException" => {
return RusotoError::Service(CreateImageRecipeError::ResourceInUse(err.msg))
}
"ServiceException" => {
return RusotoError::Service(CreateImageRecipeError::Service(err.msg))
}
"ServiceQuotaExceededException" => {
return RusotoError::Service(CreateImageRecipeError::ServiceQuotaExceeded(
err.msg,
))
}
"ServiceUnavailableException" => {
return RusotoError::Service(CreateImageRecipeError::ServiceUnavailable(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateImageRecipeError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateImageRecipeError::CallRateLimitExceeded(ref cause) => write!(f, "{}", cause),
CreateImageRecipeError::Client(ref cause) => write!(f, "{}", cause),
CreateImageRecipeError::Forbidden(ref cause) => write!(f, "{}", cause),
CreateImageRecipeError::IdempotentParameterMismatch(ref cause) => {
write!(f, "{}", cause)
}
CreateImageRecipeError::InvalidRequest(ref cause) => write!(f, "{}", cause),
CreateImageRecipeError::InvalidVersionNumber(ref cause) => write!(f, "{}", cause),
CreateImageRecipeError::ResourceAlreadyExists(ref cause) => write!(f, "{}", cause),
CreateImageRecipeError::ResourceInUse(ref cause) => write!(f, "{}", cause),
CreateImageRecipeError::Service(ref cause) => write!(f, "{}", cause),
CreateImageRecipeError::ServiceQuotaExceeded(ref cause) => write!(f, "{}", cause),
CreateImageRecipeError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateImageRecipeError {}
#[derive(Debug, PartialEq)]
pub enum CreateInfrastructureConfigurationError {
CallRateLimitExceeded(String),
Client(String),
Forbidden(String),
IdempotentParameterMismatch(String),
InvalidRequest(String),
ResourceAlreadyExists(String),
ResourceInUse(String),
Service(String),
ServiceQuotaExceeded(String),
ServiceUnavailable(String),
}
impl CreateInfrastructureConfigurationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<CreateInfrastructureConfigurationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"CallRateLimitExceededException" => {
return RusotoError::Service(
CreateInfrastructureConfigurationError::CallRateLimitExceeded(err.msg),
)
}
"ClientException" => {
return RusotoError::Service(CreateInfrastructureConfigurationError::Client(
err.msg,
))
}
"ForbiddenException" => {
return RusotoError::Service(CreateInfrastructureConfigurationError::Forbidden(
err.msg,
))
}
"IdempotentParameterMismatchException" => {
return RusotoError::Service(
CreateInfrastructureConfigurationError::IdempotentParameterMismatch(
err.msg,
),
)
}
"InvalidRequestException" => {
return RusotoError::Service(
CreateInfrastructureConfigurationError::InvalidRequest(err.msg),
)
}
"ResourceAlreadyExistsException" => {
return RusotoError::Service(
CreateInfrastructureConfigurationError::ResourceAlreadyExists(err.msg),
)
}
"ResourceInUseException" => {
return RusotoError::Service(
CreateInfrastructureConfigurationError::ResourceInUse(err.msg),
)
}
"ServiceException" => {
return RusotoError::Service(CreateInfrastructureConfigurationError::Service(
err.msg,
))
}
"ServiceQuotaExceededException" => {
return RusotoError::Service(
CreateInfrastructureConfigurationError::ServiceQuotaExceeded(err.msg),
)
}
"ServiceUnavailableException" => {
return RusotoError::Service(
CreateInfrastructureConfigurationError::ServiceUnavailable(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateInfrastructureConfigurationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateInfrastructureConfigurationError::CallRateLimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
CreateInfrastructureConfigurationError::Client(ref cause) => write!(f, "{}", cause),
CreateInfrastructureConfigurationError::Forbidden(ref cause) => write!(f, "{}", cause),
CreateInfrastructureConfigurationError::IdempotentParameterMismatch(ref cause) => {
write!(f, "{}", cause)
}
CreateInfrastructureConfigurationError::InvalidRequest(ref cause) => {
write!(f, "{}", cause)
}
CreateInfrastructureConfigurationError::ResourceAlreadyExists(ref cause) => {
write!(f, "{}", cause)
}
CreateInfrastructureConfigurationError::ResourceInUse(ref cause) => {
write!(f, "{}", cause)
}
CreateInfrastructureConfigurationError::Service(ref cause) => write!(f, "{}", cause),
CreateInfrastructureConfigurationError::ServiceQuotaExceeded(ref cause) => {
write!(f, "{}", cause)
}
CreateInfrastructureConfigurationError::ServiceUnavailable(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for CreateInfrastructureConfigurationError {}
#[derive(Debug, PartialEq)]
pub enum DeleteComponentError {
CallRateLimitExceeded(String),
Client(String),
Forbidden(String),
InvalidRequest(String),
ResourceDependency(String),
Service(String),
ServiceUnavailable(String),
}
impl DeleteComponentError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteComponentError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"CallRateLimitExceededException" => {
return RusotoError::Service(DeleteComponentError::CallRateLimitExceeded(
err.msg,
))
}
"ClientException" => {
return RusotoError::Service(DeleteComponentError::Client(err.msg))
}
"ForbiddenException" => {
return RusotoError::Service(DeleteComponentError::Forbidden(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(DeleteComponentError::InvalidRequest(err.msg))
}
"ResourceDependencyException" => {
return RusotoError::Service(DeleteComponentError::ResourceDependency(err.msg))
}
"ServiceException" => {
return RusotoError::Service(DeleteComponentError::Service(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(DeleteComponentError::ServiceUnavailable(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteComponentError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteComponentError::CallRateLimitExceeded(ref cause) => write!(f, "{}", cause),
DeleteComponentError::Client(ref cause) => write!(f, "{}", cause),
DeleteComponentError::Forbidden(ref cause) => write!(f, "{}", cause),
DeleteComponentError::InvalidRequest(ref cause) => write!(f, "{}", cause),
DeleteComponentError::ResourceDependency(ref cause) => write!(f, "{}", cause),
DeleteComponentError::Service(ref cause) => write!(f, "{}", cause),
DeleteComponentError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteComponentError {}
#[derive(Debug, PartialEq)]
pub enum DeleteContainerRecipeError {
CallRateLimitExceeded(String),
Client(String),
Forbidden(String),
InvalidRequest(String),
ResourceDependency(String),
Service(String),
ServiceUnavailable(String),
}
impl DeleteContainerRecipeError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteContainerRecipeError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"CallRateLimitExceededException" => {
return RusotoError::Service(DeleteContainerRecipeError::CallRateLimitExceeded(
err.msg,
))
}
"ClientException" => {
return RusotoError::Service(DeleteContainerRecipeError::Client(err.msg))
}
"ForbiddenException" => {
return RusotoError::Service(DeleteContainerRecipeError::Forbidden(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(DeleteContainerRecipeError::InvalidRequest(
err.msg,
))
}
"ResourceDependencyException" => {
return RusotoError::Service(DeleteContainerRecipeError::ResourceDependency(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(DeleteContainerRecipeError::Service(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(DeleteContainerRecipeError::ServiceUnavailable(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteContainerRecipeError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteContainerRecipeError::CallRateLimitExceeded(ref cause) => write!(f, "{}", cause),
DeleteContainerRecipeError::Client(ref cause) => write!(f, "{}", cause),
DeleteContainerRecipeError::Forbidden(ref cause) => write!(f, "{}", cause),
DeleteContainerRecipeError::InvalidRequest(ref cause) => write!(f, "{}", cause),
DeleteContainerRecipeError::ResourceDependency(ref cause) => write!(f, "{}", cause),
DeleteContainerRecipeError::Service(ref cause) => write!(f, "{}", cause),
DeleteContainerRecipeError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteContainerRecipeError {}
#[derive(Debug, PartialEq)]
pub enum DeleteDistributionConfigurationError {
CallRateLimitExceeded(String),
Client(String),
Forbidden(String),
InvalidRequest(String),
ResourceDependency(String),
Service(String),
ServiceUnavailable(String),
}
impl DeleteDistributionConfigurationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DeleteDistributionConfigurationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"CallRateLimitExceededException" => {
return RusotoError::Service(
DeleteDistributionConfigurationError::CallRateLimitExceeded(err.msg),
)
}
"ClientException" => {
return RusotoError::Service(DeleteDistributionConfigurationError::Client(
err.msg,
))
}
"ForbiddenException" => {
return RusotoError::Service(DeleteDistributionConfigurationError::Forbidden(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(
DeleteDistributionConfigurationError::InvalidRequest(err.msg),
)
}
"ResourceDependencyException" => {
return RusotoError::Service(
DeleteDistributionConfigurationError::ResourceDependency(err.msg),
)
}
"ServiceException" => {
return RusotoError::Service(DeleteDistributionConfigurationError::Service(
err.msg,
))
}
"ServiceUnavailableException" => {
return RusotoError::Service(
DeleteDistributionConfigurationError::ServiceUnavailable(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteDistributionConfigurationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteDistributionConfigurationError::CallRateLimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
DeleteDistributionConfigurationError::Client(ref cause) => write!(f, "{}", cause),
DeleteDistributionConfigurationError::Forbidden(ref cause) => write!(f, "{}", cause),
DeleteDistributionConfigurationError::InvalidRequest(ref cause) => {
write!(f, "{}", cause)
}
DeleteDistributionConfigurationError::ResourceDependency(ref cause) => {
write!(f, "{}", cause)
}
DeleteDistributionConfigurationError::Service(ref cause) => write!(f, "{}", cause),
DeleteDistributionConfigurationError::ServiceUnavailable(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DeleteDistributionConfigurationError {}
#[derive(Debug, PartialEq)]
pub enum DeleteImageError {
CallRateLimitExceeded(String),
Client(String),
Forbidden(String),
InvalidRequest(String),
ResourceDependency(String),
Service(String),
ServiceUnavailable(String),
}
impl DeleteImageError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteImageError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"CallRateLimitExceededException" => {
return RusotoError::Service(DeleteImageError::CallRateLimitExceeded(err.msg))
}
"ClientException" => {
return RusotoError::Service(DeleteImageError::Client(err.msg))
}
"ForbiddenException" => {
return RusotoError::Service(DeleteImageError::Forbidden(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(DeleteImageError::InvalidRequest(err.msg))
}
"ResourceDependencyException" => {
return RusotoError::Service(DeleteImageError::ResourceDependency(err.msg))
}
"ServiceException" => {
return RusotoError::Service(DeleteImageError::Service(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(DeleteImageError::ServiceUnavailable(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteImageError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteImageError::CallRateLimitExceeded(ref cause) => write!(f, "{}", cause),
DeleteImageError::Client(ref cause) => write!(f, "{}", cause),
DeleteImageError::Forbidden(ref cause) => write!(f, "{}", cause),
DeleteImageError::InvalidRequest(ref cause) => write!(f, "{}", cause),
DeleteImageError::ResourceDependency(ref cause) => write!(f, "{}", cause),
DeleteImageError::Service(ref cause) => write!(f, "{}", cause),
DeleteImageError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteImageError {}
#[derive(Debug, PartialEq)]
pub enum DeleteImagePipelineError {
CallRateLimitExceeded(String),
Client(String),
Forbidden(String),
InvalidRequest(String),
ResourceDependency(String),
Service(String),
ServiceUnavailable(String),
}
impl DeleteImagePipelineError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteImagePipelineError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"CallRateLimitExceededException" => {
return RusotoError::Service(DeleteImagePipelineError::CallRateLimitExceeded(
err.msg,
))
}
"ClientException" => {
return RusotoError::Service(DeleteImagePipelineError::Client(err.msg))
}
"ForbiddenException" => {
return RusotoError::Service(DeleteImagePipelineError::Forbidden(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(DeleteImagePipelineError::InvalidRequest(err.msg))
}
"ResourceDependencyException" => {
return RusotoError::Service(DeleteImagePipelineError::ResourceDependency(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(DeleteImagePipelineError::Service(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(DeleteImagePipelineError::ServiceUnavailable(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteImagePipelineError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteImagePipelineError::CallRateLimitExceeded(ref cause) => write!(f, "{}", cause),
DeleteImagePipelineError::Client(ref cause) => write!(f, "{}", cause),
DeleteImagePipelineError::Forbidden(ref cause) => write!(f, "{}", cause),
DeleteImagePipelineError::InvalidRequest(ref cause) => write!(f, "{}", cause),
DeleteImagePipelineError::ResourceDependency(ref cause) => write!(f, "{}", cause),
DeleteImagePipelineError::Service(ref cause) => write!(f, "{}", cause),
DeleteImagePipelineError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteImagePipelineError {}
#[derive(Debug, PartialEq)]
pub enum DeleteImageRecipeError {
CallRateLimitExceeded(String),
Client(String),
Forbidden(String),
InvalidRequest(String),
ResourceDependency(String),
Service(String),
ServiceUnavailable(String),
}
impl DeleteImageRecipeError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteImageRecipeError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"CallRateLimitExceededException" => {
return RusotoError::Service(DeleteImageRecipeError::CallRateLimitExceeded(
err.msg,
))
}
"ClientException" => {
return RusotoError::Service(DeleteImageRecipeError::Client(err.msg))
}
"ForbiddenException" => {
return RusotoError::Service(DeleteImageRecipeError::Forbidden(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(DeleteImageRecipeError::InvalidRequest(err.msg))
}
"ResourceDependencyException" => {
return RusotoError::Service(DeleteImageRecipeError::ResourceDependency(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(DeleteImageRecipeError::Service(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(DeleteImageRecipeError::ServiceUnavailable(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteImageRecipeError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteImageRecipeError::CallRateLimitExceeded(ref cause) => write!(f, "{}", cause),
DeleteImageRecipeError::Client(ref cause) => write!(f, "{}", cause),
DeleteImageRecipeError::Forbidden(ref cause) => write!(f, "{}", cause),
DeleteImageRecipeError::InvalidRequest(ref cause) => write!(f, "{}", cause),
DeleteImageRecipeError::ResourceDependency(ref cause) => write!(f, "{}", cause),
DeleteImageRecipeError::Service(ref cause) => write!(f, "{}", cause),
DeleteImageRecipeError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteImageRecipeError {}
#[derive(Debug, PartialEq)]
pub enum DeleteInfrastructureConfigurationError {
CallRateLimitExceeded(String),
Client(String),
Forbidden(String),
InvalidRequest(String),
ResourceDependency(String),
Service(String),
ServiceUnavailable(String),
}
impl DeleteInfrastructureConfigurationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DeleteInfrastructureConfigurationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"CallRateLimitExceededException" => {
return RusotoError::Service(
DeleteInfrastructureConfigurationError::CallRateLimitExceeded(err.msg),
)
}
"ClientException" => {
return RusotoError::Service(DeleteInfrastructureConfigurationError::Client(
err.msg,
))
}
"ForbiddenException" => {
return RusotoError::Service(DeleteInfrastructureConfigurationError::Forbidden(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(
DeleteInfrastructureConfigurationError::InvalidRequest(err.msg),
)
}
"ResourceDependencyException" => {
return RusotoError::Service(
DeleteInfrastructureConfigurationError::ResourceDependency(err.msg),
)
}
"ServiceException" => {
return RusotoError::Service(DeleteInfrastructureConfigurationError::Service(
err.msg,
))
}
"ServiceUnavailableException" => {
return RusotoError::Service(
DeleteInfrastructureConfigurationError::ServiceUnavailable(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteInfrastructureConfigurationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteInfrastructureConfigurationError::CallRateLimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
DeleteInfrastructureConfigurationError::Client(ref cause) => write!(f, "{}", cause),
DeleteInfrastructureConfigurationError::Forbidden(ref cause) => write!(f, "{}", cause),
DeleteInfrastructureConfigurationError::InvalidRequest(ref cause) => {
write!(f, "{}", cause)
}
DeleteInfrastructureConfigurationError::ResourceDependency(ref cause) => {
write!(f, "{}", cause)
}
DeleteInfrastructureConfigurationError::Service(ref cause) => write!(f, "{}", cause),
DeleteInfrastructureConfigurationError::ServiceUnavailable(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DeleteInfrastructureConfigurationError {}
#[derive(Debug, PartialEq)]
pub enum GetComponentError {
CallRateLimitExceeded(String),
Client(String),
Forbidden(String),
InvalidRequest(String),
Service(String),
ServiceUnavailable(String),
}
impl GetComponentError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetComponentError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"CallRateLimitExceededException" => {
return RusotoError::Service(GetComponentError::CallRateLimitExceeded(err.msg))
}
"ClientException" => {
return RusotoError::Service(GetComponentError::Client(err.msg))
}
"ForbiddenException" => {
return RusotoError::Service(GetComponentError::Forbidden(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(GetComponentError::InvalidRequest(err.msg))
}
"ServiceException" => {
return RusotoError::Service(GetComponentError::Service(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(GetComponentError::ServiceUnavailable(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetComponentError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetComponentError::CallRateLimitExceeded(ref cause) => write!(f, "{}", cause),
GetComponentError::Client(ref cause) => write!(f, "{}", cause),
GetComponentError::Forbidden(ref cause) => write!(f, "{}", cause),
GetComponentError::InvalidRequest(ref cause) => write!(f, "{}", cause),
GetComponentError::Service(ref cause) => write!(f, "{}", cause),
GetComponentError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetComponentError {}
#[derive(Debug, PartialEq)]
pub enum GetComponentPolicyError {
CallRateLimitExceeded(String),
Forbidden(String),
InvalidRequest(String),
ResourceNotFound(String),
Service(String),
ServiceUnavailable(String),
}
impl GetComponentPolicyError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetComponentPolicyError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"CallRateLimitExceededException" => {
return RusotoError::Service(GetComponentPolicyError::CallRateLimitExceeded(
err.msg,
))
}
"ForbiddenException" => {
return RusotoError::Service(GetComponentPolicyError::Forbidden(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(GetComponentPolicyError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(GetComponentPolicyError::ResourceNotFound(err.msg))
}
"ServiceException" => {
return RusotoError::Service(GetComponentPolicyError::Service(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(GetComponentPolicyError::ServiceUnavailable(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetComponentPolicyError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetComponentPolicyError::CallRateLimitExceeded(ref cause) => write!(f, "{}", cause),
GetComponentPolicyError::Forbidden(ref cause) => write!(f, "{}", cause),
GetComponentPolicyError::InvalidRequest(ref cause) => write!(f, "{}", cause),
GetComponentPolicyError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
GetComponentPolicyError::Service(ref cause) => write!(f, "{}", cause),
GetComponentPolicyError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetComponentPolicyError {}
#[derive(Debug, PartialEq)]
pub enum GetContainerRecipeError {
CallRateLimitExceeded(String),
Client(String),
Forbidden(String),
InvalidRequest(String),
Service(String),
ServiceUnavailable(String),
}
impl GetContainerRecipeError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetContainerRecipeError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"CallRateLimitExceededException" => {
return RusotoError::Service(GetContainerRecipeError::CallRateLimitExceeded(
err.msg,
))
}
"ClientException" => {
return RusotoError::Service(GetContainerRecipeError::Client(err.msg))
}
"ForbiddenException" => {
return RusotoError::Service(GetContainerRecipeError::Forbidden(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(GetContainerRecipeError::InvalidRequest(err.msg))
}
"ServiceException" => {
return RusotoError::Service(GetContainerRecipeError::Service(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(GetContainerRecipeError::ServiceUnavailable(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetContainerRecipeError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetContainerRecipeError::CallRateLimitExceeded(ref cause) => write!(f, "{}", cause),
GetContainerRecipeError::Client(ref cause) => write!(f, "{}", cause),
GetContainerRecipeError::Forbidden(ref cause) => write!(f, "{}", cause),
GetContainerRecipeError::InvalidRequest(ref cause) => write!(f, "{}", cause),
GetContainerRecipeError::Service(ref cause) => write!(f, "{}", cause),
GetContainerRecipeError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetContainerRecipeError {}
#[derive(Debug, PartialEq)]
pub enum GetContainerRecipePolicyError {
CallRateLimitExceeded(String),
Forbidden(String),
InvalidRequest(String),
ResourceNotFound(String),
Service(String),
ServiceUnavailable(String),
}
impl GetContainerRecipePolicyError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetContainerRecipePolicyError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"CallRateLimitExceededException" => {
return RusotoError::Service(
GetContainerRecipePolicyError::CallRateLimitExceeded(err.msg),
)
}
"ForbiddenException" => {
return RusotoError::Service(GetContainerRecipePolicyError::Forbidden(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(GetContainerRecipePolicyError::InvalidRequest(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(GetContainerRecipePolicyError::ResourceNotFound(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(GetContainerRecipePolicyError::Service(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(GetContainerRecipePolicyError::ServiceUnavailable(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetContainerRecipePolicyError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetContainerRecipePolicyError::CallRateLimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
GetContainerRecipePolicyError::Forbidden(ref cause) => write!(f, "{}", cause),
GetContainerRecipePolicyError::InvalidRequest(ref cause) => write!(f, "{}", cause),
GetContainerRecipePolicyError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
GetContainerRecipePolicyError::Service(ref cause) => write!(f, "{}", cause),
GetContainerRecipePolicyError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetContainerRecipePolicyError {}
#[derive(Debug, PartialEq)]
pub enum GetDistributionConfigurationError {
CallRateLimitExceeded(String),
Client(String),
Forbidden(String),
InvalidRequest(String),
Service(String),
ServiceUnavailable(String),
}
impl GetDistributionConfigurationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetDistributionConfigurationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"CallRateLimitExceededException" => {
return RusotoError::Service(
GetDistributionConfigurationError::CallRateLimitExceeded(err.msg),
)
}
"ClientException" => {
return RusotoError::Service(GetDistributionConfigurationError::Client(err.msg))
}
"ForbiddenException" => {
return RusotoError::Service(GetDistributionConfigurationError::Forbidden(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(GetDistributionConfigurationError::InvalidRequest(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(GetDistributionConfigurationError::Service(
err.msg,
))
}
"ServiceUnavailableException" => {
return RusotoError::Service(
GetDistributionConfigurationError::ServiceUnavailable(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetDistributionConfigurationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetDistributionConfigurationError::CallRateLimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
GetDistributionConfigurationError::Client(ref cause) => write!(f, "{}", cause),
GetDistributionConfigurationError::Forbidden(ref cause) => write!(f, "{}", cause),
GetDistributionConfigurationError::InvalidRequest(ref cause) => write!(f, "{}", cause),
GetDistributionConfigurationError::Service(ref cause) => write!(f, "{}", cause),
GetDistributionConfigurationError::ServiceUnavailable(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for GetDistributionConfigurationError {}
#[derive(Debug, PartialEq)]
pub enum GetImageError {
CallRateLimitExceeded(String),
Client(String),
Forbidden(String),
InvalidRequest(String),
Service(String),
ServiceUnavailable(String),
}
impl GetImageError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetImageError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"CallRateLimitExceededException" => {
return RusotoError::Service(GetImageError::CallRateLimitExceeded(err.msg))
}
"ClientException" => return RusotoError::Service(GetImageError::Client(err.msg)),
"ForbiddenException" => {
return RusotoError::Service(GetImageError::Forbidden(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(GetImageError::InvalidRequest(err.msg))
}
"ServiceException" => return RusotoError::Service(GetImageError::Service(err.msg)),
"ServiceUnavailableException" => {
return RusotoError::Service(GetImageError::ServiceUnavailable(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetImageError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetImageError::CallRateLimitExceeded(ref cause) => write!(f, "{}", cause),
GetImageError::Client(ref cause) => write!(f, "{}", cause),
GetImageError::Forbidden(ref cause) => write!(f, "{}", cause),
GetImageError::InvalidRequest(ref cause) => write!(f, "{}", cause),
GetImageError::Service(ref cause) => write!(f, "{}", cause),
GetImageError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetImageError {}
#[derive(Debug, PartialEq)]
pub enum GetImagePipelineError {
CallRateLimitExceeded(String),
Client(String),
Forbidden(String),
InvalidRequest(String),
Service(String),
ServiceUnavailable(String),
}
impl GetImagePipelineError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetImagePipelineError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"CallRateLimitExceededException" => {
return RusotoError::Service(GetImagePipelineError::CallRateLimitExceeded(
err.msg,
))
}
"ClientException" => {
return RusotoError::Service(GetImagePipelineError::Client(err.msg))
}
"ForbiddenException" => {
return RusotoError::Service(GetImagePipelineError::Forbidden(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(GetImagePipelineError::InvalidRequest(err.msg))
}
"ServiceException" => {
return RusotoError::Service(GetImagePipelineError::Service(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(GetImagePipelineError::ServiceUnavailable(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetImagePipelineError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetImagePipelineError::CallRateLimitExceeded(ref cause) => write!(f, "{}", cause),
GetImagePipelineError::Client(ref cause) => write!(f, "{}", cause),
GetImagePipelineError::Forbidden(ref cause) => write!(f, "{}", cause),
GetImagePipelineError::InvalidRequest(ref cause) => write!(f, "{}", cause),
GetImagePipelineError::Service(ref cause) => write!(f, "{}", cause),
GetImagePipelineError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetImagePipelineError {}
#[derive(Debug, PartialEq)]
pub enum GetImagePolicyError {
CallRateLimitExceeded(String),
Forbidden(String),
InvalidRequest(String),
ResourceNotFound(String),
Service(String),
ServiceUnavailable(String),
}
impl GetImagePolicyError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetImagePolicyError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"CallRateLimitExceededException" => {
return RusotoError::Service(GetImagePolicyError::CallRateLimitExceeded(
err.msg,
))
}
"ForbiddenException" => {
return RusotoError::Service(GetImagePolicyError::Forbidden(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(GetImagePolicyError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(GetImagePolicyError::ResourceNotFound(err.msg))
}
"ServiceException" => {
return RusotoError::Service(GetImagePolicyError::Service(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(GetImagePolicyError::ServiceUnavailable(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetImagePolicyError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetImagePolicyError::CallRateLimitExceeded(ref cause) => write!(f, "{}", cause),
GetImagePolicyError::Forbidden(ref cause) => write!(f, "{}", cause),
GetImagePolicyError::InvalidRequest(ref cause) => write!(f, "{}", cause),
GetImagePolicyError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
GetImagePolicyError::Service(ref cause) => write!(f, "{}", cause),
GetImagePolicyError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetImagePolicyError {}
#[derive(Debug, PartialEq)]
pub enum GetImageRecipeError {
CallRateLimitExceeded(String),
Client(String),
Forbidden(String),
InvalidRequest(String),
Service(String),
ServiceUnavailable(String),
}
impl GetImageRecipeError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetImageRecipeError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"CallRateLimitExceededException" => {
return RusotoError::Service(GetImageRecipeError::CallRateLimitExceeded(
err.msg,
))
}
"ClientException" => {
return RusotoError::Service(GetImageRecipeError::Client(err.msg))
}
"ForbiddenException" => {
return RusotoError::Service(GetImageRecipeError::Forbidden(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(GetImageRecipeError::InvalidRequest(err.msg))
}
"ServiceException" => {
return RusotoError::Service(GetImageRecipeError::Service(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(GetImageRecipeError::ServiceUnavailable(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetImageRecipeError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetImageRecipeError::CallRateLimitExceeded(ref cause) => write!(f, "{}", cause),
GetImageRecipeError::Client(ref cause) => write!(f, "{}", cause),
GetImageRecipeError::Forbidden(ref cause) => write!(f, "{}", cause),
GetImageRecipeError::InvalidRequest(ref cause) => write!(f, "{}", cause),
GetImageRecipeError::Service(ref cause) => write!(f, "{}", cause),
GetImageRecipeError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetImageRecipeError {}
#[derive(Debug, PartialEq)]
pub enum GetImageRecipePolicyError {
CallRateLimitExceeded(String),
Forbidden(String),
InvalidRequest(String),
ResourceNotFound(String),
Service(String),
ServiceUnavailable(String),
}
impl GetImageRecipePolicyError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetImageRecipePolicyError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"CallRateLimitExceededException" => {
return RusotoError::Service(GetImageRecipePolicyError::CallRateLimitExceeded(
err.msg,
))
}
"ForbiddenException" => {
return RusotoError::Service(GetImageRecipePolicyError::Forbidden(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(GetImageRecipePolicyError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(GetImageRecipePolicyError::ResourceNotFound(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(GetImageRecipePolicyError::Service(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(GetImageRecipePolicyError::ServiceUnavailable(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetImageRecipePolicyError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetImageRecipePolicyError::CallRateLimitExceeded(ref cause) => write!(f, "{}", cause),
GetImageRecipePolicyError::Forbidden(ref cause) => write!(f, "{}", cause),
GetImageRecipePolicyError::InvalidRequest(ref cause) => write!(f, "{}", cause),
GetImageRecipePolicyError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
GetImageRecipePolicyError::Service(ref cause) => write!(f, "{}", cause),
GetImageRecipePolicyError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetImageRecipePolicyError {}
#[derive(Debug, PartialEq)]
pub enum GetInfrastructureConfigurationError {
CallRateLimitExceeded(String),
Client(String),
Forbidden(String),
InvalidRequest(String),
Service(String),
ServiceUnavailable(String),
}
impl GetInfrastructureConfigurationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetInfrastructureConfigurationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"CallRateLimitExceededException" => {
return RusotoError::Service(
GetInfrastructureConfigurationError::CallRateLimitExceeded(err.msg),
)
}
"ClientException" => {
return RusotoError::Service(GetInfrastructureConfigurationError::Client(
err.msg,
))
}
"ForbiddenException" => {
return RusotoError::Service(GetInfrastructureConfigurationError::Forbidden(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(
GetInfrastructureConfigurationError::InvalidRequest(err.msg),
)
}
"ServiceException" => {
return RusotoError::Service(GetInfrastructureConfigurationError::Service(
err.msg,
))
}
"ServiceUnavailableException" => {
return RusotoError::Service(
GetInfrastructureConfigurationError::ServiceUnavailable(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetInfrastructureConfigurationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetInfrastructureConfigurationError::CallRateLimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
GetInfrastructureConfigurationError::Client(ref cause) => write!(f, "{}", cause),
GetInfrastructureConfigurationError::Forbidden(ref cause) => write!(f, "{}", cause),
GetInfrastructureConfigurationError::InvalidRequest(ref cause) => {
write!(f, "{}", cause)
}
GetInfrastructureConfigurationError::Service(ref cause) => write!(f, "{}", cause),
GetInfrastructureConfigurationError::ServiceUnavailable(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for GetInfrastructureConfigurationError {}
#[derive(Debug, PartialEq)]
pub enum ImportComponentError {
CallRateLimitExceeded(String),
Client(String),
Forbidden(String),
IdempotentParameterMismatch(String),
InvalidParameterCombination(String),
InvalidRequest(String),
InvalidVersionNumber(String),
ResourceInUse(String),
Service(String),
ServiceUnavailable(String),
}
impl ImportComponentError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ImportComponentError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"CallRateLimitExceededException" => {
return RusotoError::Service(ImportComponentError::CallRateLimitExceeded(
err.msg,
))
}
"ClientException" => {
return RusotoError::Service(ImportComponentError::Client(err.msg))
}
"ForbiddenException" => {
return RusotoError::Service(ImportComponentError::Forbidden(err.msg))
}
"IdempotentParameterMismatchException" => {
return RusotoError::Service(ImportComponentError::IdempotentParameterMismatch(
err.msg,
))
}
"InvalidParameterCombinationException" => {
return RusotoError::Service(ImportComponentError::InvalidParameterCombination(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(ImportComponentError::InvalidRequest(err.msg))
}
"InvalidVersionNumberException" => {
return RusotoError::Service(ImportComponentError::InvalidVersionNumber(
err.msg,
))
}
"ResourceInUseException" => {
return RusotoError::Service(ImportComponentError::ResourceInUse(err.msg))
}
"ServiceException" => {
return RusotoError::Service(ImportComponentError::Service(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(ImportComponentError::ServiceUnavailable(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ImportComponentError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ImportComponentError::CallRateLimitExceeded(ref cause) => write!(f, "{}", cause),
ImportComponentError::Client(ref cause) => write!(f, "{}", cause),
ImportComponentError::Forbidden(ref cause) => write!(f, "{}", cause),
ImportComponentError::IdempotentParameterMismatch(ref cause) => write!(f, "{}", cause),
ImportComponentError::InvalidParameterCombination(ref cause) => write!(f, "{}", cause),
ImportComponentError::InvalidRequest(ref cause) => write!(f, "{}", cause),
ImportComponentError::InvalidVersionNumber(ref cause) => write!(f, "{}", cause),
ImportComponentError::ResourceInUse(ref cause) => write!(f, "{}", cause),
ImportComponentError::Service(ref cause) => write!(f, "{}", cause),
ImportComponentError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ImportComponentError {}
#[derive(Debug, PartialEq)]
pub enum ListComponentBuildVersionsError {
CallRateLimitExceeded(String),
Client(String),
Forbidden(String),
InvalidPaginationToken(String),
InvalidRequest(String),
Service(String),
ServiceUnavailable(String),
}
impl ListComponentBuildVersionsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListComponentBuildVersionsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"CallRateLimitExceededException" => {
return RusotoError::Service(
ListComponentBuildVersionsError::CallRateLimitExceeded(err.msg),
)
}
"ClientException" => {
return RusotoError::Service(ListComponentBuildVersionsError::Client(err.msg))
}
"ForbiddenException" => {
return RusotoError::Service(ListComponentBuildVersionsError::Forbidden(
err.msg,
))
}
"InvalidPaginationTokenException" => {
return RusotoError::Service(
ListComponentBuildVersionsError::InvalidPaginationToken(err.msg),
)
}
"InvalidRequestException" => {
return RusotoError::Service(ListComponentBuildVersionsError::InvalidRequest(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(ListComponentBuildVersionsError::Service(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(
ListComponentBuildVersionsError::ServiceUnavailable(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListComponentBuildVersionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListComponentBuildVersionsError::CallRateLimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
ListComponentBuildVersionsError::Client(ref cause) => write!(f, "{}", cause),
ListComponentBuildVersionsError::Forbidden(ref cause) => write!(f, "{}", cause),
ListComponentBuildVersionsError::InvalidPaginationToken(ref cause) => {
write!(f, "{}", cause)
}
ListComponentBuildVersionsError::InvalidRequest(ref cause) => write!(f, "{}", cause),
ListComponentBuildVersionsError::Service(ref cause) => write!(f, "{}", cause),
ListComponentBuildVersionsError::ServiceUnavailable(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ListComponentBuildVersionsError {}
#[derive(Debug, PartialEq)]
pub enum ListComponentsError {
CallRateLimitExceeded(String),
Client(String),
Forbidden(String),
InvalidPaginationToken(String),
InvalidRequest(String),
Service(String),
ServiceUnavailable(String),
}
impl ListComponentsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListComponentsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"CallRateLimitExceededException" => {
return RusotoError::Service(ListComponentsError::CallRateLimitExceeded(
err.msg,
))
}
"ClientException" => {
return RusotoError::Service(ListComponentsError::Client(err.msg))
}
"ForbiddenException" => {
return RusotoError::Service(ListComponentsError::Forbidden(err.msg))
}
"InvalidPaginationTokenException" => {
return RusotoError::Service(ListComponentsError::InvalidPaginationToken(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(ListComponentsError::InvalidRequest(err.msg))
}
"ServiceException" => {
return RusotoError::Service(ListComponentsError::Service(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(ListComponentsError::ServiceUnavailable(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListComponentsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListComponentsError::CallRateLimitExceeded(ref cause) => write!(f, "{}", cause),
ListComponentsError::Client(ref cause) => write!(f, "{}", cause),
ListComponentsError::Forbidden(ref cause) => write!(f, "{}", cause),
ListComponentsError::InvalidPaginationToken(ref cause) => write!(f, "{}", cause),
ListComponentsError::InvalidRequest(ref cause) => write!(f, "{}", cause),
ListComponentsError::Service(ref cause) => write!(f, "{}", cause),
ListComponentsError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListComponentsError {}
#[derive(Debug, PartialEq)]
pub enum ListContainerRecipesError {
CallRateLimitExceeded(String),
Client(String),
Forbidden(String),
InvalidPaginationToken(String),
InvalidRequest(String),
Service(String),
ServiceUnavailable(String),
}
impl ListContainerRecipesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListContainerRecipesError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"CallRateLimitExceededException" => {
return RusotoError::Service(ListContainerRecipesError::CallRateLimitExceeded(
err.msg,
))
}
"ClientException" => {
return RusotoError::Service(ListContainerRecipesError::Client(err.msg))
}
"ForbiddenException" => {
return RusotoError::Service(ListContainerRecipesError::Forbidden(err.msg))
}
"InvalidPaginationTokenException" => {
return RusotoError::Service(ListContainerRecipesError::InvalidPaginationToken(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(ListContainerRecipesError::InvalidRequest(err.msg))
}
"ServiceException" => {
return RusotoError::Service(ListContainerRecipesError::Service(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(ListContainerRecipesError::ServiceUnavailable(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListContainerRecipesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListContainerRecipesError::CallRateLimitExceeded(ref cause) => write!(f, "{}", cause),
ListContainerRecipesError::Client(ref cause) => write!(f, "{}", cause),
ListContainerRecipesError::Forbidden(ref cause) => write!(f, "{}", cause),
ListContainerRecipesError::InvalidPaginationToken(ref cause) => write!(f, "{}", cause),
ListContainerRecipesError::InvalidRequest(ref cause) => write!(f, "{}", cause),
ListContainerRecipesError::Service(ref cause) => write!(f, "{}", cause),
ListContainerRecipesError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListContainerRecipesError {}
#[derive(Debug, PartialEq)]
pub enum ListDistributionConfigurationsError {
CallRateLimitExceeded(String),
Client(String),
Forbidden(String),
InvalidPaginationToken(String),
InvalidRequest(String),
Service(String),
ServiceUnavailable(String),
}
impl ListDistributionConfigurationsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListDistributionConfigurationsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"CallRateLimitExceededException" => {
return RusotoError::Service(
ListDistributionConfigurationsError::CallRateLimitExceeded(err.msg),
)
}
"ClientException" => {
return RusotoError::Service(ListDistributionConfigurationsError::Client(
err.msg,
))
}
"ForbiddenException" => {
return RusotoError::Service(ListDistributionConfigurationsError::Forbidden(
err.msg,
))
}
"InvalidPaginationTokenException" => {
return RusotoError::Service(
ListDistributionConfigurationsError::InvalidPaginationToken(err.msg),
)
}
"InvalidRequestException" => {
return RusotoError::Service(
ListDistributionConfigurationsError::InvalidRequest(err.msg),
)
}
"ServiceException" => {
return RusotoError::Service(ListDistributionConfigurationsError::Service(
err.msg,
))
}
"ServiceUnavailableException" => {
return RusotoError::Service(
ListDistributionConfigurationsError::ServiceUnavailable(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListDistributionConfigurationsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListDistributionConfigurationsError::CallRateLimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
ListDistributionConfigurationsError::Client(ref cause) => write!(f, "{}", cause),
ListDistributionConfigurationsError::Forbidden(ref cause) => write!(f, "{}", cause),
ListDistributionConfigurationsError::InvalidPaginationToken(ref cause) => {
write!(f, "{}", cause)
}
ListDistributionConfigurationsError::InvalidRequest(ref cause) => {
write!(f, "{}", cause)
}
ListDistributionConfigurationsError::Service(ref cause) => write!(f, "{}", cause),
ListDistributionConfigurationsError::ServiceUnavailable(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ListDistributionConfigurationsError {}
#[derive(Debug, PartialEq)]
pub enum ListImageBuildVersionsError {
CallRateLimitExceeded(String),
Client(String),
Forbidden(String),
InvalidPaginationToken(String),
InvalidRequest(String),
Service(String),
ServiceUnavailable(String),
}
impl ListImageBuildVersionsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListImageBuildVersionsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"CallRateLimitExceededException" => {
return RusotoError::Service(
ListImageBuildVersionsError::CallRateLimitExceeded(err.msg),
)
}
"ClientException" => {
return RusotoError::Service(ListImageBuildVersionsError::Client(err.msg))
}
"ForbiddenException" => {
return RusotoError::Service(ListImageBuildVersionsError::Forbidden(err.msg))
}
"InvalidPaginationTokenException" => {
return RusotoError::Service(
ListImageBuildVersionsError::InvalidPaginationToken(err.msg),
)
}
"InvalidRequestException" => {
return RusotoError::Service(ListImageBuildVersionsError::InvalidRequest(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(ListImageBuildVersionsError::Service(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(ListImageBuildVersionsError::ServiceUnavailable(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListImageBuildVersionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListImageBuildVersionsError::CallRateLimitExceeded(ref cause) => write!(f, "{}", cause),
ListImageBuildVersionsError::Client(ref cause) => write!(f, "{}", cause),
ListImageBuildVersionsError::Forbidden(ref cause) => write!(f, "{}", cause),
ListImageBuildVersionsError::InvalidPaginationToken(ref cause) => {
write!(f, "{}", cause)
}
ListImageBuildVersionsError::InvalidRequest(ref cause) => write!(f, "{}", cause),
ListImageBuildVersionsError::Service(ref cause) => write!(f, "{}", cause),
ListImageBuildVersionsError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListImageBuildVersionsError {}
#[derive(Debug, PartialEq)]
pub enum ListImagePipelineImagesError {
CallRateLimitExceeded(String),
Client(String),
Forbidden(String),
InvalidPaginationToken(String),
InvalidRequest(String),
ResourceNotFound(String),
Service(String),
ServiceUnavailable(String),
}
impl ListImagePipelineImagesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListImagePipelineImagesError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"CallRateLimitExceededException" => {
return RusotoError::Service(
ListImagePipelineImagesError::CallRateLimitExceeded(err.msg),
)
}
"ClientException" => {
return RusotoError::Service(ListImagePipelineImagesError::Client(err.msg))
}
"ForbiddenException" => {
return RusotoError::Service(ListImagePipelineImagesError::Forbidden(err.msg))
}
"InvalidPaginationTokenException" => {
return RusotoError::Service(
ListImagePipelineImagesError::InvalidPaginationToken(err.msg),
)
}
"InvalidRequestException" => {
return RusotoError::Service(ListImagePipelineImagesError::InvalidRequest(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListImagePipelineImagesError::ResourceNotFound(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(ListImagePipelineImagesError::Service(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(ListImagePipelineImagesError::ServiceUnavailable(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListImagePipelineImagesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListImagePipelineImagesError::CallRateLimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
ListImagePipelineImagesError::Client(ref cause) => write!(f, "{}", cause),
ListImagePipelineImagesError::Forbidden(ref cause) => write!(f, "{}", cause),
ListImagePipelineImagesError::InvalidPaginationToken(ref cause) => {
write!(f, "{}", cause)
}
ListImagePipelineImagesError::InvalidRequest(ref cause) => write!(f, "{}", cause),
ListImagePipelineImagesError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ListImagePipelineImagesError::Service(ref cause) => write!(f, "{}", cause),
ListImagePipelineImagesError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListImagePipelineImagesError {}
#[derive(Debug, PartialEq)]
pub enum ListImagePipelinesError {
CallRateLimitExceeded(String),
Client(String),
Forbidden(String),
InvalidPaginationToken(String),
InvalidRequest(String),
Service(String),
ServiceUnavailable(String),
}
impl ListImagePipelinesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListImagePipelinesError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"CallRateLimitExceededException" => {
return RusotoError::Service(ListImagePipelinesError::CallRateLimitExceeded(
err.msg,
))
}
"ClientException" => {
return RusotoError::Service(ListImagePipelinesError::Client(err.msg))
}
"ForbiddenException" => {
return RusotoError::Service(ListImagePipelinesError::Forbidden(err.msg))
}
"InvalidPaginationTokenException" => {
return RusotoError::Service(ListImagePipelinesError::InvalidPaginationToken(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(ListImagePipelinesError::InvalidRequest(err.msg))
}
"ServiceException" => {
return RusotoError::Service(ListImagePipelinesError::Service(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(ListImagePipelinesError::ServiceUnavailable(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListImagePipelinesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListImagePipelinesError::CallRateLimitExceeded(ref cause) => write!(f, "{}", cause),
ListImagePipelinesError::Client(ref cause) => write!(f, "{}", cause),
ListImagePipelinesError::Forbidden(ref cause) => write!(f, "{}", cause),
ListImagePipelinesError::InvalidPaginationToken(ref cause) => write!(f, "{}", cause),
ListImagePipelinesError::InvalidRequest(ref cause) => write!(f, "{}", cause),
ListImagePipelinesError::Service(ref cause) => write!(f, "{}", cause),
ListImagePipelinesError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListImagePipelinesError {}
#[derive(Debug, PartialEq)]
pub enum ListImageRecipesError {
CallRateLimitExceeded(String),
Client(String),
Forbidden(String),
InvalidPaginationToken(String),
InvalidRequest(String),
Service(String),
ServiceUnavailable(String),
}
impl ListImageRecipesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListImageRecipesError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"CallRateLimitExceededException" => {
return RusotoError::Service(ListImageRecipesError::CallRateLimitExceeded(
err.msg,
))
}
"ClientException" => {
return RusotoError::Service(ListImageRecipesError::Client(err.msg))
}
"ForbiddenException" => {
return RusotoError::Service(ListImageRecipesError::Forbidden(err.msg))
}
"InvalidPaginationTokenException" => {
return RusotoError::Service(ListImageRecipesError::InvalidPaginationToken(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(ListImageRecipesError::InvalidRequest(err.msg))
}
"ServiceException" => {
return RusotoError::Service(ListImageRecipesError::Service(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(ListImageRecipesError::ServiceUnavailable(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListImageRecipesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListImageRecipesError::CallRateLimitExceeded(ref cause) => write!(f, "{}", cause),
ListImageRecipesError::Client(ref cause) => write!(f, "{}", cause),
ListImageRecipesError::Forbidden(ref cause) => write!(f, "{}", cause),
ListImageRecipesError::InvalidPaginationToken(ref cause) => write!(f, "{}", cause),
ListImageRecipesError::InvalidRequest(ref cause) => write!(f, "{}", cause),
ListImageRecipesError::Service(ref cause) => write!(f, "{}", cause),
ListImageRecipesError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListImageRecipesError {}
#[derive(Debug, PartialEq)]
pub enum ListImagesError {
CallRateLimitExceeded(String),
Client(String),
Forbidden(String),
InvalidPaginationToken(String),
InvalidRequest(String),
Service(String),
ServiceUnavailable(String),
}
impl ListImagesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListImagesError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"CallRateLimitExceededException" => {
return RusotoError::Service(ListImagesError::CallRateLimitExceeded(err.msg))
}
"ClientException" => return RusotoError::Service(ListImagesError::Client(err.msg)),
"ForbiddenException" => {
return RusotoError::Service(ListImagesError::Forbidden(err.msg))
}
"InvalidPaginationTokenException" => {
return RusotoError::Service(ListImagesError::InvalidPaginationToken(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(ListImagesError::InvalidRequest(err.msg))
}
"ServiceException" => {
return RusotoError::Service(ListImagesError::Service(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(ListImagesError::ServiceUnavailable(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListImagesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListImagesError::CallRateLimitExceeded(ref cause) => write!(f, "{}", cause),
ListImagesError::Client(ref cause) => write!(f, "{}", cause),
ListImagesError::Forbidden(ref cause) => write!(f, "{}", cause),
ListImagesError::InvalidPaginationToken(ref cause) => write!(f, "{}", cause),
ListImagesError::InvalidRequest(ref cause) => write!(f, "{}", cause),
ListImagesError::Service(ref cause) => write!(f, "{}", cause),
ListImagesError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListImagesError {}
#[derive(Debug, PartialEq)]
pub enum ListInfrastructureConfigurationsError {
CallRateLimitExceeded(String),
Client(String),
Forbidden(String),
InvalidPaginationToken(String),
InvalidRequest(String),
Service(String),
ServiceUnavailable(String),
}
impl ListInfrastructureConfigurationsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListInfrastructureConfigurationsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"CallRateLimitExceededException" => {
return RusotoError::Service(
ListInfrastructureConfigurationsError::CallRateLimitExceeded(err.msg),
)
}
"ClientException" => {
return RusotoError::Service(ListInfrastructureConfigurationsError::Client(
err.msg,
))
}
"ForbiddenException" => {
return RusotoError::Service(ListInfrastructureConfigurationsError::Forbidden(
err.msg,
))
}
"InvalidPaginationTokenException" => {
return RusotoError::Service(
ListInfrastructureConfigurationsError::InvalidPaginationToken(err.msg),
)
}
"InvalidRequestException" => {
return RusotoError::Service(
ListInfrastructureConfigurationsError::InvalidRequest(err.msg),
)
}
"ServiceException" => {
return RusotoError::Service(ListInfrastructureConfigurationsError::Service(
err.msg,
))
}
"ServiceUnavailableException" => {
return RusotoError::Service(
ListInfrastructureConfigurationsError::ServiceUnavailable(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListInfrastructureConfigurationsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListInfrastructureConfigurationsError::CallRateLimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
ListInfrastructureConfigurationsError::Client(ref cause) => write!(f, "{}", cause),
ListInfrastructureConfigurationsError::Forbidden(ref cause) => write!(f, "{}", cause),
ListInfrastructureConfigurationsError::InvalidPaginationToken(ref cause) => {
write!(f, "{}", cause)
}
ListInfrastructureConfigurationsError::InvalidRequest(ref cause) => {
write!(f, "{}", cause)
}
ListInfrastructureConfigurationsError::Service(ref cause) => write!(f, "{}", cause),
ListInfrastructureConfigurationsError::ServiceUnavailable(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ListInfrastructureConfigurationsError {}
#[derive(Debug, PartialEq)]
pub enum ListTagsForResourceError {
InvalidParameter(String),
ResourceNotFound(String),
Service(String),
}
impl ListTagsForResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListTagsForResourceError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterException" => {
return RusotoError::Service(ListTagsForResourceError::InvalidParameter(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListTagsForResourceError::ResourceNotFound(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(ListTagsForResourceError::Service(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::InvalidParameter(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::Service(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListTagsForResourceError {}
#[derive(Debug, PartialEq)]
pub enum PutComponentPolicyError {
CallRateLimitExceeded(String),
Client(String),
Forbidden(String),
InvalidParameterValue(String),
InvalidRequest(String),
ResourceNotFound(String),
Service(String),
ServiceUnavailable(String),
}
impl PutComponentPolicyError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<PutComponentPolicyError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"CallRateLimitExceededException" => {
return RusotoError::Service(PutComponentPolicyError::CallRateLimitExceeded(
err.msg,
))
}
"ClientException" => {
return RusotoError::Service(PutComponentPolicyError::Client(err.msg))
}
"ForbiddenException" => {
return RusotoError::Service(PutComponentPolicyError::Forbidden(err.msg))
}
"InvalidParameterValueException" => {
return RusotoError::Service(PutComponentPolicyError::InvalidParameterValue(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(PutComponentPolicyError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(PutComponentPolicyError::ResourceNotFound(err.msg))
}
"ServiceException" => {
return RusotoError::Service(PutComponentPolicyError::Service(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(PutComponentPolicyError::ServiceUnavailable(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for PutComponentPolicyError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PutComponentPolicyError::CallRateLimitExceeded(ref cause) => write!(f, "{}", cause),
PutComponentPolicyError::Client(ref cause) => write!(f, "{}", cause),
PutComponentPolicyError::Forbidden(ref cause) => write!(f, "{}", cause),
PutComponentPolicyError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
PutComponentPolicyError::InvalidRequest(ref cause) => write!(f, "{}", cause),
PutComponentPolicyError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
PutComponentPolicyError::Service(ref cause) => write!(f, "{}", cause),
PutComponentPolicyError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for PutComponentPolicyError {}
#[derive(Debug, PartialEq)]
pub enum PutContainerRecipePolicyError {
CallRateLimitExceeded(String),
Client(String),
Forbidden(String),
InvalidParameterValue(String),
InvalidRequest(String),
ResourceNotFound(String),
Service(String),
ServiceUnavailable(String),
}
impl PutContainerRecipePolicyError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<PutContainerRecipePolicyError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"CallRateLimitExceededException" => {
return RusotoError::Service(
PutContainerRecipePolicyError::CallRateLimitExceeded(err.msg),
)
}
"ClientException" => {
return RusotoError::Service(PutContainerRecipePolicyError::Client(err.msg))
}
"ForbiddenException" => {
return RusotoError::Service(PutContainerRecipePolicyError::Forbidden(err.msg))
}
"InvalidParameterValueException" => {
return RusotoError::Service(
PutContainerRecipePolicyError::InvalidParameterValue(err.msg),
)
}
"InvalidRequestException" => {
return RusotoError::Service(PutContainerRecipePolicyError::InvalidRequest(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(PutContainerRecipePolicyError::ResourceNotFound(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(PutContainerRecipePolicyError::Service(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(PutContainerRecipePolicyError::ServiceUnavailable(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for PutContainerRecipePolicyError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PutContainerRecipePolicyError::CallRateLimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
PutContainerRecipePolicyError::Client(ref cause) => write!(f, "{}", cause),
PutContainerRecipePolicyError::Forbidden(ref cause) => write!(f, "{}", cause),
PutContainerRecipePolicyError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
PutContainerRecipePolicyError::InvalidRequest(ref cause) => write!(f, "{}", cause),
PutContainerRecipePolicyError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
PutContainerRecipePolicyError::Service(ref cause) => write!(f, "{}", cause),
PutContainerRecipePolicyError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for PutContainerRecipePolicyError {}
#[derive(Debug, PartialEq)]
pub enum PutImagePolicyError {
CallRateLimitExceeded(String),
Client(String),
Forbidden(String),
InvalidParameterValue(String),
InvalidRequest(String),
ResourceNotFound(String),
Service(String),
ServiceUnavailable(String),
}
impl PutImagePolicyError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<PutImagePolicyError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"CallRateLimitExceededException" => {
return RusotoError::Service(PutImagePolicyError::CallRateLimitExceeded(
err.msg,
))
}
"ClientException" => {
return RusotoError::Service(PutImagePolicyError::Client(err.msg))
}
"ForbiddenException" => {
return RusotoError::Service(PutImagePolicyError::Forbidden(err.msg))
}
"InvalidParameterValueException" => {
return RusotoError::Service(PutImagePolicyError::InvalidParameterValue(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(PutImagePolicyError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(PutImagePolicyError::ResourceNotFound(err.msg))
}
"ServiceException" => {
return RusotoError::Service(PutImagePolicyError::Service(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(PutImagePolicyError::ServiceUnavailable(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for PutImagePolicyError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PutImagePolicyError::CallRateLimitExceeded(ref cause) => write!(f, "{}", cause),
PutImagePolicyError::Client(ref cause) => write!(f, "{}", cause),
PutImagePolicyError::Forbidden(ref cause) => write!(f, "{}", cause),
PutImagePolicyError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
PutImagePolicyError::InvalidRequest(ref cause) => write!(f, "{}", cause),
PutImagePolicyError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
PutImagePolicyError::Service(ref cause) => write!(f, "{}", cause),
PutImagePolicyError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for PutImagePolicyError {}
#[derive(Debug, PartialEq)]
pub enum PutImageRecipePolicyError {
CallRateLimitExceeded(String),
Client(String),
Forbidden(String),
InvalidParameterValue(String),
InvalidRequest(String),
ResourceNotFound(String),
Service(String),
ServiceUnavailable(String),
}
impl PutImageRecipePolicyError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<PutImageRecipePolicyError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"CallRateLimitExceededException" => {
return RusotoError::Service(PutImageRecipePolicyError::CallRateLimitExceeded(
err.msg,
))
}
"ClientException" => {
return RusotoError::Service(PutImageRecipePolicyError::Client(err.msg))
}
"ForbiddenException" => {
return RusotoError::Service(PutImageRecipePolicyError::Forbidden(err.msg))
}
"InvalidParameterValueException" => {
return RusotoError::Service(PutImageRecipePolicyError::InvalidParameterValue(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(PutImageRecipePolicyError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(PutImageRecipePolicyError::ResourceNotFound(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(PutImageRecipePolicyError::Service(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(PutImageRecipePolicyError::ServiceUnavailable(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for PutImageRecipePolicyError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PutImageRecipePolicyError::CallRateLimitExceeded(ref cause) => write!(f, "{}", cause),
PutImageRecipePolicyError::Client(ref cause) => write!(f, "{}", cause),
PutImageRecipePolicyError::Forbidden(ref cause) => write!(f, "{}", cause),
PutImageRecipePolicyError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
PutImageRecipePolicyError::InvalidRequest(ref cause) => write!(f, "{}", cause),
PutImageRecipePolicyError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
PutImageRecipePolicyError::Service(ref cause) => write!(f, "{}", cause),
PutImageRecipePolicyError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for PutImageRecipePolicyError {}
#[derive(Debug, PartialEq)]
pub enum StartImagePipelineExecutionError {
CallRateLimitExceeded(String),
Client(String),
Forbidden(String),
IdempotentParameterMismatch(String),
InvalidRequest(String),
ResourceInUse(String),
ResourceNotFound(String),
Service(String),
ServiceUnavailable(String),
}
impl StartImagePipelineExecutionError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<StartImagePipelineExecutionError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"CallRateLimitExceededException" => {
return RusotoError::Service(
StartImagePipelineExecutionError::CallRateLimitExceeded(err.msg),
)
}
"ClientException" => {
return RusotoError::Service(StartImagePipelineExecutionError::Client(err.msg))
}
"ForbiddenException" => {
return RusotoError::Service(StartImagePipelineExecutionError::Forbidden(
err.msg,
))
}
"IdempotentParameterMismatchException" => {
return RusotoError::Service(
StartImagePipelineExecutionError::IdempotentParameterMismatch(err.msg),
)
}
"InvalidRequestException" => {
return RusotoError::Service(StartImagePipelineExecutionError::InvalidRequest(
err.msg,
))
}
"ResourceInUseException" => {
return RusotoError::Service(StartImagePipelineExecutionError::ResourceInUse(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(
StartImagePipelineExecutionError::ResourceNotFound(err.msg),
)
}
"ServiceException" => {
return RusotoError::Service(StartImagePipelineExecutionError::Service(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(
StartImagePipelineExecutionError::ServiceUnavailable(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for StartImagePipelineExecutionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
StartImagePipelineExecutionError::CallRateLimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
StartImagePipelineExecutionError::Client(ref cause) => write!(f, "{}", cause),
StartImagePipelineExecutionError::Forbidden(ref cause) => write!(f, "{}", cause),
StartImagePipelineExecutionError::IdempotentParameterMismatch(ref cause) => {
write!(f, "{}", cause)
}
StartImagePipelineExecutionError::InvalidRequest(ref cause) => write!(f, "{}", cause),
StartImagePipelineExecutionError::ResourceInUse(ref cause) => write!(f, "{}", cause),
StartImagePipelineExecutionError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
StartImagePipelineExecutionError::Service(ref cause) => write!(f, "{}", cause),
StartImagePipelineExecutionError::ServiceUnavailable(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for StartImagePipelineExecutionError {}
#[derive(Debug, PartialEq)]
pub enum TagResourceError {
InvalidParameter(String),
ResourceNotFound(String),
Service(String),
}
impl TagResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<TagResourceError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterException" => {
return RusotoError::Service(TagResourceError::InvalidParameter(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(TagResourceError::ResourceNotFound(err.msg))
}
"ServiceException" => {
return RusotoError::Service(TagResourceError::Service(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::InvalidParameter(ref cause) => write!(f, "{}", cause),
TagResourceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
TagResourceError::Service(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for TagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UntagResourceError {
InvalidParameter(String),
ResourceNotFound(String),
Service(String),
}
impl UntagResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UntagResourceError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterException" => {
return RusotoError::Service(UntagResourceError::InvalidParameter(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UntagResourceError::ResourceNotFound(err.msg))
}
"ServiceException" => {
return RusotoError::Service(UntagResourceError::Service(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::InvalidParameter(ref cause) => write!(f, "{}", cause),
UntagResourceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
UntagResourceError::Service(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UntagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UpdateDistributionConfigurationError {
CallRateLimitExceeded(String),
Client(String),
Forbidden(String),
IdempotentParameterMismatch(String),
InvalidParameterCombination(String),
InvalidRequest(String),
ResourceInUse(String),
Service(String),
ServiceUnavailable(String),
}
impl UpdateDistributionConfigurationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<UpdateDistributionConfigurationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"CallRateLimitExceededException" => {
return RusotoError::Service(
UpdateDistributionConfigurationError::CallRateLimitExceeded(err.msg),
)
}
"ClientException" => {
return RusotoError::Service(UpdateDistributionConfigurationError::Client(
err.msg,
))
}
"ForbiddenException" => {
return RusotoError::Service(UpdateDistributionConfigurationError::Forbidden(
err.msg,
))
}
"IdempotentParameterMismatchException" => {
return RusotoError::Service(
UpdateDistributionConfigurationError::IdempotentParameterMismatch(err.msg),
)
}
"InvalidParameterCombinationException" => {
return RusotoError::Service(
UpdateDistributionConfigurationError::InvalidParameterCombination(err.msg),
)
}
"InvalidRequestException" => {
return RusotoError::Service(
UpdateDistributionConfigurationError::InvalidRequest(err.msg),
)
}
"ResourceInUseException" => {
return RusotoError::Service(
UpdateDistributionConfigurationError::ResourceInUse(err.msg),
)
}
"ServiceException" => {
return RusotoError::Service(UpdateDistributionConfigurationError::Service(
err.msg,
))
}
"ServiceUnavailableException" => {
return RusotoError::Service(
UpdateDistributionConfigurationError::ServiceUnavailable(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateDistributionConfigurationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateDistributionConfigurationError::CallRateLimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
UpdateDistributionConfigurationError::Client(ref cause) => write!(f, "{}", cause),
UpdateDistributionConfigurationError::Forbidden(ref cause) => write!(f, "{}", cause),
UpdateDistributionConfigurationError::IdempotentParameterMismatch(ref cause) => {
write!(f, "{}", cause)
}
UpdateDistributionConfigurationError::InvalidParameterCombination(ref cause) => {
write!(f, "{}", cause)
}
UpdateDistributionConfigurationError::InvalidRequest(ref cause) => {
write!(f, "{}", cause)
}
UpdateDistributionConfigurationError::ResourceInUse(ref cause) => {
write!(f, "{}", cause)
}
UpdateDistributionConfigurationError::Service(ref cause) => write!(f, "{}", cause),
UpdateDistributionConfigurationError::ServiceUnavailable(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for UpdateDistributionConfigurationError {}
#[derive(Debug, PartialEq)]
pub enum UpdateImagePipelineError {
CallRateLimitExceeded(String),
Client(String),
Forbidden(String),
IdempotentParameterMismatch(String),
InvalidRequest(String),
ResourceInUse(String),
Service(String),
ServiceUnavailable(String),
}
impl UpdateImagePipelineError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateImagePipelineError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"CallRateLimitExceededException" => {
return RusotoError::Service(UpdateImagePipelineError::CallRateLimitExceeded(
err.msg,
))
}
"ClientException" => {
return RusotoError::Service(UpdateImagePipelineError::Client(err.msg))
}
"ForbiddenException" => {
return RusotoError::Service(UpdateImagePipelineError::Forbidden(err.msg))
}
"IdempotentParameterMismatchException" => {
return RusotoError::Service(
UpdateImagePipelineError::IdempotentParameterMismatch(err.msg),
)
}
"InvalidRequestException" => {
return RusotoError::Service(UpdateImagePipelineError::InvalidRequest(err.msg))
}
"ResourceInUseException" => {
return RusotoError::Service(UpdateImagePipelineError::ResourceInUse(err.msg))
}
"ServiceException" => {
return RusotoError::Service(UpdateImagePipelineError::Service(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(UpdateImagePipelineError::ServiceUnavailable(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateImagePipelineError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateImagePipelineError::CallRateLimitExceeded(ref cause) => write!(f, "{}", cause),
UpdateImagePipelineError::Client(ref cause) => write!(f, "{}", cause),
UpdateImagePipelineError::Forbidden(ref cause) => write!(f, "{}", cause),
UpdateImagePipelineError::IdempotentParameterMismatch(ref cause) => {
write!(f, "{}", cause)
}
UpdateImagePipelineError::InvalidRequest(ref cause) => write!(f, "{}", cause),
UpdateImagePipelineError::ResourceInUse(ref cause) => write!(f, "{}", cause),
UpdateImagePipelineError::Service(ref cause) => write!(f, "{}", cause),
UpdateImagePipelineError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateImagePipelineError {}
#[derive(Debug, PartialEq)]
pub enum UpdateInfrastructureConfigurationError {
CallRateLimitExceeded(String),
Client(String),
Forbidden(String),
IdempotentParameterMismatch(String),
InvalidRequest(String),
ResourceInUse(String),
Service(String),
ServiceUnavailable(String),
}
impl UpdateInfrastructureConfigurationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<UpdateInfrastructureConfigurationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"CallRateLimitExceededException" => {
return RusotoError::Service(
UpdateInfrastructureConfigurationError::CallRateLimitExceeded(err.msg),
)
}
"ClientException" => {
return RusotoError::Service(UpdateInfrastructureConfigurationError::Client(
err.msg,
))
}
"ForbiddenException" => {
return RusotoError::Service(UpdateInfrastructureConfigurationError::Forbidden(
err.msg,
))
}
"IdempotentParameterMismatchException" => {
return RusotoError::Service(
UpdateInfrastructureConfigurationError::IdempotentParameterMismatch(
err.msg,
),
)
}
"InvalidRequestException" => {
return RusotoError::Service(
UpdateInfrastructureConfigurationError::InvalidRequest(err.msg),
)
}
"ResourceInUseException" => {
return RusotoError::Service(
UpdateInfrastructureConfigurationError::ResourceInUse(err.msg),
)
}
"ServiceException" => {
return RusotoError::Service(UpdateInfrastructureConfigurationError::Service(
err.msg,
))
}
"ServiceUnavailableException" => {
return RusotoError::Service(
UpdateInfrastructureConfigurationError::ServiceUnavailable(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateInfrastructureConfigurationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateInfrastructureConfigurationError::CallRateLimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
UpdateInfrastructureConfigurationError::Client(ref cause) => write!(f, "{}", cause),
UpdateInfrastructureConfigurationError::Forbidden(ref cause) => write!(f, "{}", cause),
UpdateInfrastructureConfigurationError::IdempotentParameterMismatch(ref cause) => {
write!(f, "{}", cause)
}
UpdateInfrastructureConfigurationError::InvalidRequest(ref cause) => {
write!(f, "{}", cause)
}
UpdateInfrastructureConfigurationError::ResourceInUse(ref cause) => {
write!(f, "{}", cause)
}
UpdateInfrastructureConfigurationError::Service(ref cause) => write!(f, "{}", cause),
UpdateInfrastructureConfigurationError::ServiceUnavailable(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for UpdateInfrastructureConfigurationError {}
#[async_trait]
pub trait ImageBuilder {
async fn cancel_image_creation(
&self,
input: CancelImageCreationRequest,
) -> Result<CancelImageCreationResponse, RusotoError<CancelImageCreationError>>;
async fn create_component(
&self,
input: CreateComponentRequest,
) -> Result<CreateComponentResponse, RusotoError<CreateComponentError>>;
async fn create_container_recipe(
&self,
input: CreateContainerRecipeRequest,
) -> Result<CreateContainerRecipeResponse, RusotoError<CreateContainerRecipeError>>;
async fn create_distribution_configuration(
&self,
input: CreateDistributionConfigurationRequest,
) -> Result<
CreateDistributionConfigurationResponse,
RusotoError<CreateDistributionConfigurationError>,
>;
async fn create_image(
&self,
input: CreateImageRequest,
) -> Result<CreateImageResponse, RusotoError<CreateImageError>>;
async fn create_image_pipeline(
&self,
input: CreateImagePipelineRequest,
) -> Result<CreateImagePipelineResponse, RusotoError<CreateImagePipelineError>>;
async fn create_image_recipe(
&self,
input: CreateImageRecipeRequest,
) -> Result<CreateImageRecipeResponse, RusotoError<CreateImageRecipeError>>;
async fn create_infrastructure_configuration(
&self,
input: CreateInfrastructureConfigurationRequest,
) -> Result<
CreateInfrastructureConfigurationResponse,
RusotoError<CreateInfrastructureConfigurationError>,
>;
async fn delete_component(
&self,
input: DeleteComponentRequest,
) -> Result<DeleteComponentResponse, RusotoError<DeleteComponentError>>;
async fn delete_container_recipe(
&self,
input: DeleteContainerRecipeRequest,
) -> Result<DeleteContainerRecipeResponse, RusotoError<DeleteContainerRecipeError>>;
async fn delete_distribution_configuration(
&self,
input: DeleteDistributionConfigurationRequest,
) -> Result<
DeleteDistributionConfigurationResponse,
RusotoError<DeleteDistributionConfigurationError>,
>;
async fn delete_image(
&self,
input: DeleteImageRequest,
) -> Result<DeleteImageResponse, RusotoError<DeleteImageError>>;
async fn delete_image_pipeline(
&self,
input: DeleteImagePipelineRequest,
) -> Result<DeleteImagePipelineResponse, RusotoError<DeleteImagePipelineError>>;
async fn delete_image_recipe(
&self,
input: DeleteImageRecipeRequest,
) -> Result<DeleteImageRecipeResponse, RusotoError<DeleteImageRecipeError>>;
async fn delete_infrastructure_configuration(
&self,
input: DeleteInfrastructureConfigurationRequest,
) -> Result<
DeleteInfrastructureConfigurationResponse,
RusotoError<DeleteInfrastructureConfigurationError>,
>;
async fn get_component(
&self,
input: GetComponentRequest,
) -> Result<GetComponentResponse, RusotoError<GetComponentError>>;
async fn get_component_policy(
&self,
input: GetComponentPolicyRequest,
) -> Result<GetComponentPolicyResponse, RusotoError<GetComponentPolicyError>>;
async fn get_container_recipe(
&self,
input: GetContainerRecipeRequest,
) -> Result<GetContainerRecipeResponse, RusotoError<GetContainerRecipeError>>;
async fn get_container_recipe_policy(
&self,
input: GetContainerRecipePolicyRequest,
) -> Result<GetContainerRecipePolicyResponse, RusotoError<GetContainerRecipePolicyError>>;
async fn get_distribution_configuration(
&self,
input: GetDistributionConfigurationRequest,
) -> Result<GetDistributionConfigurationResponse, RusotoError<GetDistributionConfigurationError>>;
async fn get_image(
&self,
input: GetImageRequest,
) -> Result<GetImageResponse, RusotoError<GetImageError>>;
async fn get_image_pipeline(
&self,
input: GetImagePipelineRequest,
) -> Result<GetImagePipelineResponse, RusotoError<GetImagePipelineError>>;
async fn get_image_policy(
&self,
input: GetImagePolicyRequest,
) -> Result<GetImagePolicyResponse, RusotoError<GetImagePolicyError>>;
async fn get_image_recipe(
&self,
input: GetImageRecipeRequest,
) -> Result<GetImageRecipeResponse, RusotoError<GetImageRecipeError>>;
async fn get_image_recipe_policy(
&self,
input: GetImageRecipePolicyRequest,
) -> Result<GetImageRecipePolicyResponse, RusotoError<GetImageRecipePolicyError>>;
async fn get_infrastructure_configuration(
&self,
input: GetInfrastructureConfigurationRequest,
) -> Result<
GetInfrastructureConfigurationResponse,
RusotoError<GetInfrastructureConfigurationError>,
>;
async fn import_component(
&self,
input: ImportComponentRequest,
) -> Result<ImportComponentResponse, RusotoError<ImportComponentError>>;
async fn list_component_build_versions(
&self,
input: ListComponentBuildVersionsRequest,
) -> Result<ListComponentBuildVersionsResponse, RusotoError<ListComponentBuildVersionsError>>;
async fn list_components(
&self,
input: ListComponentsRequest,
) -> Result<ListComponentsResponse, RusotoError<ListComponentsError>>;
async fn list_container_recipes(
&self,
input: ListContainerRecipesRequest,
) -> Result<ListContainerRecipesResponse, RusotoError<ListContainerRecipesError>>;
async fn list_distribution_configurations(
&self,
input: ListDistributionConfigurationsRequest,
) -> Result<
ListDistributionConfigurationsResponse,
RusotoError<ListDistributionConfigurationsError>,
>;
async fn list_image_build_versions(
&self,
input: ListImageBuildVersionsRequest,
) -> Result<ListImageBuildVersionsResponse, RusotoError<ListImageBuildVersionsError>>;
async fn list_image_pipeline_images(
&self,
input: ListImagePipelineImagesRequest,
) -> Result<ListImagePipelineImagesResponse, RusotoError<ListImagePipelineImagesError>>;
async fn list_image_pipelines(
&self,
input: ListImagePipelinesRequest,
) -> Result<ListImagePipelinesResponse, RusotoError<ListImagePipelinesError>>;
async fn list_image_recipes(
&self,
input: ListImageRecipesRequest,
) -> Result<ListImageRecipesResponse, RusotoError<ListImageRecipesError>>;
async fn list_images(
&self,
input: ListImagesRequest,
) -> Result<ListImagesResponse, RusotoError<ListImagesError>>;
async fn list_infrastructure_configurations(
&self,
input: ListInfrastructureConfigurationsRequest,
) -> Result<
ListInfrastructureConfigurationsResponse,
RusotoError<ListInfrastructureConfigurationsError>,
>;
async fn list_tags_for_resource(
&self,
input: ListTagsForResourceRequest,
) -> Result<ListTagsForResourceResponse, RusotoError<ListTagsForResourceError>>;
async fn put_component_policy(
&self,
input: PutComponentPolicyRequest,
) -> Result<PutComponentPolicyResponse, RusotoError<PutComponentPolicyError>>;
async fn put_container_recipe_policy(
&self,
input: PutContainerRecipePolicyRequest,
) -> Result<PutContainerRecipePolicyResponse, RusotoError<PutContainerRecipePolicyError>>;
async fn put_image_policy(
&self,
input: PutImagePolicyRequest,
) -> Result<PutImagePolicyResponse, RusotoError<PutImagePolicyError>>;
async fn put_image_recipe_policy(
&self,
input: PutImageRecipePolicyRequest,
) -> Result<PutImageRecipePolicyResponse, RusotoError<PutImageRecipePolicyError>>;
async fn start_image_pipeline_execution(
&self,
input: StartImagePipelineExecutionRequest,
) -> Result<StartImagePipelineExecutionResponse, RusotoError<StartImagePipelineExecutionError>>;
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_distribution_configuration(
&self,
input: UpdateDistributionConfigurationRequest,
) -> Result<
UpdateDistributionConfigurationResponse,
RusotoError<UpdateDistributionConfigurationError>,
>;
async fn update_image_pipeline(
&self,
input: UpdateImagePipelineRequest,
) -> Result<UpdateImagePipelineResponse, RusotoError<UpdateImagePipelineError>>;
async fn update_infrastructure_configuration(
&self,
input: UpdateInfrastructureConfigurationRequest,
) -> Result<
UpdateInfrastructureConfigurationResponse,
RusotoError<UpdateInfrastructureConfigurationError>,
>;
}
#[derive(Clone)]
pub struct ImageBuilderClient {
client: Client,
region: region::Region,
}
impl ImageBuilderClient {
pub fn new(region: region::Region) -> ImageBuilderClient {
ImageBuilderClient {
client: Client::shared(),
region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> ImageBuilderClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
D: DispatchSignedRequest + Send + Sync + 'static,
{
ImageBuilderClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region,
}
}
pub fn new_with_client(client: Client, region: region::Region) -> ImageBuilderClient {
ImageBuilderClient { client, region }
}
}
#[async_trait]
impl ImageBuilder for ImageBuilderClient {
#[allow(unused_mut)]
async fn cancel_image_creation(
&self,
input: CancelImageCreationRequest,
) -> Result<CancelImageCreationResponse, RusotoError<CancelImageCreationError>> {
let request_uri = "/CancelImageCreation";
let mut request = SignedRequest::new("PUT", "imagebuilder", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CancelImageCreationResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CancelImageCreationError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_component(
&self,
input: CreateComponentRequest,
) -> Result<CreateComponentResponse, RusotoError<CreateComponentError>> {
let request_uri = "/CreateComponent";
let mut request = SignedRequest::new("PUT", "imagebuilder", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateComponentResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateComponentError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_container_recipe(
&self,
input: CreateContainerRecipeRequest,
) -> Result<CreateContainerRecipeResponse, RusotoError<CreateContainerRecipeError>> {
let request_uri = "/CreateContainerRecipe";
let mut request = SignedRequest::new("PUT", "imagebuilder", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateContainerRecipeResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateContainerRecipeError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_distribution_configuration(
&self,
input: CreateDistributionConfigurationRequest,
) -> Result<
CreateDistributionConfigurationResponse,
RusotoError<CreateDistributionConfigurationError>,
> {
let request_uri = "/CreateDistributionConfiguration";
let mut request = SignedRequest::new("PUT", "imagebuilder", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateDistributionConfigurationResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateDistributionConfigurationError::from_response(
response,
))
}
}
#[allow(unused_mut)]
async fn create_image(
&self,
input: CreateImageRequest,
) -> Result<CreateImageResponse, RusotoError<CreateImageError>> {
let request_uri = "/CreateImage";
let mut request = SignedRequest::new("PUT", "imagebuilder", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateImageResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateImageError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_image_pipeline(
&self,
input: CreateImagePipelineRequest,
) -> Result<CreateImagePipelineResponse, RusotoError<CreateImagePipelineError>> {
let request_uri = "/CreateImagePipeline";
let mut request = SignedRequest::new("PUT", "imagebuilder", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateImagePipelineResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateImagePipelineError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_image_recipe(
&self,
input: CreateImageRecipeRequest,
) -> Result<CreateImageRecipeResponse, RusotoError<CreateImageRecipeError>> {
let request_uri = "/CreateImageRecipe";
let mut request = SignedRequest::new("PUT", "imagebuilder", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateImageRecipeResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateImageRecipeError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_infrastructure_configuration(
&self,
input: CreateInfrastructureConfigurationRequest,
) -> Result<
CreateInfrastructureConfigurationResponse,
RusotoError<CreateInfrastructureConfigurationError>,
> {
let request_uri = "/CreateInfrastructureConfiguration";
let mut request = SignedRequest::new("PUT", "imagebuilder", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateInfrastructureConfigurationResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateInfrastructureConfigurationError::from_response(
response,
))
}
}
#[allow(unused_mut)]
async fn delete_component(
&self,
input: DeleteComponentRequest,
) -> Result<DeleteComponentResponse, RusotoError<DeleteComponentError>> {
let request_uri = "/DeleteComponent";
let mut request = SignedRequest::new("DELETE", "imagebuilder", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
params.put(
"componentBuildVersionArn",
&input.component_build_version_arn,
);
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteComponentResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteComponentError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_container_recipe(
&self,
input: DeleteContainerRecipeRequest,
) -> Result<DeleteContainerRecipeResponse, RusotoError<DeleteContainerRecipeError>> {
let request_uri = "/DeleteContainerRecipe";
let mut request = SignedRequest::new("DELETE", "imagebuilder", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
params.put("containerRecipeArn", &input.container_recipe_arn);
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteContainerRecipeResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteContainerRecipeError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_distribution_configuration(
&self,
input: DeleteDistributionConfigurationRequest,
) -> Result<
DeleteDistributionConfigurationResponse,
RusotoError<DeleteDistributionConfigurationError>,
> {
let request_uri = "/DeleteDistributionConfiguration";
let mut request = SignedRequest::new("DELETE", "imagebuilder", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
params.put(
"distributionConfigurationArn",
&input.distribution_configuration_arn,
);
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteDistributionConfigurationResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteDistributionConfigurationError::from_response(
response,
))
}
}
#[allow(unused_mut)]
async fn delete_image(
&self,
input: DeleteImageRequest,
) -> Result<DeleteImageResponse, RusotoError<DeleteImageError>> {
let request_uri = "/DeleteImage";
let mut request = SignedRequest::new("DELETE", "imagebuilder", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
params.put("imageBuildVersionArn", &input.image_build_version_arn);
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteImageResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteImageError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_image_pipeline(
&self,
input: DeleteImagePipelineRequest,
) -> Result<DeleteImagePipelineResponse, RusotoError<DeleteImagePipelineError>> {
let request_uri = "/DeleteImagePipeline";
let mut request = SignedRequest::new("DELETE", "imagebuilder", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
params.put("imagePipelineArn", &input.image_pipeline_arn);
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteImagePipelineResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteImagePipelineError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_image_recipe(
&self,
input: DeleteImageRecipeRequest,
) -> Result<DeleteImageRecipeResponse, RusotoError<DeleteImageRecipeError>> {
let request_uri = "/DeleteImageRecipe";
let mut request = SignedRequest::new("DELETE", "imagebuilder", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
params.put("imageRecipeArn", &input.image_recipe_arn);
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteImageRecipeResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteImageRecipeError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_infrastructure_configuration(
&self,
input: DeleteInfrastructureConfigurationRequest,
) -> Result<
DeleteInfrastructureConfigurationResponse,
RusotoError<DeleteInfrastructureConfigurationError>,
> {
let request_uri = "/DeleteInfrastructureConfiguration";
let mut request = SignedRequest::new("DELETE", "imagebuilder", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
params.put(
"infrastructureConfigurationArn",
&input.infrastructure_configuration_arn,
);
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteInfrastructureConfigurationResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteInfrastructureConfigurationError::from_response(
response,
))
}
}
#[allow(unused_mut)]
async fn get_component(
&self,
input: GetComponentRequest,
) -> Result<GetComponentResponse, RusotoError<GetComponentError>> {
let request_uri = "/GetComponent";
let mut request = SignedRequest::new("GET", "imagebuilder", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
params.put(
"componentBuildVersionArn",
&input.component_build_version_arn,
);
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetComponentResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetComponentError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_component_policy(
&self,
input: GetComponentPolicyRequest,
) -> Result<GetComponentPolicyResponse, RusotoError<GetComponentPolicyError>> {
let request_uri = "/GetComponentPolicy";
let mut request = SignedRequest::new("GET", "imagebuilder", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
params.put("componentArn", &input.component_arn);
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetComponentPolicyResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetComponentPolicyError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_container_recipe(
&self,
input: GetContainerRecipeRequest,
) -> Result<GetContainerRecipeResponse, RusotoError<GetContainerRecipeError>> {
let request_uri = "/GetContainerRecipe";
let mut request = SignedRequest::new("GET", "imagebuilder", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
params.put("containerRecipeArn", &input.container_recipe_arn);
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetContainerRecipeResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetContainerRecipeError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_container_recipe_policy(
&self,
input: GetContainerRecipePolicyRequest,
) -> Result<GetContainerRecipePolicyResponse, RusotoError<GetContainerRecipePolicyError>> {
let request_uri = "/GetContainerRecipePolicy";
let mut request = SignedRequest::new("GET", "imagebuilder", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
params.put("containerRecipeArn", &input.container_recipe_arn);
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetContainerRecipePolicyResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetContainerRecipePolicyError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_distribution_configuration(
&self,
input: GetDistributionConfigurationRequest,
) -> Result<GetDistributionConfigurationResponse, RusotoError<GetDistributionConfigurationError>>
{
let request_uri = "/GetDistributionConfiguration";
let mut request = SignedRequest::new("GET", "imagebuilder", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
params.put(
"distributionConfigurationArn",
&input.distribution_configuration_arn,
);
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetDistributionConfigurationResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetDistributionConfigurationError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_image(
&self,
input: GetImageRequest,
) -> Result<GetImageResponse, RusotoError<GetImageError>> {
let request_uri = "/GetImage";
let mut request = SignedRequest::new("GET", "imagebuilder", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
params.put("imageBuildVersionArn", &input.image_build_version_arn);
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetImageResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetImageError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_image_pipeline(
&self,
input: GetImagePipelineRequest,
) -> Result<GetImagePipelineResponse, RusotoError<GetImagePipelineError>> {
let request_uri = "/GetImagePipeline";
let mut request = SignedRequest::new("GET", "imagebuilder", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
params.put("imagePipelineArn", &input.image_pipeline_arn);
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetImagePipelineResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetImagePipelineError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_image_policy(
&self,
input: GetImagePolicyRequest,
) -> Result<GetImagePolicyResponse, RusotoError<GetImagePolicyError>> {
let request_uri = "/GetImagePolicy";
let mut request = SignedRequest::new("GET", "imagebuilder", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
params.put("imageArn", &input.image_arn);
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetImagePolicyResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetImagePolicyError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_image_recipe(
&self,
input: GetImageRecipeRequest,
) -> Result<GetImageRecipeResponse, RusotoError<GetImageRecipeError>> {
let request_uri = "/GetImageRecipe";
let mut request = SignedRequest::new("GET", "imagebuilder", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
params.put("imageRecipeArn", &input.image_recipe_arn);
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetImageRecipeResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetImageRecipeError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_image_recipe_policy(
&self,
input: GetImageRecipePolicyRequest,
) -> Result<GetImageRecipePolicyResponse, RusotoError<GetImageRecipePolicyError>> {
let request_uri = "/GetImageRecipePolicy";
let mut request = SignedRequest::new("GET", "imagebuilder", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
params.put("imageRecipeArn", &input.image_recipe_arn);
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetImageRecipePolicyResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetImageRecipePolicyError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_infrastructure_configuration(
&self,
input: GetInfrastructureConfigurationRequest,
) -> Result<
GetInfrastructureConfigurationResponse,
RusotoError<GetInfrastructureConfigurationError>,
> {
let request_uri = "/GetInfrastructureConfiguration";
let mut request = SignedRequest::new("GET", "imagebuilder", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
params.put(
"infrastructureConfigurationArn",
&input.infrastructure_configuration_arn,
);
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetInfrastructureConfigurationResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetInfrastructureConfigurationError::from_response(response))
}
}
#[allow(unused_mut)]
async fn import_component(
&self,
input: ImportComponentRequest,
) -> Result<ImportComponentResponse, RusotoError<ImportComponentError>> {
let request_uri = "/ImportComponent";
let mut request = SignedRequest::new("PUT", "imagebuilder", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ImportComponentResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ImportComponentError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_component_build_versions(
&self,
input: ListComponentBuildVersionsRequest,
) -> Result<ListComponentBuildVersionsResponse, RusotoError<ListComponentBuildVersionsError>>
{
let request_uri = "/ListComponentBuildVersions";
let mut request = SignedRequest::new("POST", "imagebuilder", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListComponentBuildVersionsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListComponentBuildVersionsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_components(
&self,
input: ListComponentsRequest,
) -> Result<ListComponentsResponse, RusotoError<ListComponentsError>> {
let request_uri = "/ListComponents";
let mut request = SignedRequest::new("POST", "imagebuilder", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListComponentsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListComponentsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_container_recipes(
&self,
input: ListContainerRecipesRequest,
) -> Result<ListContainerRecipesResponse, RusotoError<ListContainerRecipesError>> {
let request_uri = "/ListContainerRecipes";
let mut request = SignedRequest::new("POST", "imagebuilder", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListContainerRecipesResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListContainerRecipesError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_distribution_configurations(
&self,
input: ListDistributionConfigurationsRequest,
) -> Result<
ListDistributionConfigurationsResponse,
RusotoError<ListDistributionConfigurationsError>,
> {
let request_uri = "/ListDistributionConfigurations";
let mut request = SignedRequest::new("POST", "imagebuilder", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListDistributionConfigurationsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListDistributionConfigurationsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_image_build_versions(
&self,
input: ListImageBuildVersionsRequest,
) -> Result<ListImageBuildVersionsResponse, RusotoError<ListImageBuildVersionsError>> {
let request_uri = "/ListImageBuildVersions";
let mut request = SignedRequest::new("POST", "imagebuilder", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListImageBuildVersionsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListImageBuildVersionsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_image_pipeline_images(
&self,
input: ListImagePipelineImagesRequest,
) -> Result<ListImagePipelineImagesResponse, RusotoError<ListImagePipelineImagesError>> {
let request_uri = "/ListImagePipelineImages";
let mut request = SignedRequest::new("POST", "imagebuilder", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListImagePipelineImagesResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListImagePipelineImagesError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_image_pipelines(
&self,
input: ListImagePipelinesRequest,
) -> Result<ListImagePipelinesResponse, RusotoError<ListImagePipelinesError>> {
let request_uri = "/ListImagePipelines";
let mut request = SignedRequest::new("POST", "imagebuilder", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListImagePipelinesResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListImagePipelinesError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_image_recipes(
&self,
input: ListImageRecipesRequest,
) -> Result<ListImageRecipesResponse, RusotoError<ListImageRecipesError>> {
let request_uri = "/ListImageRecipes";
let mut request = SignedRequest::new("POST", "imagebuilder", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListImageRecipesResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListImageRecipesError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_images(
&self,
input: ListImagesRequest,
) -> Result<ListImagesResponse, RusotoError<ListImagesError>> {
let request_uri = "/ListImages";
let mut request = SignedRequest::new("POST", "imagebuilder", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListImagesResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListImagesError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_infrastructure_configurations(
&self,
input: ListInfrastructureConfigurationsRequest,
) -> Result<
ListInfrastructureConfigurationsResponse,
RusotoError<ListInfrastructureConfigurationsError>,
> {
let request_uri = "/ListInfrastructureConfigurations";
let mut request = SignedRequest::new("POST", "imagebuilder", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListInfrastructureConfigurationsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListInfrastructureConfigurationsError::from_response(
response,
))
}
}
#[allow(unused_mut)]
async fn list_tags_for_resource(
&self,
input: ListTagsForResourceRequest,
) -> Result<ListTagsForResourceResponse, RusotoError<ListTagsForResourceError>> {
let request_uri = format!("/tags/{resource_arn}", resource_arn = input.resource_arn);
let mut request = SignedRequest::new("GET", "imagebuilder", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListTagsForResourceResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListTagsForResourceError::from_response(response))
}
}
#[allow(unused_mut)]
async fn put_component_policy(
&self,
input: PutComponentPolicyRequest,
) -> Result<PutComponentPolicyResponse, RusotoError<PutComponentPolicyError>> {
let request_uri = "/PutComponentPolicy";
let mut request = SignedRequest::new("PUT", "imagebuilder", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<PutComponentPolicyResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(PutComponentPolicyError::from_response(response))
}
}
#[allow(unused_mut)]
async fn put_container_recipe_policy(
&self,
input: PutContainerRecipePolicyRequest,
) -> Result<PutContainerRecipePolicyResponse, RusotoError<PutContainerRecipePolicyError>> {
let request_uri = "/PutContainerRecipePolicy";
let mut request = SignedRequest::new("PUT", "imagebuilder", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<PutContainerRecipePolicyResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(PutContainerRecipePolicyError::from_response(response))
}
}
#[allow(unused_mut)]
async fn put_image_policy(
&self,
input: PutImagePolicyRequest,
) -> Result<PutImagePolicyResponse, RusotoError<PutImagePolicyError>> {
let request_uri = "/PutImagePolicy";
let mut request = SignedRequest::new("PUT", "imagebuilder", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<PutImagePolicyResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(PutImagePolicyError::from_response(response))
}
}
#[allow(unused_mut)]
async fn put_image_recipe_policy(
&self,
input: PutImageRecipePolicyRequest,
) -> Result<PutImageRecipePolicyResponse, RusotoError<PutImageRecipePolicyError>> {
let request_uri = "/PutImageRecipePolicy";
let mut request = SignedRequest::new("PUT", "imagebuilder", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<PutImageRecipePolicyResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(PutImageRecipePolicyError::from_response(response))
}
}
#[allow(unused_mut)]
async fn start_image_pipeline_execution(
&self,
input: StartImagePipelineExecutionRequest,
) -> Result<StartImagePipelineExecutionResponse, RusotoError<StartImagePipelineExecutionError>>
{
let request_uri = "/StartImagePipelineExecution";
let mut request = SignedRequest::new("PUT", "imagebuilder", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<StartImagePipelineExecutionResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(StartImagePipelineExecutionError::from_response(response))
}
}
#[allow(unused_mut)]
async fn tag_resource(
&self,
input: TagResourceRequest,
) -> Result<TagResourceResponse, RusotoError<TagResourceError>> {
let request_uri = format!("/tags/{resource_arn}", resource_arn = input.resource_arn);
let mut request = SignedRequest::new("POST", "imagebuilder", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<TagResourceResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(TagResourceError::from_response(response))
}
}
#[allow(unused_mut)]
async fn untag_resource(
&self,
input: UntagResourceRequest,
) -> Result<UntagResourceResponse, RusotoError<UntagResourceError>> {
let request_uri = format!("/tags/{resource_arn}", resource_arn = input.resource_arn);
let mut request = SignedRequest::new("DELETE", "imagebuilder", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
for item in input.tag_keys.iter() {
params.put("tagKeys", item);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UntagResourceResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UntagResourceError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_distribution_configuration(
&self,
input: UpdateDistributionConfigurationRequest,
) -> Result<
UpdateDistributionConfigurationResponse,
RusotoError<UpdateDistributionConfigurationError>,
> {
let request_uri = "/UpdateDistributionConfiguration";
let mut request = SignedRequest::new("PUT", "imagebuilder", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateDistributionConfigurationResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateDistributionConfigurationError::from_response(
response,
))
}
}
#[allow(unused_mut)]
async fn update_image_pipeline(
&self,
input: UpdateImagePipelineRequest,
) -> Result<UpdateImagePipelineResponse, RusotoError<UpdateImagePipelineError>> {
let request_uri = "/UpdateImagePipeline";
let mut request = SignedRequest::new("PUT", "imagebuilder", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateImagePipelineResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateImagePipelineError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_infrastructure_configuration(
&self,
input: UpdateInfrastructureConfigurationRequest,
) -> Result<
UpdateInfrastructureConfigurationResponse,
RusotoError<UpdateInfrastructureConfigurationError>,
> {
let request_uri = "/UpdateInfrastructureConfiguration";
let mut request = SignedRequest::new("PUT", "imagebuilder", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateInfrastructureConfigurationResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateInfrastructureConfigurationError::from_response(
response,
))
}
}
}