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 ApplicationDependencySummary {
#[serde(rename = "ApplicationId")]
pub application_id: String,
#[serde(rename = "SemanticVersion")]
pub semantic_version: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ApplicationPolicyStatement {
#[serde(rename = "Actions")]
pub actions: Vec<String>,
#[serde(rename = "PrincipalOrgIDs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub principal_org_i_ds: Option<Vec<String>>,
#[serde(rename = "Principals")]
pub principals: Vec<String>,
#[serde(rename = "StatementId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub statement_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ApplicationSummary {
#[serde(rename = "ApplicationId")]
pub application_id: String,
#[serde(rename = "Author")]
pub author: String,
#[serde(rename = "CreationTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_time: Option<String>,
#[serde(rename = "Description")]
pub description: String,
#[serde(rename = "HomePageUrl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub home_page_url: Option<String>,
#[serde(rename = "Labels")]
#[serde(skip_serializing_if = "Option::is_none")]
pub labels: Option<Vec<String>>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "SpdxLicenseId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub spdx_license_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateApplicationRequest {
#[serde(rename = "Author")]
pub author: String,
#[serde(rename = "Description")]
pub description: String,
#[serde(rename = "HomePageUrl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub home_page_url: Option<String>,
#[serde(rename = "Labels")]
#[serde(skip_serializing_if = "Option::is_none")]
pub labels: Option<Vec<String>>,
#[serde(rename = "LicenseBody")]
#[serde(skip_serializing_if = "Option::is_none")]
pub license_body: Option<String>,
#[serde(rename = "LicenseUrl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub license_url: Option<String>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "ReadmeBody")]
#[serde(skip_serializing_if = "Option::is_none")]
pub readme_body: Option<String>,
#[serde(rename = "ReadmeUrl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub readme_url: Option<String>,
#[serde(rename = "SemanticVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub semantic_version: Option<String>,
#[serde(rename = "SourceCodeArchiveUrl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_code_archive_url: Option<String>,
#[serde(rename = "SourceCodeUrl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_code_url: Option<String>,
#[serde(rename = "SpdxLicenseId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub spdx_license_id: Option<String>,
#[serde(rename = "TemplateBody")]
#[serde(skip_serializing_if = "Option::is_none")]
pub template_body: Option<String>,
#[serde(rename = "TemplateUrl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub template_url: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateApplicationResponse {
#[serde(rename = "ApplicationId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_id: Option<String>,
#[serde(rename = "Author")]
#[serde(skip_serializing_if = "Option::is_none")]
pub author: Option<String>,
#[serde(rename = "CreationTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_time: Option<String>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "HomePageUrl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub home_page_url: Option<String>,
#[serde(rename = "IsVerifiedAuthor")]
#[serde(skip_serializing_if = "Option::is_none")]
pub is_verified_author: Option<bool>,
#[serde(rename = "Labels")]
#[serde(skip_serializing_if = "Option::is_none")]
pub labels: Option<Vec<String>>,
#[serde(rename = "LicenseUrl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub license_url: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "ReadmeUrl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub readme_url: Option<String>,
#[serde(rename = "SpdxLicenseId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub spdx_license_id: Option<String>,
#[serde(rename = "VerifiedAuthorUrl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub verified_author_url: Option<String>,
#[serde(rename = "Version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<Version>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateApplicationVersionRequest {
#[serde(rename = "ApplicationId")]
pub application_id: String,
#[serde(rename = "SemanticVersion")]
pub semantic_version: String,
#[serde(rename = "SourceCodeArchiveUrl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_code_archive_url: Option<String>,
#[serde(rename = "SourceCodeUrl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_code_url: Option<String>,
#[serde(rename = "TemplateBody")]
#[serde(skip_serializing_if = "Option::is_none")]
pub template_body: Option<String>,
#[serde(rename = "TemplateUrl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub template_url: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateApplicationVersionResponse {
#[serde(rename = "ApplicationId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_id: Option<String>,
#[serde(rename = "CreationTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_time: Option<String>,
#[serde(rename = "ParameterDefinitions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub parameter_definitions: Option<Vec<ParameterDefinition>>,
#[serde(rename = "RequiredCapabilities")]
#[serde(skip_serializing_if = "Option::is_none")]
pub required_capabilities: Option<Vec<String>>,
#[serde(rename = "ResourcesSupported")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resources_supported: Option<bool>,
#[serde(rename = "SemanticVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub semantic_version: Option<String>,
#[serde(rename = "SourceCodeArchiveUrl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_code_archive_url: Option<String>,
#[serde(rename = "SourceCodeUrl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_code_url: Option<String>,
#[serde(rename = "TemplateUrl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub template_url: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateCloudFormationChangeSetRequest {
#[serde(rename = "ApplicationId")]
pub application_id: String,
#[serde(rename = "Capabilities")]
#[serde(skip_serializing_if = "Option::is_none")]
pub capabilities: Option<Vec<String>>,
#[serde(rename = "ChangeSetName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub change_set_name: Option<String>,
#[serde(rename = "ClientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_token: Option<String>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "NotificationArns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub notification_arns: Option<Vec<String>>,
#[serde(rename = "ParameterOverrides")]
#[serde(skip_serializing_if = "Option::is_none")]
pub parameter_overrides: Option<Vec<ParameterValue>>,
#[serde(rename = "ResourceTypes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_types: Option<Vec<String>>,
#[serde(rename = "RollbackConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub rollback_configuration: Option<RollbackConfiguration>,
#[serde(rename = "SemanticVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub semantic_version: Option<String>,
#[serde(rename = "StackName")]
pub stack_name: String,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
#[serde(rename = "TemplateId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub template_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateCloudFormationChangeSetResponse {
#[serde(rename = "ApplicationId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_id: Option<String>,
#[serde(rename = "ChangeSetId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub change_set_id: Option<String>,
#[serde(rename = "SemanticVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub semantic_version: Option<String>,
#[serde(rename = "StackId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stack_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateCloudFormationTemplateRequest {
#[serde(rename = "ApplicationId")]
pub application_id: String,
#[serde(rename = "SemanticVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub semantic_version: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateCloudFormationTemplateResponse {
#[serde(rename = "ApplicationId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_id: Option<String>,
#[serde(rename = "CreationTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_time: Option<String>,
#[serde(rename = "ExpirationTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub expiration_time: Option<String>,
#[serde(rename = "SemanticVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub semantic_version: Option<String>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "TemplateId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub template_id: Option<String>,
#[serde(rename = "TemplateUrl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub template_url: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteApplicationRequest {
#[serde(rename = "ApplicationId")]
pub application_id: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetApplicationPolicyRequest {
#[serde(rename = "ApplicationId")]
pub application_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetApplicationPolicyResponse {
#[serde(rename = "Statements")]
#[serde(skip_serializing_if = "Option::is_none")]
pub statements: Option<Vec<ApplicationPolicyStatement>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetApplicationRequest {
#[serde(rename = "ApplicationId")]
pub application_id: String,
#[serde(rename = "SemanticVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub semantic_version: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetApplicationResponse {
#[serde(rename = "ApplicationId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_id: Option<String>,
#[serde(rename = "Author")]
#[serde(skip_serializing_if = "Option::is_none")]
pub author: Option<String>,
#[serde(rename = "CreationTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_time: Option<String>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "HomePageUrl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub home_page_url: Option<String>,
#[serde(rename = "IsVerifiedAuthor")]
#[serde(skip_serializing_if = "Option::is_none")]
pub is_verified_author: Option<bool>,
#[serde(rename = "Labels")]
#[serde(skip_serializing_if = "Option::is_none")]
pub labels: Option<Vec<String>>,
#[serde(rename = "LicenseUrl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub license_url: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "ReadmeUrl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub readme_url: Option<String>,
#[serde(rename = "SpdxLicenseId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub spdx_license_id: Option<String>,
#[serde(rename = "VerifiedAuthorUrl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub verified_author_url: Option<String>,
#[serde(rename = "Version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<Version>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetCloudFormationTemplateRequest {
#[serde(rename = "ApplicationId")]
pub application_id: String,
#[serde(rename = "TemplateId")]
pub template_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetCloudFormationTemplateResponse {
#[serde(rename = "ApplicationId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_id: Option<String>,
#[serde(rename = "CreationTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_time: Option<String>,
#[serde(rename = "ExpirationTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub expiration_time: Option<String>,
#[serde(rename = "SemanticVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub semantic_version: Option<String>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "TemplateId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub template_id: Option<String>,
#[serde(rename = "TemplateUrl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub template_url: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListApplicationDependenciesRequest {
#[serde(rename = "ApplicationId")]
pub application_id: String,
#[serde(rename = "MaxItems")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_items: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "SemanticVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub semantic_version: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListApplicationDependenciesResponse {
#[serde(rename = "Dependencies")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dependencies: Option<Vec<ApplicationDependencySummary>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListApplicationVersionsRequest {
#[serde(rename = "ApplicationId")]
pub application_id: String,
#[serde(rename = "MaxItems")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_items: 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 ListApplicationVersionsResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Versions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub versions: Option<Vec<VersionSummary>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListApplicationsRequest {
#[serde(rename = "MaxItems")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_items: 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 ListApplicationsResponse {
#[serde(rename = "Applications")]
#[serde(skip_serializing_if = "Option::is_none")]
pub applications: Option<Vec<ApplicationSummary>>,
#[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 ParameterDefinition {
#[serde(rename = "AllowedPattern")]
#[serde(skip_serializing_if = "Option::is_none")]
pub allowed_pattern: Option<String>,
#[serde(rename = "AllowedValues")]
#[serde(skip_serializing_if = "Option::is_none")]
pub allowed_values: Option<Vec<String>>,
#[serde(rename = "ConstraintDescription")]
#[serde(skip_serializing_if = "Option::is_none")]
pub constraint_description: Option<String>,
#[serde(rename = "DefaultValue")]
#[serde(skip_serializing_if = "Option::is_none")]
pub default_value: Option<String>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "MaxLength")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_length: Option<i64>,
#[serde(rename = "MaxValue")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_value: Option<i64>,
#[serde(rename = "MinLength")]
#[serde(skip_serializing_if = "Option::is_none")]
pub min_length: Option<i64>,
#[serde(rename = "MinValue")]
#[serde(skip_serializing_if = "Option::is_none")]
pub min_value: Option<i64>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "NoEcho")]
#[serde(skip_serializing_if = "Option::is_none")]
pub no_echo: Option<bool>,
#[serde(rename = "ReferencedByResources")]
pub referenced_by_resources: Vec<String>,
#[serde(rename = "Type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ParameterValue {
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "Value")]
pub value: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PutApplicationPolicyRequest {
#[serde(rename = "ApplicationId")]
pub application_id: String,
#[serde(rename = "Statements")]
pub statements: Vec<ApplicationPolicyStatement>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PutApplicationPolicyResponse {
#[serde(rename = "Statements")]
#[serde(skip_serializing_if = "Option::is_none")]
pub statements: Option<Vec<ApplicationPolicyStatement>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct RollbackConfiguration {
#[serde(rename = "MonitoringTimeInMinutes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub monitoring_time_in_minutes: Option<i64>,
#[serde(rename = "RollbackTriggers")]
#[serde(skip_serializing_if = "Option::is_none")]
pub rollback_triggers: Option<Vec<RollbackTrigger>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct RollbackTrigger {
#[serde(rename = "Arn")]
pub arn: String,
#[serde(rename = "Type")]
pub type_: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct Tag {
#[serde(rename = "Key")]
pub key: String,
#[serde(rename = "Value")]
pub value: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UnshareApplicationRequest {
#[serde(rename = "ApplicationId")]
pub application_id: String,
#[serde(rename = "OrganizationId")]
pub organization_id: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateApplicationRequest {
#[serde(rename = "ApplicationId")]
pub application_id: String,
#[serde(rename = "Author")]
#[serde(skip_serializing_if = "Option::is_none")]
pub author: Option<String>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "HomePageUrl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub home_page_url: Option<String>,
#[serde(rename = "Labels")]
#[serde(skip_serializing_if = "Option::is_none")]
pub labels: Option<Vec<String>>,
#[serde(rename = "ReadmeBody")]
#[serde(skip_serializing_if = "Option::is_none")]
pub readme_body: Option<String>,
#[serde(rename = "ReadmeUrl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub readme_url: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateApplicationResponse {
#[serde(rename = "ApplicationId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_id: Option<String>,
#[serde(rename = "Author")]
#[serde(skip_serializing_if = "Option::is_none")]
pub author: Option<String>,
#[serde(rename = "CreationTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_time: Option<String>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "HomePageUrl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub home_page_url: Option<String>,
#[serde(rename = "IsVerifiedAuthor")]
#[serde(skip_serializing_if = "Option::is_none")]
pub is_verified_author: Option<bool>,
#[serde(rename = "Labels")]
#[serde(skip_serializing_if = "Option::is_none")]
pub labels: Option<Vec<String>>,
#[serde(rename = "LicenseUrl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub license_url: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "ReadmeUrl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub readme_url: Option<String>,
#[serde(rename = "SpdxLicenseId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub spdx_license_id: Option<String>,
#[serde(rename = "VerifiedAuthorUrl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub verified_author_url: Option<String>,
#[serde(rename = "Version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<Version>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Version {
#[serde(rename = "ApplicationId")]
pub application_id: String,
#[serde(rename = "CreationTime")]
pub creation_time: String,
#[serde(rename = "ParameterDefinitions")]
pub parameter_definitions: Vec<ParameterDefinition>,
#[serde(rename = "RequiredCapabilities")]
pub required_capabilities: Vec<String>,
#[serde(rename = "ResourcesSupported")]
pub resources_supported: bool,
#[serde(rename = "SemanticVersion")]
pub semantic_version: String,
#[serde(rename = "SourceCodeArchiveUrl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_code_archive_url: Option<String>,
#[serde(rename = "SourceCodeUrl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_code_url: Option<String>,
#[serde(rename = "TemplateUrl")]
pub template_url: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct VersionSummary {
#[serde(rename = "ApplicationId")]
pub application_id: String,
#[serde(rename = "CreationTime")]
pub creation_time: String,
#[serde(rename = "SemanticVersion")]
pub semantic_version: String,
#[serde(rename = "SourceCodeUrl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_code_url: Option<String>,
}
#[derive(Debug, PartialEq)]
pub enum CreateApplicationError {
BadRequest(String),
Conflict(String),
Forbidden(String),
InternalServerError(String),
TooManyRequests(String),
}
impl CreateApplicationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateApplicationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(CreateApplicationError::BadRequest(err.msg))
}
"ConflictException" => {
return RusotoError::Service(CreateApplicationError::Conflict(err.msg))
}
"ForbiddenException" => {
return RusotoError::Service(CreateApplicationError::Forbidden(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(CreateApplicationError::InternalServerError(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(CreateApplicationError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateApplicationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateApplicationError::BadRequest(ref cause) => write!(f, "{}", cause),
CreateApplicationError::Conflict(ref cause) => write!(f, "{}", cause),
CreateApplicationError::Forbidden(ref cause) => write!(f, "{}", cause),
CreateApplicationError::InternalServerError(ref cause) => write!(f, "{}", cause),
CreateApplicationError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateApplicationError {}
#[derive(Debug, PartialEq)]
pub enum CreateApplicationVersionError {
BadRequest(String),
Conflict(String),
Forbidden(String),
InternalServerError(String),
TooManyRequests(String),
}
impl CreateApplicationVersionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateApplicationVersionError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(CreateApplicationVersionError::BadRequest(err.msg))
}
"ConflictException" => {
return RusotoError::Service(CreateApplicationVersionError::Conflict(err.msg))
}
"ForbiddenException" => {
return RusotoError::Service(CreateApplicationVersionError::Forbidden(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(
CreateApplicationVersionError::InternalServerError(err.msg),
)
}
"TooManyRequestsException" => {
return RusotoError::Service(CreateApplicationVersionError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateApplicationVersionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateApplicationVersionError::BadRequest(ref cause) => write!(f, "{}", cause),
CreateApplicationVersionError::Conflict(ref cause) => write!(f, "{}", cause),
CreateApplicationVersionError::Forbidden(ref cause) => write!(f, "{}", cause),
CreateApplicationVersionError::InternalServerError(ref cause) => write!(f, "{}", cause),
CreateApplicationVersionError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateApplicationVersionError {}
#[derive(Debug, PartialEq)]
pub enum CreateCloudFormationChangeSetError {
BadRequest(String),
Forbidden(String),
InternalServerError(String),
TooManyRequests(String),
}
impl CreateCloudFormationChangeSetError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<CreateCloudFormationChangeSetError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(CreateCloudFormationChangeSetError::BadRequest(
err.msg,
))
}
"ForbiddenException" => {
return RusotoError::Service(CreateCloudFormationChangeSetError::Forbidden(
err.msg,
))
}
"InternalServerErrorException" => {
return RusotoError::Service(
CreateCloudFormationChangeSetError::InternalServerError(err.msg),
)
}
"TooManyRequestsException" => {
return RusotoError::Service(
CreateCloudFormationChangeSetError::TooManyRequests(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateCloudFormationChangeSetError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateCloudFormationChangeSetError::BadRequest(ref cause) => write!(f, "{}", cause),
CreateCloudFormationChangeSetError::Forbidden(ref cause) => write!(f, "{}", cause),
CreateCloudFormationChangeSetError::InternalServerError(ref cause) => {
write!(f, "{}", cause)
}
CreateCloudFormationChangeSetError::TooManyRequests(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for CreateCloudFormationChangeSetError {}
#[derive(Debug, PartialEq)]
pub enum CreateCloudFormationTemplateError {
BadRequest(String),
Forbidden(String),
InternalServerError(String),
NotFound(String),
TooManyRequests(String),
}
impl CreateCloudFormationTemplateError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<CreateCloudFormationTemplateError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(CreateCloudFormationTemplateError::BadRequest(
err.msg,
))
}
"ForbiddenException" => {
return RusotoError::Service(CreateCloudFormationTemplateError::Forbidden(
err.msg,
))
}
"InternalServerErrorException" => {
return RusotoError::Service(
CreateCloudFormationTemplateError::InternalServerError(err.msg),
)
}
"NotFoundException" => {
return RusotoError::Service(CreateCloudFormationTemplateError::NotFound(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(
CreateCloudFormationTemplateError::TooManyRequests(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateCloudFormationTemplateError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateCloudFormationTemplateError::BadRequest(ref cause) => write!(f, "{}", cause),
CreateCloudFormationTemplateError::Forbidden(ref cause) => write!(f, "{}", cause),
CreateCloudFormationTemplateError::InternalServerError(ref cause) => {
write!(f, "{}", cause)
}
CreateCloudFormationTemplateError::NotFound(ref cause) => write!(f, "{}", cause),
CreateCloudFormationTemplateError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateCloudFormationTemplateError {}
#[derive(Debug, PartialEq)]
pub enum DeleteApplicationError {
BadRequest(String),
Conflict(String),
Forbidden(String),
InternalServerError(String),
NotFound(String),
TooManyRequests(String),
}
impl DeleteApplicationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteApplicationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(DeleteApplicationError::BadRequest(err.msg))
}
"ConflictException" => {
return RusotoError::Service(DeleteApplicationError::Conflict(err.msg))
}
"ForbiddenException" => {
return RusotoError::Service(DeleteApplicationError::Forbidden(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(DeleteApplicationError::InternalServerError(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(DeleteApplicationError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(DeleteApplicationError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteApplicationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteApplicationError::BadRequest(ref cause) => write!(f, "{}", cause),
DeleteApplicationError::Conflict(ref cause) => write!(f, "{}", cause),
DeleteApplicationError::Forbidden(ref cause) => write!(f, "{}", cause),
DeleteApplicationError::InternalServerError(ref cause) => write!(f, "{}", cause),
DeleteApplicationError::NotFound(ref cause) => write!(f, "{}", cause),
DeleteApplicationError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteApplicationError {}
#[derive(Debug, PartialEq)]
pub enum GetApplicationError {
BadRequest(String),
Forbidden(String),
InternalServerError(String),
NotFound(String),
TooManyRequests(String),
}
impl GetApplicationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetApplicationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetApplicationError::BadRequest(err.msg))
}
"ForbiddenException" => {
return RusotoError::Service(GetApplicationError::Forbidden(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(GetApplicationError::InternalServerError(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetApplicationError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(GetApplicationError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetApplicationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetApplicationError::BadRequest(ref cause) => write!(f, "{}", cause),
GetApplicationError::Forbidden(ref cause) => write!(f, "{}", cause),
GetApplicationError::InternalServerError(ref cause) => write!(f, "{}", cause),
GetApplicationError::NotFound(ref cause) => write!(f, "{}", cause),
GetApplicationError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetApplicationError {}
#[derive(Debug, PartialEq)]
pub enum GetApplicationPolicyError {
BadRequest(String),
Forbidden(String),
InternalServerError(String),
NotFound(String),
TooManyRequests(String),
}
impl GetApplicationPolicyError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetApplicationPolicyError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetApplicationPolicyError::BadRequest(err.msg))
}
"ForbiddenException" => {
return RusotoError::Service(GetApplicationPolicyError::Forbidden(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(GetApplicationPolicyError::InternalServerError(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(GetApplicationPolicyError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(GetApplicationPolicyError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetApplicationPolicyError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetApplicationPolicyError::BadRequest(ref cause) => write!(f, "{}", cause),
GetApplicationPolicyError::Forbidden(ref cause) => write!(f, "{}", cause),
GetApplicationPolicyError::InternalServerError(ref cause) => write!(f, "{}", cause),
GetApplicationPolicyError::NotFound(ref cause) => write!(f, "{}", cause),
GetApplicationPolicyError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetApplicationPolicyError {}
#[derive(Debug, PartialEq)]
pub enum GetCloudFormationTemplateError {
BadRequest(String),
Forbidden(String),
InternalServerError(String),
NotFound(String),
TooManyRequests(String),
}
impl GetCloudFormationTemplateError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetCloudFormationTemplateError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetCloudFormationTemplateError::BadRequest(
err.msg,
))
}
"ForbiddenException" => {
return RusotoError::Service(GetCloudFormationTemplateError::Forbidden(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(
GetCloudFormationTemplateError::InternalServerError(err.msg),
)
}
"NotFoundException" => {
return RusotoError::Service(GetCloudFormationTemplateError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(GetCloudFormationTemplateError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetCloudFormationTemplateError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetCloudFormationTemplateError::BadRequest(ref cause) => write!(f, "{}", cause),
GetCloudFormationTemplateError::Forbidden(ref cause) => write!(f, "{}", cause),
GetCloudFormationTemplateError::InternalServerError(ref cause) => {
write!(f, "{}", cause)
}
GetCloudFormationTemplateError::NotFound(ref cause) => write!(f, "{}", cause),
GetCloudFormationTemplateError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetCloudFormationTemplateError {}
#[derive(Debug, PartialEq)]
pub enum ListApplicationDependenciesError {
BadRequest(String),
Forbidden(String),
InternalServerError(String),
NotFound(String),
TooManyRequests(String),
}
impl ListApplicationDependenciesError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListApplicationDependenciesError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(ListApplicationDependenciesError::BadRequest(
err.msg,
))
}
"ForbiddenException" => {
return RusotoError::Service(ListApplicationDependenciesError::Forbidden(
err.msg,
))
}
"InternalServerErrorException" => {
return RusotoError::Service(
ListApplicationDependenciesError::InternalServerError(err.msg),
)
}
"NotFoundException" => {
return RusotoError::Service(ListApplicationDependenciesError::NotFound(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(ListApplicationDependenciesError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListApplicationDependenciesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListApplicationDependenciesError::BadRequest(ref cause) => write!(f, "{}", cause),
ListApplicationDependenciesError::Forbidden(ref cause) => write!(f, "{}", cause),
ListApplicationDependenciesError::InternalServerError(ref cause) => {
write!(f, "{}", cause)
}
ListApplicationDependenciesError::NotFound(ref cause) => write!(f, "{}", cause),
ListApplicationDependenciesError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListApplicationDependenciesError {}
#[derive(Debug, PartialEq)]
pub enum ListApplicationVersionsError {
BadRequest(String),
Forbidden(String),
InternalServerError(String),
NotFound(String),
TooManyRequests(String),
}
impl ListApplicationVersionsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListApplicationVersionsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(ListApplicationVersionsError::BadRequest(err.msg))
}
"ForbiddenException" => {
return RusotoError::Service(ListApplicationVersionsError::Forbidden(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(ListApplicationVersionsError::InternalServerError(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(ListApplicationVersionsError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(ListApplicationVersionsError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListApplicationVersionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListApplicationVersionsError::BadRequest(ref cause) => write!(f, "{}", cause),
ListApplicationVersionsError::Forbidden(ref cause) => write!(f, "{}", cause),
ListApplicationVersionsError::InternalServerError(ref cause) => write!(f, "{}", cause),
ListApplicationVersionsError::NotFound(ref cause) => write!(f, "{}", cause),
ListApplicationVersionsError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListApplicationVersionsError {}
#[derive(Debug, PartialEq)]
pub enum ListApplicationsError {
BadRequest(String),
Forbidden(String),
InternalServerError(String),
NotFound(String),
}
impl ListApplicationsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListApplicationsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(ListApplicationsError::BadRequest(err.msg))
}
"ForbiddenException" => {
return RusotoError::Service(ListApplicationsError::Forbidden(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(ListApplicationsError::InternalServerError(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(ListApplicationsError::NotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListApplicationsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListApplicationsError::BadRequest(ref cause) => write!(f, "{}", cause),
ListApplicationsError::Forbidden(ref cause) => write!(f, "{}", cause),
ListApplicationsError::InternalServerError(ref cause) => write!(f, "{}", cause),
ListApplicationsError::NotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListApplicationsError {}
#[derive(Debug, PartialEq)]
pub enum PutApplicationPolicyError {
BadRequest(String),
Forbidden(String),
InternalServerError(String),
NotFound(String),
TooManyRequests(String),
}
impl PutApplicationPolicyError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<PutApplicationPolicyError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(PutApplicationPolicyError::BadRequest(err.msg))
}
"ForbiddenException" => {
return RusotoError::Service(PutApplicationPolicyError::Forbidden(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(PutApplicationPolicyError::InternalServerError(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(PutApplicationPolicyError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(PutApplicationPolicyError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for PutApplicationPolicyError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PutApplicationPolicyError::BadRequest(ref cause) => write!(f, "{}", cause),
PutApplicationPolicyError::Forbidden(ref cause) => write!(f, "{}", cause),
PutApplicationPolicyError::InternalServerError(ref cause) => write!(f, "{}", cause),
PutApplicationPolicyError::NotFound(ref cause) => write!(f, "{}", cause),
PutApplicationPolicyError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for PutApplicationPolicyError {}
#[derive(Debug, PartialEq)]
pub enum UnshareApplicationError {
BadRequest(String),
Forbidden(String),
InternalServerError(String),
NotFound(String),
TooManyRequests(String),
}
impl UnshareApplicationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UnshareApplicationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(UnshareApplicationError::BadRequest(err.msg))
}
"ForbiddenException" => {
return RusotoError::Service(UnshareApplicationError::Forbidden(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(UnshareApplicationError::InternalServerError(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(UnshareApplicationError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(UnshareApplicationError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UnshareApplicationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UnshareApplicationError::BadRequest(ref cause) => write!(f, "{}", cause),
UnshareApplicationError::Forbidden(ref cause) => write!(f, "{}", cause),
UnshareApplicationError::InternalServerError(ref cause) => write!(f, "{}", cause),
UnshareApplicationError::NotFound(ref cause) => write!(f, "{}", cause),
UnshareApplicationError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UnshareApplicationError {}
#[derive(Debug, PartialEq)]
pub enum UpdateApplicationError {
BadRequest(String),
Conflict(String),
Forbidden(String),
InternalServerError(String),
NotFound(String),
TooManyRequests(String),
}
impl UpdateApplicationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateApplicationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(UpdateApplicationError::BadRequest(err.msg))
}
"ConflictException" => {
return RusotoError::Service(UpdateApplicationError::Conflict(err.msg))
}
"ForbiddenException" => {
return RusotoError::Service(UpdateApplicationError::Forbidden(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(UpdateApplicationError::InternalServerError(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(UpdateApplicationError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(UpdateApplicationError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateApplicationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateApplicationError::BadRequest(ref cause) => write!(f, "{}", cause),
UpdateApplicationError::Conflict(ref cause) => write!(f, "{}", cause),
UpdateApplicationError::Forbidden(ref cause) => write!(f, "{}", cause),
UpdateApplicationError::InternalServerError(ref cause) => write!(f, "{}", cause),
UpdateApplicationError::NotFound(ref cause) => write!(f, "{}", cause),
UpdateApplicationError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateApplicationError {}
#[async_trait]
pub trait ServerlessRepo {
async fn create_application(
&self,
input: CreateApplicationRequest,
) -> Result<CreateApplicationResponse, RusotoError<CreateApplicationError>>;
async fn create_application_version(
&self,
input: CreateApplicationVersionRequest,
) -> Result<CreateApplicationVersionResponse, RusotoError<CreateApplicationVersionError>>;
async fn create_cloud_formation_change_set(
&self,
input: CreateCloudFormationChangeSetRequest,
) -> Result<
CreateCloudFormationChangeSetResponse,
RusotoError<CreateCloudFormationChangeSetError>,
>;
async fn create_cloud_formation_template(
&self,
input: CreateCloudFormationTemplateRequest,
) -> Result<CreateCloudFormationTemplateResponse, RusotoError<CreateCloudFormationTemplateError>>;
async fn delete_application(
&self,
input: DeleteApplicationRequest,
) -> Result<(), RusotoError<DeleteApplicationError>>;
async fn get_application(
&self,
input: GetApplicationRequest,
) -> Result<GetApplicationResponse, RusotoError<GetApplicationError>>;
async fn get_application_policy(
&self,
input: GetApplicationPolicyRequest,
) -> Result<GetApplicationPolicyResponse, RusotoError<GetApplicationPolicyError>>;
async fn get_cloud_formation_template(
&self,
input: GetCloudFormationTemplateRequest,
) -> Result<GetCloudFormationTemplateResponse, RusotoError<GetCloudFormationTemplateError>>;
async fn list_application_dependencies(
&self,
input: ListApplicationDependenciesRequest,
) -> Result<ListApplicationDependenciesResponse, RusotoError<ListApplicationDependenciesError>>;
async fn list_application_versions(
&self,
input: ListApplicationVersionsRequest,
) -> Result<ListApplicationVersionsResponse, RusotoError<ListApplicationVersionsError>>;
async fn list_applications(
&self,
input: ListApplicationsRequest,
) -> Result<ListApplicationsResponse, RusotoError<ListApplicationsError>>;
async fn put_application_policy(
&self,
input: PutApplicationPolicyRequest,
) -> Result<PutApplicationPolicyResponse, RusotoError<PutApplicationPolicyError>>;
async fn unshare_application(
&self,
input: UnshareApplicationRequest,
) -> Result<(), RusotoError<UnshareApplicationError>>;
async fn update_application(
&self,
input: UpdateApplicationRequest,
) -> Result<UpdateApplicationResponse, RusotoError<UpdateApplicationError>>;
}
#[derive(Clone)]
pub struct ServerlessRepoClient {
client: Client,
region: region::Region,
}
impl ServerlessRepoClient {
pub fn new(region: region::Region) -> ServerlessRepoClient {
ServerlessRepoClient {
client: Client::shared(),
region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> ServerlessRepoClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
D: DispatchSignedRequest + Send + Sync + 'static,
{
ServerlessRepoClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region,
}
}
pub fn new_with_client(client: Client, region: region::Region) -> ServerlessRepoClient {
ServerlessRepoClient { client, region }
}
}
#[async_trait]
impl ServerlessRepo for ServerlessRepoClient {
#[allow(unused_mut)]
async fn create_application(
&self,
input: CreateApplicationRequest,
) -> Result<CreateApplicationResponse, RusotoError<CreateApplicationError>> {
let request_uri = "/applications";
let mut request = SignedRequest::new("POST", "serverlessrepo", &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.as_u16() == 201 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateApplicationResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateApplicationError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_application_version(
&self,
input: CreateApplicationVersionRequest,
) -> Result<CreateApplicationVersionResponse, RusotoError<CreateApplicationVersionError>> {
let request_uri = format!(
"/applications/{application_id}/versions/{semantic_version}",
application_id = input.application_id,
semantic_version = input.semantic_version
);
let mut request = SignedRequest::new("PUT", "serverlessrepo", &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.as_u16() == 201 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateApplicationVersionResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateApplicationVersionError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_cloud_formation_change_set(
&self,
input: CreateCloudFormationChangeSetRequest,
) -> Result<
CreateCloudFormationChangeSetResponse,
RusotoError<CreateCloudFormationChangeSetError>,
> {
let request_uri = format!(
"/applications/{application_id}/changesets",
application_id = input.application_id
);
let mut request = SignedRequest::new("POST", "serverlessrepo", &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.as_u16() == 201 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateCloudFormationChangeSetResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateCloudFormationChangeSetError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_cloud_formation_template(
&self,
input: CreateCloudFormationTemplateRequest,
) -> Result<CreateCloudFormationTemplateResponse, RusotoError<CreateCloudFormationTemplateError>>
{
let request_uri = format!(
"/applications/{application_id}/templates",
application_id = input.application_id
);
let mut request = SignedRequest::new("POST", "serverlessrepo", &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.as_u16() == 201 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateCloudFormationTemplateResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateCloudFormationTemplateError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_application(
&self,
input: DeleteApplicationRequest,
) -> Result<(), RusotoError<DeleteApplicationError>> {
let request_uri = format!(
"/applications/{application_id}",
application_id = input.application_id
);
let mut request =
SignedRequest::new("DELETE", "serverlessrepo", &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.as_u16() == 204 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = ::std::mem::drop(response);
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteApplicationError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_application(
&self,
input: GetApplicationRequest,
) -> Result<GetApplicationResponse, RusotoError<GetApplicationError>> {
let request_uri = format!(
"/applications/{application_id}",
application_id = input.application_id
);
let mut request = SignedRequest::new("GET", "serverlessrepo", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.semantic_version {
params.put("semanticVersion", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetApplicationResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetApplicationError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_application_policy(
&self,
input: GetApplicationPolicyRequest,
) -> Result<GetApplicationPolicyResponse, RusotoError<GetApplicationPolicyError>> {
let request_uri = format!(
"/applications/{application_id}/policy",
application_id = input.application_id
);
let mut request = SignedRequest::new("GET", "serverlessrepo", &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.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetApplicationPolicyResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetApplicationPolicyError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_cloud_formation_template(
&self,
input: GetCloudFormationTemplateRequest,
) -> Result<GetCloudFormationTemplateResponse, RusotoError<GetCloudFormationTemplateError>>
{
let request_uri = format!(
"/applications/{application_id}/templates/{template_id}",
application_id = input.application_id,
template_id = input.template_id
);
let mut request = SignedRequest::new("GET", "serverlessrepo", &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.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetCloudFormationTemplateResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetCloudFormationTemplateError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_application_dependencies(
&self,
input: ListApplicationDependenciesRequest,
) -> Result<ListApplicationDependenciesResponse, RusotoError<ListApplicationDependenciesError>>
{
let request_uri = format!(
"/applications/{application_id}/dependencies",
application_id = input.application_id
);
let mut request = SignedRequest::new("GET", "serverlessrepo", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_items {
params.put("maxItems", x);
}
if let Some(ref x) = input.next_token {
params.put("nextToken", x);
}
if let Some(ref x) = input.semantic_version {
params.put("semanticVersion", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListApplicationDependenciesResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListApplicationDependenciesError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_application_versions(
&self,
input: ListApplicationVersionsRequest,
) -> Result<ListApplicationVersionsResponse, RusotoError<ListApplicationVersionsError>> {
let request_uri = format!(
"/applications/{application_id}/versions",
application_id = input.application_id
);
let mut request = SignedRequest::new("GET", "serverlessrepo", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_items {
params.put("maxItems", x);
}
if let Some(ref x) = input.next_token {
params.put("nextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListApplicationVersionsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListApplicationVersionsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_applications(
&self,
input: ListApplicationsRequest,
) -> Result<ListApplicationsResponse, RusotoError<ListApplicationsError>> {
let request_uri = "/applications";
let mut request = SignedRequest::new("GET", "serverlessrepo", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_items {
params.put("maxItems", x);
}
if let Some(ref x) = input.next_token {
params.put("nextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListApplicationsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListApplicationsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn put_application_policy(
&self,
input: PutApplicationPolicyRequest,
) -> Result<PutApplicationPolicyResponse, RusotoError<PutApplicationPolicyError>> {
let request_uri = format!(
"/applications/{application_id}/policy",
application_id = input.application_id
);
let mut request = SignedRequest::new("PUT", "serverlessrepo", &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.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<PutApplicationPolicyResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(PutApplicationPolicyError::from_response(response))
}
}
#[allow(unused_mut)]
async fn unshare_application(
&self,
input: UnshareApplicationRequest,
) -> Result<(), RusotoError<UnshareApplicationError>> {
let request_uri = format!(
"/applications/{application_id}/unshare",
application_id = input.application_id
);
let mut request = SignedRequest::new("POST", "serverlessrepo", &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.as_u16() == 204 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = ::std::mem::drop(response);
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UnshareApplicationError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_application(
&self,
input: UpdateApplicationRequest,
) -> Result<UpdateApplicationResponse, RusotoError<UpdateApplicationError>> {
let request_uri = format!(
"/applications/{application_id}",
application_id = input.application_id
);
let mut request = SignedRequest::new("PATCH", "serverlessrepo", &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.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateApplicationResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateApplicationError::from_response(response))
}
}
}