use std::error::Error;
use std::fmt;
use async_trait::async_trait;
use rusoto_core::credential::ProvideAwsCredentials;
use rusoto_core::region;
use rusoto_core::request::{BufferedHttpResponse, DispatchSignedRequest};
use rusoto_core::{Client, RusotoError};
use rusoto_core::proto;
use rusoto_core::request::HttpResponse;
use rusoto_core::signature::SignedRequest;
#[allow(unused_imports)]
use serde::{Deserialize, Serialize};
impl ServiceQuotasClient {
fn new_signed_request(&self, http_method: &str, request_uri: &str) -> SignedRequest {
let mut request =
SignedRequest::new(http_method, "servicequotas", &self.region, request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request
}
async fn sign_and_dispatch<E>(
&self,
request: SignedRequest,
from_response: fn(BufferedHttpResponse) -> RusotoError<E>,
) -> Result<HttpResponse, RusotoError<E>> {
let mut response = self.client.sign_and_dispatch(request).await?;
if !response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
return Err(from_response(response));
}
Ok(response)
}
}
use serde_json;
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AssociateServiceQuotaTemplateRequest {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AssociateServiceQuotaTemplateResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteServiceQuotaIncreaseRequestFromTemplateRequest {
#[serde(rename = "AwsRegion")]
pub aws_region: String,
#[serde(rename = "QuotaCode")]
pub quota_code: String,
#[serde(rename = "ServiceCode")]
pub service_code: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteServiceQuotaIncreaseRequestFromTemplateResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DisassociateServiceQuotaTemplateRequest {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DisassociateServiceQuotaTemplateResponse {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ErrorReason {
#[serde(rename = "ErrorCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_code: Option<String>,
#[serde(rename = "ErrorMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_message: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetAWSDefaultServiceQuotaRequest {
#[serde(rename = "QuotaCode")]
pub quota_code: String,
#[serde(rename = "ServiceCode")]
pub service_code: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetAWSDefaultServiceQuotaResponse {
#[serde(rename = "Quota")]
#[serde(skip_serializing_if = "Option::is_none")]
pub quota: Option<ServiceQuota>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetAssociationForServiceQuotaTemplateRequest {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetAssociationForServiceQuotaTemplateResponse {
#[serde(rename = "ServiceQuotaTemplateAssociationStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub service_quota_template_association_status: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetRequestedServiceQuotaChangeRequest {
#[serde(rename = "RequestId")]
pub request_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetRequestedServiceQuotaChangeResponse {
#[serde(rename = "RequestedQuota")]
#[serde(skip_serializing_if = "Option::is_none")]
pub requested_quota: Option<RequestedServiceQuotaChange>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetServiceQuotaIncreaseRequestFromTemplateRequest {
#[serde(rename = "AwsRegion")]
pub aws_region: String,
#[serde(rename = "QuotaCode")]
pub quota_code: String,
#[serde(rename = "ServiceCode")]
pub service_code: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetServiceQuotaIncreaseRequestFromTemplateResponse {
#[serde(rename = "ServiceQuotaIncreaseRequestInTemplate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub service_quota_increase_request_in_template: Option<ServiceQuotaIncreaseRequestInTemplate>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetServiceQuotaRequest {
#[serde(rename = "QuotaCode")]
pub quota_code: String,
#[serde(rename = "ServiceCode")]
pub service_code: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetServiceQuotaResponse {
#[serde(rename = "Quota")]
#[serde(skip_serializing_if = "Option::is_none")]
pub quota: Option<ServiceQuota>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListAWSDefaultServiceQuotasRequest {
#[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 = "ServiceCode")]
pub service_code: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListAWSDefaultServiceQuotasResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Quotas")]
#[serde(skip_serializing_if = "Option::is_none")]
pub quotas: Option<Vec<ServiceQuota>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListRequestedServiceQuotaChangeHistoryByQuotaRequest {
#[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 = "QuotaCode")]
pub quota_code: String,
#[serde(rename = "ServiceCode")]
pub service_code: 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 ListRequestedServiceQuotaChangeHistoryByQuotaResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "RequestedQuotas")]
#[serde(skip_serializing_if = "Option::is_none")]
pub requested_quotas: Option<Vec<RequestedServiceQuotaChange>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListRequestedServiceQuotaChangeHistoryRequest {
#[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 = "ServiceCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub service_code: 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 ListRequestedServiceQuotaChangeHistoryResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "RequestedQuotas")]
#[serde(skip_serializing_if = "Option::is_none")]
pub requested_quotas: Option<Vec<RequestedServiceQuotaChange>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListServiceQuotaIncreaseRequestsInTemplateRequest {
#[serde(rename = "AwsRegion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub aws_region: Option<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>,
#[serde(rename = "ServiceCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub service_code: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListServiceQuotaIncreaseRequestsInTemplateResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "ServiceQuotaIncreaseRequestInTemplateList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub service_quota_increase_request_in_template_list:
Option<Vec<ServiceQuotaIncreaseRequestInTemplate>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListServiceQuotasRequest {
#[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 = "ServiceCode")]
pub service_code: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListServiceQuotasResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Quotas")]
#[serde(skip_serializing_if = "Option::is_none")]
pub quotas: Option<Vec<ServiceQuota>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListServicesRequest {
#[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 ListServicesResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Services")]
#[serde(skip_serializing_if = "Option::is_none")]
pub services: Option<Vec<ServiceInfo>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct MetricInfo {
#[serde(rename = "MetricDimensions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub metric_dimensions: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "MetricName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub metric_name: Option<String>,
#[serde(rename = "MetricNamespace")]
#[serde(skip_serializing_if = "Option::is_none")]
pub metric_namespace: Option<String>,
#[serde(rename = "MetricStatisticRecommendation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub metric_statistic_recommendation: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PutServiceQuotaIncreaseRequestIntoTemplateRequest {
#[serde(rename = "AwsRegion")]
pub aws_region: String,
#[serde(rename = "DesiredValue")]
pub desired_value: f64,
#[serde(rename = "QuotaCode")]
pub quota_code: String,
#[serde(rename = "ServiceCode")]
pub service_code: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PutServiceQuotaIncreaseRequestIntoTemplateResponse {
#[serde(rename = "ServiceQuotaIncreaseRequestInTemplate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub service_quota_increase_request_in_template: Option<ServiceQuotaIncreaseRequestInTemplate>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct QuotaPeriod {
#[serde(rename = "PeriodUnit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub period_unit: Option<String>,
#[serde(rename = "PeriodValue")]
#[serde(skip_serializing_if = "Option::is_none")]
pub period_value: Option<i64>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct RequestServiceQuotaIncreaseRequest {
#[serde(rename = "DesiredValue")]
pub desired_value: f64,
#[serde(rename = "QuotaCode")]
pub quota_code: String,
#[serde(rename = "ServiceCode")]
pub service_code: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RequestServiceQuotaIncreaseResponse {
#[serde(rename = "RequestedQuota")]
#[serde(skip_serializing_if = "Option::is_none")]
pub requested_quota: Option<RequestedServiceQuotaChange>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RequestedServiceQuotaChange {
#[serde(rename = "CaseId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub case_id: Option<String>,
#[serde(rename = "Created")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created: Option<f64>,
#[serde(rename = "DesiredValue")]
#[serde(skip_serializing_if = "Option::is_none")]
pub desired_value: Option<f64>,
#[serde(rename = "GlobalQuota")]
#[serde(skip_serializing_if = "Option::is_none")]
pub global_quota: Option<bool>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "LastUpdated")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated: Option<f64>,
#[serde(rename = "QuotaArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub quota_arn: Option<String>,
#[serde(rename = "QuotaCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub quota_code: Option<String>,
#[serde(rename = "QuotaName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub quota_name: Option<String>,
#[serde(rename = "Requester")]
#[serde(skip_serializing_if = "Option::is_none")]
pub requester: Option<String>,
#[serde(rename = "ServiceCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub service_code: Option<String>,
#[serde(rename = "ServiceName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub service_name: Option<String>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "Unit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub unit: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ServiceInfo {
#[serde(rename = "ServiceCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub service_code: Option<String>,
#[serde(rename = "ServiceName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub service_name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ServiceQuota {
#[serde(rename = "Adjustable")]
#[serde(skip_serializing_if = "Option::is_none")]
pub adjustable: Option<bool>,
#[serde(rename = "ErrorReason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_reason: Option<ErrorReason>,
#[serde(rename = "GlobalQuota")]
#[serde(skip_serializing_if = "Option::is_none")]
pub global_quota: Option<bool>,
#[serde(rename = "Period")]
#[serde(skip_serializing_if = "Option::is_none")]
pub period: Option<QuotaPeriod>,
#[serde(rename = "QuotaArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub quota_arn: Option<String>,
#[serde(rename = "QuotaCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub quota_code: Option<String>,
#[serde(rename = "QuotaName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub quota_name: Option<String>,
#[serde(rename = "ServiceCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub service_code: Option<String>,
#[serde(rename = "ServiceName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub service_name: Option<String>,
#[serde(rename = "Unit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub unit: Option<String>,
#[serde(rename = "UsageMetric")]
#[serde(skip_serializing_if = "Option::is_none")]
pub usage_metric: Option<MetricInfo>,
#[serde(rename = "Value")]
#[serde(skip_serializing_if = "Option::is_none")]
pub value: Option<f64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ServiceQuotaIncreaseRequestInTemplate {
#[serde(rename = "AwsRegion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub aws_region: Option<String>,
#[serde(rename = "DesiredValue")]
#[serde(skip_serializing_if = "Option::is_none")]
pub desired_value: Option<f64>,
#[serde(rename = "GlobalQuota")]
#[serde(skip_serializing_if = "Option::is_none")]
pub global_quota: Option<bool>,
#[serde(rename = "QuotaCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub quota_code: Option<String>,
#[serde(rename = "QuotaName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub quota_name: Option<String>,
#[serde(rename = "ServiceCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub service_code: Option<String>,
#[serde(rename = "ServiceName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub service_name: Option<String>,
#[serde(rename = "Unit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub unit: Option<String>,
}
#[derive(Debug, PartialEq)]
pub enum AssociateServiceQuotaTemplateError {
AWSServiceAccessNotEnabled(String),
AccessDenied(String),
DependencyAccessDenied(String),
NoAvailableOrganization(String),
OrganizationNotInAllFeaturesMode(String),
Service(String),
TemplatesNotAvailableInRegion(String),
TooManyRequests(String),
}
impl AssociateServiceQuotaTemplateError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<AssociateServiceQuotaTemplateError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AWSServiceAccessNotEnabledException" => {
return RusotoError::Service(
AssociateServiceQuotaTemplateError::AWSServiceAccessNotEnabled(err.msg),
)
}
"AccessDeniedException" => {
return RusotoError::Service(AssociateServiceQuotaTemplateError::AccessDenied(
err.msg,
))
}
"DependencyAccessDeniedException" => {
return RusotoError::Service(
AssociateServiceQuotaTemplateError::DependencyAccessDenied(err.msg),
)
}
"NoAvailableOrganizationException" => {
return RusotoError::Service(
AssociateServiceQuotaTemplateError::NoAvailableOrganization(err.msg),
)
}
"OrganizationNotInAllFeaturesModeException" => {
return RusotoError::Service(
AssociateServiceQuotaTemplateError::OrganizationNotInAllFeaturesMode(
err.msg,
),
)
}
"ServiceException" => {
return RusotoError::Service(AssociateServiceQuotaTemplateError::Service(
err.msg,
))
}
"TemplatesNotAvailableInRegionException" => {
return RusotoError::Service(
AssociateServiceQuotaTemplateError::TemplatesNotAvailableInRegion(err.msg),
)
}
"TooManyRequestsException" => {
return RusotoError::Service(
AssociateServiceQuotaTemplateError::TooManyRequests(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AssociateServiceQuotaTemplateError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AssociateServiceQuotaTemplateError::AWSServiceAccessNotEnabled(ref cause) => {
write!(f, "{}", cause)
}
AssociateServiceQuotaTemplateError::AccessDenied(ref cause) => write!(f, "{}", cause),
AssociateServiceQuotaTemplateError::DependencyAccessDenied(ref cause) => {
write!(f, "{}", cause)
}
AssociateServiceQuotaTemplateError::NoAvailableOrganization(ref cause) => {
write!(f, "{}", cause)
}
AssociateServiceQuotaTemplateError::OrganizationNotInAllFeaturesMode(ref cause) => {
write!(f, "{}", cause)
}
AssociateServiceQuotaTemplateError::Service(ref cause) => write!(f, "{}", cause),
AssociateServiceQuotaTemplateError::TemplatesNotAvailableInRegion(ref cause) => {
write!(f, "{}", cause)
}
AssociateServiceQuotaTemplateError::TooManyRequests(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for AssociateServiceQuotaTemplateError {}
#[derive(Debug, PartialEq)]
pub enum DeleteServiceQuotaIncreaseRequestFromTemplateError {
AWSServiceAccessNotEnabled(String),
AccessDenied(String),
DependencyAccessDenied(String),
IllegalArgument(String),
NoAvailableOrganization(String),
NoSuchResource(String),
Service(String),
TemplatesNotAvailableInRegion(String),
TooManyRequests(String),
}
impl DeleteServiceQuotaIncreaseRequestFromTemplateError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DeleteServiceQuotaIncreaseRequestFromTemplateError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AWSServiceAccessNotEnabledException" => return RusotoError::Service(DeleteServiceQuotaIncreaseRequestFromTemplateError::AWSServiceAccessNotEnabled(err.msg)),
"AccessDeniedException" => return RusotoError::Service(DeleteServiceQuotaIncreaseRequestFromTemplateError::AccessDenied(err.msg)),
"DependencyAccessDeniedException" => return RusotoError::Service(DeleteServiceQuotaIncreaseRequestFromTemplateError::DependencyAccessDenied(err.msg)),
"IllegalArgumentException" => return RusotoError::Service(DeleteServiceQuotaIncreaseRequestFromTemplateError::IllegalArgument(err.msg)),
"NoAvailableOrganizationException" => return RusotoError::Service(DeleteServiceQuotaIncreaseRequestFromTemplateError::NoAvailableOrganization(err.msg)),
"NoSuchResourceException" => return RusotoError::Service(DeleteServiceQuotaIncreaseRequestFromTemplateError::NoSuchResource(err.msg)),
"ServiceException" => return RusotoError::Service(DeleteServiceQuotaIncreaseRequestFromTemplateError::Service(err.msg)),
"TemplatesNotAvailableInRegionException" => return RusotoError::Service(DeleteServiceQuotaIncreaseRequestFromTemplateError::TemplatesNotAvailableInRegion(err.msg)),
"TooManyRequestsException" => return RusotoError::Service(DeleteServiceQuotaIncreaseRequestFromTemplateError::TooManyRequests(err.msg)),
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteServiceQuotaIncreaseRequestFromTemplateError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteServiceQuotaIncreaseRequestFromTemplateError::AWSServiceAccessNotEnabled(
ref cause,
) => write!(f, "{}", cause),
DeleteServiceQuotaIncreaseRequestFromTemplateError::AccessDenied(ref cause) => {
write!(f, "{}", cause)
}
DeleteServiceQuotaIncreaseRequestFromTemplateError::DependencyAccessDenied(
ref cause,
) => write!(f, "{}", cause),
DeleteServiceQuotaIncreaseRequestFromTemplateError::IllegalArgument(ref cause) => {
write!(f, "{}", cause)
}
DeleteServiceQuotaIncreaseRequestFromTemplateError::NoAvailableOrganization(
ref cause,
) => write!(f, "{}", cause),
DeleteServiceQuotaIncreaseRequestFromTemplateError::NoSuchResource(ref cause) => {
write!(f, "{}", cause)
}
DeleteServiceQuotaIncreaseRequestFromTemplateError::Service(ref cause) => {
write!(f, "{}", cause)
}
DeleteServiceQuotaIncreaseRequestFromTemplateError::TemplatesNotAvailableInRegion(
ref cause,
) => write!(f, "{}", cause),
DeleteServiceQuotaIncreaseRequestFromTemplateError::TooManyRequests(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DeleteServiceQuotaIncreaseRequestFromTemplateError {}
#[derive(Debug, PartialEq)]
pub enum DisassociateServiceQuotaTemplateError {
AWSServiceAccessNotEnabled(String),
AccessDenied(String),
DependencyAccessDenied(String),
NoAvailableOrganization(String),
Service(String),
ServiceQuotaTemplateNotInUse(String),
TemplatesNotAvailableInRegion(String),
TooManyRequests(String),
}
impl DisassociateServiceQuotaTemplateError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DisassociateServiceQuotaTemplateError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AWSServiceAccessNotEnabledException" => {
return RusotoError::Service(
DisassociateServiceQuotaTemplateError::AWSServiceAccessNotEnabled(err.msg),
)
}
"AccessDeniedException" => {
return RusotoError::Service(
DisassociateServiceQuotaTemplateError::AccessDenied(err.msg),
)
}
"DependencyAccessDeniedException" => {
return RusotoError::Service(
DisassociateServiceQuotaTemplateError::DependencyAccessDenied(err.msg),
)
}
"NoAvailableOrganizationException" => {
return RusotoError::Service(
DisassociateServiceQuotaTemplateError::NoAvailableOrganization(err.msg),
)
}
"ServiceException" => {
return RusotoError::Service(DisassociateServiceQuotaTemplateError::Service(
err.msg,
))
}
"ServiceQuotaTemplateNotInUseException" => {
return RusotoError::Service(
DisassociateServiceQuotaTemplateError::ServiceQuotaTemplateNotInUse(
err.msg,
),
)
}
"TemplatesNotAvailableInRegionException" => {
return RusotoError::Service(
DisassociateServiceQuotaTemplateError::TemplatesNotAvailableInRegion(
err.msg,
),
)
}
"TooManyRequestsException" => {
return RusotoError::Service(
DisassociateServiceQuotaTemplateError::TooManyRequests(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DisassociateServiceQuotaTemplateError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DisassociateServiceQuotaTemplateError::AWSServiceAccessNotEnabled(ref cause) => {
write!(f, "{}", cause)
}
DisassociateServiceQuotaTemplateError::AccessDenied(ref cause) => {
write!(f, "{}", cause)
}
DisassociateServiceQuotaTemplateError::DependencyAccessDenied(ref cause) => {
write!(f, "{}", cause)
}
DisassociateServiceQuotaTemplateError::NoAvailableOrganization(ref cause) => {
write!(f, "{}", cause)
}
DisassociateServiceQuotaTemplateError::Service(ref cause) => write!(f, "{}", cause),
DisassociateServiceQuotaTemplateError::ServiceQuotaTemplateNotInUse(ref cause) => {
write!(f, "{}", cause)
}
DisassociateServiceQuotaTemplateError::TemplatesNotAvailableInRegion(ref cause) => {
write!(f, "{}", cause)
}
DisassociateServiceQuotaTemplateError::TooManyRequests(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DisassociateServiceQuotaTemplateError {}
#[derive(Debug, PartialEq)]
pub enum GetAWSDefaultServiceQuotaError {
AccessDenied(String),
IllegalArgument(String),
NoSuchResource(String),
Service(String),
TooManyRequests(String),
}
impl GetAWSDefaultServiceQuotaError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetAWSDefaultServiceQuotaError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(GetAWSDefaultServiceQuotaError::AccessDenied(
err.msg,
))
}
"IllegalArgumentException" => {
return RusotoError::Service(GetAWSDefaultServiceQuotaError::IllegalArgument(
err.msg,
))
}
"NoSuchResourceException" => {
return RusotoError::Service(GetAWSDefaultServiceQuotaError::NoSuchResource(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(GetAWSDefaultServiceQuotaError::Service(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(GetAWSDefaultServiceQuotaError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetAWSDefaultServiceQuotaError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetAWSDefaultServiceQuotaError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetAWSDefaultServiceQuotaError::IllegalArgument(ref cause) => write!(f, "{}", cause),
GetAWSDefaultServiceQuotaError::NoSuchResource(ref cause) => write!(f, "{}", cause),
GetAWSDefaultServiceQuotaError::Service(ref cause) => write!(f, "{}", cause),
GetAWSDefaultServiceQuotaError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetAWSDefaultServiceQuotaError {}
#[derive(Debug, PartialEq)]
pub enum GetAssociationForServiceQuotaTemplateError {
AWSServiceAccessNotEnabled(String),
AccessDenied(String),
DependencyAccessDenied(String),
NoAvailableOrganization(String),
Service(String),
ServiceQuotaTemplateNotInUse(String),
TemplatesNotAvailableInRegion(String),
TooManyRequests(String),
}
impl GetAssociationForServiceQuotaTemplateError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetAssociationForServiceQuotaTemplateError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AWSServiceAccessNotEnabledException" => {
return RusotoError::Service(
GetAssociationForServiceQuotaTemplateError::AWSServiceAccessNotEnabled(
err.msg,
),
)
}
"AccessDeniedException" => {
return RusotoError::Service(
GetAssociationForServiceQuotaTemplateError::AccessDenied(err.msg),
)
}
"DependencyAccessDeniedException" => {
return RusotoError::Service(
GetAssociationForServiceQuotaTemplateError::DependencyAccessDenied(err.msg),
)
}
"NoAvailableOrganizationException" => {
return RusotoError::Service(
GetAssociationForServiceQuotaTemplateError::NoAvailableOrganization(
err.msg,
),
)
}
"ServiceException" => {
return RusotoError::Service(
GetAssociationForServiceQuotaTemplateError::Service(err.msg),
)
}
"ServiceQuotaTemplateNotInUseException" => {
return RusotoError::Service(
GetAssociationForServiceQuotaTemplateError::ServiceQuotaTemplateNotInUse(
err.msg,
),
)
}
"TemplatesNotAvailableInRegionException" => {
return RusotoError::Service(
GetAssociationForServiceQuotaTemplateError::TemplatesNotAvailableInRegion(
err.msg,
),
)
}
"TooManyRequestsException" => {
return RusotoError::Service(
GetAssociationForServiceQuotaTemplateError::TooManyRequests(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetAssociationForServiceQuotaTemplateError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetAssociationForServiceQuotaTemplateError::AWSServiceAccessNotEnabled(ref cause) => {
write!(f, "{}", cause)
}
GetAssociationForServiceQuotaTemplateError::AccessDenied(ref cause) => {
write!(f, "{}", cause)
}
GetAssociationForServiceQuotaTemplateError::DependencyAccessDenied(ref cause) => {
write!(f, "{}", cause)
}
GetAssociationForServiceQuotaTemplateError::NoAvailableOrganization(ref cause) => {
write!(f, "{}", cause)
}
GetAssociationForServiceQuotaTemplateError::Service(ref cause) => {
write!(f, "{}", cause)
}
GetAssociationForServiceQuotaTemplateError::ServiceQuotaTemplateNotInUse(ref cause) => {
write!(f, "{}", cause)
}
GetAssociationForServiceQuotaTemplateError::TemplatesNotAvailableInRegion(
ref cause,
) => write!(f, "{}", cause),
GetAssociationForServiceQuotaTemplateError::TooManyRequests(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for GetAssociationForServiceQuotaTemplateError {}
#[derive(Debug, PartialEq)]
pub enum GetRequestedServiceQuotaChangeError {
AccessDenied(String),
IllegalArgument(String),
NoSuchResource(String),
Service(String),
TooManyRequests(String),
}
impl GetRequestedServiceQuotaChangeError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetRequestedServiceQuotaChangeError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(GetRequestedServiceQuotaChangeError::AccessDenied(
err.msg,
))
}
"IllegalArgumentException" => {
return RusotoError::Service(
GetRequestedServiceQuotaChangeError::IllegalArgument(err.msg),
)
}
"NoSuchResourceException" => {
return RusotoError::Service(
GetRequestedServiceQuotaChangeError::NoSuchResource(err.msg),
)
}
"ServiceException" => {
return RusotoError::Service(GetRequestedServiceQuotaChangeError::Service(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(
GetRequestedServiceQuotaChangeError::TooManyRequests(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetRequestedServiceQuotaChangeError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetRequestedServiceQuotaChangeError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetRequestedServiceQuotaChangeError::IllegalArgument(ref cause) => {
write!(f, "{}", cause)
}
GetRequestedServiceQuotaChangeError::NoSuchResource(ref cause) => {
write!(f, "{}", cause)
}
GetRequestedServiceQuotaChangeError::Service(ref cause) => write!(f, "{}", cause),
GetRequestedServiceQuotaChangeError::TooManyRequests(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for GetRequestedServiceQuotaChangeError {}
#[derive(Debug, PartialEq)]
pub enum GetServiceQuotaError {
AccessDenied(String),
IllegalArgument(String),
NoSuchResource(String),
Service(String),
TooManyRequests(String),
}
impl GetServiceQuotaError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetServiceQuotaError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(GetServiceQuotaError::AccessDenied(err.msg))
}
"IllegalArgumentException" => {
return RusotoError::Service(GetServiceQuotaError::IllegalArgument(err.msg))
}
"NoSuchResourceException" => {
return RusotoError::Service(GetServiceQuotaError::NoSuchResource(err.msg))
}
"ServiceException" => {
return RusotoError::Service(GetServiceQuotaError::Service(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(GetServiceQuotaError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetServiceQuotaError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetServiceQuotaError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetServiceQuotaError::IllegalArgument(ref cause) => write!(f, "{}", cause),
GetServiceQuotaError::NoSuchResource(ref cause) => write!(f, "{}", cause),
GetServiceQuotaError::Service(ref cause) => write!(f, "{}", cause),
GetServiceQuotaError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetServiceQuotaError {}
#[derive(Debug, PartialEq)]
pub enum GetServiceQuotaIncreaseRequestFromTemplateError {
AWSServiceAccessNotEnabled(String),
AccessDenied(String),
DependencyAccessDenied(String),
IllegalArgument(String),
NoAvailableOrganization(String),
NoSuchResource(String),
Service(String),
TemplatesNotAvailableInRegion(String),
TooManyRequests(String),
}
impl GetServiceQuotaIncreaseRequestFromTemplateError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetServiceQuotaIncreaseRequestFromTemplateError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AWSServiceAccessNotEnabledException" => {
return RusotoError::Service(
GetServiceQuotaIncreaseRequestFromTemplateError::AWSServiceAccessNotEnabled(
err.msg,
),
)
}
"AccessDeniedException" => {
return RusotoError::Service(
GetServiceQuotaIncreaseRequestFromTemplateError::AccessDenied(err.msg),
)
}
"DependencyAccessDeniedException" => {
return RusotoError::Service(
GetServiceQuotaIncreaseRequestFromTemplateError::DependencyAccessDenied(
err.msg,
),
)
}
"IllegalArgumentException" => {
return RusotoError::Service(
GetServiceQuotaIncreaseRequestFromTemplateError::IllegalArgument(err.msg),
)
}
"NoAvailableOrganizationException" => {
return RusotoError::Service(
GetServiceQuotaIncreaseRequestFromTemplateError::NoAvailableOrganization(
err.msg,
),
)
}
"NoSuchResourceException" => {
return RusotoError::Service(
GetServiceQuotaIncreaseRequestFromTemplateError::NoSuchResource(err.msg),
)
}
"ServiceException" => {
return RusotoError::Service(
GetServiceQuotaIncreaseRequestFromTemplateError::Service(err.msg),
)
}
"TemplatesNotAvailableInRegionException" => return RusotoError::Service(
GetServiceQuotaIncreaseRequestFromTemplateError::TemplatesNotAvailableInRegion(
err.msg,
),
),
"TooManyRequestsException" => {
return RusotoError::Service(
GetServiceQuotaIncreaseRequestFromTemplateError::TooManyRequests(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetServiceQuotaIncreaseRequestFromTemplateError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetServiceQuotaIncreaseRequestFromTemplateError::AWSServiceAccessNotEnabled(
ref cause,
) => write!(f, "{}", cause),
GetServiceQuotaIncreaseRequestFromTemplateError::AccessDenied(ref cause) => {
write!(f, "{}", cause)
}
GetServiceQuotaIncreaseRequestFromTemplateError::DependencyAccessDenied(ref cause) => {
write!(f, "{}", cause)
}
GetServiceQuotaIncreaseRequestFromTemplateError::IllegalArgument(ref cause) => {
write!(f, "{}", cause)
}
GetServiceQuotaIncreaseRequestFromTemplateError::NoAvailableOrganization(ref cause) => {
write!(f, "{}", cause)
}
GetServiceQuotaIncreaseRequestFromTemplateError::NoSuchResource(ref cause) => {
write!(f, "{}", cause)
}
GetServiceQuotaIncreaseRequestFromTemplateError::Service(ref cause) => {
write!(f, "{}", cause)
}
GetServiceQuotaIncreaseRequestFromTemplateError::TemplatesNotAvailableInRegion(
ref cause,
) => write!(f, "{}", cause),
GetServiceQuotaIncreaseRequestFromTemplateError::TooManyRequests(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for GetServiceQuotaIncreaseRequestFromTemplateError {}
#[derive(Debug, PartialEq)]
pub enum ListAWSDefaultServiceQuotasError {
AccessDenied(String),
IllegalArgument(String),
InvalidPaginationToken(String),
NoSuchResource(String),
Service(String),
TooManyRequests(String),
}
impl ListAWSDefaultServiceQuotasError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListAWSDefaultServiceQuotasError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(ListAWSDefaultServiceQuotasError::AccessDenied(
err.msg,
))
}
"IllegalArgumentException" => {
return RusotoError::Service(ListAWSDefaultServiceQuotasError::IllegalArgument(
err.msg,
))
}
"InvalidPaginationTokenException" => {
return RusotoError::Service(
ListAWSDefaultServiceQuotasError::InvalidPaginationToken(err.msg),
)
}
"NoSuchResourceException" => {
return RusotoError::Service(ListAWSDefaultServiceQuotasError::NoSuchResource(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(ListAWSDefaultServiceQuotasError::Service(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(ListAWSDefaultServiceQuotasError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListAWSDefaultServiceQuotasError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListAWSDefaultServiceQuotasError::AccessDenied(ref cause) => write!(f, "{}", cause),
ListAWSDefaultServiceQuotasError::IllegalArgument(ref cause) => write!(f, "{}", cause),
ListAWSDefaultServiceQuotasError::InvalidPaginationToken(ref cause) => {
write!(f, "{}", cause)
}
ListAWSDefaultServiceQuotasError::NoSuchResource(ref cause) => write!(f, "{}", cause),
ListAWSDefaultServiceQuotasError::Service(ref cause) => write!(f, "{}", cause),
ListAWSDefaultServiceQuotasError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListAWSDefaultServiceQuotasError {}
#[derive(Debug, PartialEq)]
pub enum ListRequestedServiceQuotaChangeHistoryError {
AccessDenied(String),
IllegalArgument(String),
InvalidPaginationToken(String),
NoSuchResource(String),
Service(String),
TooManyRequests(String),
}
impl ListRequestedServiceQuotaChangeHistoryError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListRequestedServiceQuotaChangeHistoryError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(
ListRequestedServiceQuotaChangeHistoryError::AccessDenied(err.msg),
)
}
"IllegalArgumentException" => {
return RusotoError::Service(
ListRequestedServiceQuotaChangeHistoryError::IllegalArgument(err.msg),
)
}
"InvalidPaginationTokenException" => {
return RusotoError::Service(
ListRequestedServiceQuotaChangeHistoryError::InvalidPaginationToken(
err.msg,
),
)
}
"NoSuchResourceException" => {
return RusotoError::Service(
ListRequestedServiceQuotaChangeHistoryError::NoSuchResource(err.msg),
)
}
"ServiceException" => {
return RusotoError::Service(
ListRequestedServiceQuotaChangeHistoryError::Service(err.msg),
)
}
"TooManyRequestsException" => {
return RusotoError::Service(
ListRequestedServiceQuotaChangeHistoryError::TooManyRequests(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListRequestedServiceQuotaChangeHistoryError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListRequestedServiceQuotaChangeHistoryError::AccessDenied(ref cause) => {
write!(f, "{}", cause)
}
ListRequestedServiceQuotaChangeHistoryError::IllegalArgument(ref cause) => {
write!(f, "{}", cause)
}
ListRequestedServiceQuotaChangeHistoryError::InvalidPaginationToken(ref cause) => {
write!(f, "{}", cause)
}
ListRequestedServiceQuotaChangeHistoryError::NoSuchResource(ref cause) => {
write!(f, "{}", cause)
}
ListRequestedServiceQuotaChangeHistoryError::Service(ref cause) => {
write!(f, "{}", cause)
}
ListRequestedServiceQuotaChangeHistoryError::TooManyRequests(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ListRequestedServiceQuotaChangeHistoryError {}
#[derive(Debug, PartialEq)]
pub enum ListRequestedServiceQuotaChangeHistoryByQuotaError {
AccessDenied(String),
IllegalArgument(String),
InvalidPaginationToken(String),
NoSuchResource(String),
Service(String),
TooManyRequests(String),
}
impl ListRequestedServiceQuotaChangeHistoryByQuotaError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListRequestedServiceQuotaChangeHistoryByQuotaError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(
ListRequestedServiceQuotaChangeHistoryByQuotaError::AccessDenied(err.msg),
)
}
"IllegalArgumentException" => {
return RusotoError::Service(
ListRequestedServiceQuotaChangeHistoryByQuotaError::IllegalArgument(
err.msg,
),
)
}
"InvalidPaginationTokenException" => {
return RusotoError::Service(
ListRequestedServiceQuotaChangeHistoryByQuotaError::InvalidPaginationToken(
err.msg,
),
)
}
"NoSuchResourceException" => {
return RusotoError::Service(
ListRequestedServiceQuotaChangeHistoryByQuotaError::NoSuchResource(err.msg),
)
}
"ServiceException" => {
return RusotoError::Service(
ListRequestedServiceQuotaChangeHistoryByQuotaError::Service(err.msg),
)
}
"TooManyRequestsException" => {
return RusotoError::Service(
ListRequestedServiceQuotaChangeHistoryByQuotaError::TooManyRequests(
err.msg,
),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListRequestedServiceQuotaChangeHistoryByQuotaError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListRequestedServiceQuotaChangeHistoryByQuotaError::AccessDenied(ref cause) => {
write!(f, "{}", cause)
}
ListRequestedServiceQuotaChangeHistoryByQuotaError::IllegalArgument(ref cause) => {
write!(f, "{}", cause)
}
ListRequestedServiceQuotaChangeHistoryByQuotaError::InvalidPaginationToken(
ref cause,
) => write!(f, "{}", cause),
ListRequestedServiceQuotaChangeHistoryByQuotaError::NoSuchResource(ref cause) => {
write!(f, "{}", cause)
}
ListRequestedServiceQuotaChangeHistoryByQuotaError::Service(ref cause) => {
write!(f, "{}", cause)
}
ListRequestedServiceQuotaChangeHistoryByQuotaError::TooManyRequests(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ListRequestedServiceQuotaChangeHistoryByQuotaError {}
#[derive(Debug, PartialEq)]
pub enum ListServiceQuotaIncreaseRequestsInTemplateError {
AWSServiceAccessNotEnabled(String),
AccessDenied(String),
DependencyAccessDenied(String),
IllegalArgument(String),
NoAvailableOrganization(String),
Service(String),
TemplatesNotAvailableInRegion(String),
TooManyRequests(String),
}
impl ListServiceQuotaIncreaseRequestsInTemplateError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListServiceQuotaIncreaseRequestsInTemplateError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AWSServiceAccessNotEnabledException" => {
return RusotoError::Service(
ListServiceQuotaIncreaseRequestsInTemplateError::AWSServiceAccessNotEnabled(
err.msg,
),
)
}
"AccessDeniedException" => {
return RusotoError::Service(
ListServiceQuotaIncreaseRequestsInTemplateError::AccessDenied(err.msg),
)
}
"DependencyAccessDeniedException" => {
return RusotoError::Service(
ListServiceQuotaIncreaseRequestsInTemplateError::DependencyAccessDenied(
err.msg,
),
)
}
"IllegalArgumentException" => {
return RusotoError::Service(
ListServiceQuotaIncreaseRequestsInTemplateError::IllegalArgument(err.msg),
)
}
"NoAvailableOrganizationException" => {
return RusotoError::Service(
ListServiceQuotaIncreaseRequestsInTemplateError::NoAvailableOrganization(
err.msg,
),
)
}
"ServiceException" => {
return RusotoError::Service(
ListServiceQuotaIncreaseRequestsInTemplateError::Service(err.msg),
)
}
"TemplatesNotAvailableInRegionException" => return RusotoError::Service(
ListServiceQuotaIncreaseRequestsInTemplateError::TemplatesNotAvailableInRegion(
err.msg,
),
),
"TooManyRequestsException" => {
return RusotoError::Service(
ListServiceQuotaIncreaseRequestsInTemplateError::TooManyRequests(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListServiceQuotaIncreaseRequestsInTemplateError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListServiceQuotaIncreaseRequestsInTemplateError::AWSServiceAccessNotEnabled(
ref cause,
) => write!(f, "{}", cause),
ListServiceQuotaIncreaseRequestsInTemplateError::AccessDenied(ref cause) => {
write!(f, "{}", cause)
}
ListServiceQuotaIncreaseRequestsInTemplateError::DependencyAccessDenied(ref cause) => {
write!(f, "{}", cause)
}
ListServiceQuotaIncreaseRequestsInTemplateError::IllegalArgument(ref cause) => {
write!(f, "{}", cause)
}
ListServiceQuotaIncreaseRequestsInTemplateError::NoAvailableOrganization(ref cause) => {
write!(f, "{}", cause)
}
ListServiceQuotaIncreaseRequestsInTemplateError::Service(ref cause) => {
write!(f, "{}", cause)
}
ListServiceQuotaIncreaseRequestsInTemplateError::TemplatesNotAvailableInRegion(
ref cause,
) => write!(f, "{}", cause),
ListServiceQuotaIncreaseRequestsInTemplateError::TooManyRequests(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ListServiceQuotaIncreaseRequestsInTemplateError {}
#[derive(Debug, PartialEq)]
pub enum ListServiceQuotasError {
AccessDenied(String),
IllegalArgument(String),
InvalidPaginationToken(String),
NoSuchResource(String),
Service(String),
TooManyRequests(String),
}
impl ListServiceQuotasError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListServiceQuotasError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(ListServiceQuotasError::AccessDenied(err.msg))
}
"IllegalArgumentException" => {
return RusotoError::Service(ListServiceQuotasError::IllegalArgument(err.msg))
}
"InvalidPaginationTokenException" => {
return RusotoError::Service(ListServiceQuotasError::InvalidPaginationToken(
err.msg,
))
}
"NoSuchResourceException" => {
return RusotoError::Service(ListServiceQuotasError::NoSuchResource(err.msg))
}
"ServiceException" => {
return RusotoError::Service(ListServiceQuotasError::Service(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(ListServiceQuotasError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListServiceQuotasError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListServiceQuotasError::AccessDenied(ref cause) => write!(f, "{}", cause),
ListServiceQuotasError::IllegalArgument(ref cause) => write!(f, "{}", cause),
ListServiceQuotasError::InvalidPaginationToken(ref cause) => write!(f, "{}", cause),
ListServiceQuotasError::NoSuchResource(ref cause) => write!(f, "{}", cause),
ListServiceQuotasError::Service(ref cause) => write!(f, "{}", cause),
ListServiceQuotasError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListServiceQuotasError {}
#[derive(Debug, PartialEq)]
pub enum ListServicesError {
AccessDenied(String),
IllegalArgument(String),
InvalidPaginationToken(String),
Service(String),
TooManyRequests(String),
}
impl ListServicesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListServicesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(ListServicesError::AccessDenied(err.msg))
}
"IllegalArgumentException" => {
return RusotoError::Service(ListServicesError::IllegalArgument(err.msg))
}
"InvalidPaginationTokenException" => {
return RusotoError::Service(ListServicesError::InvalidPaginationToken(err.msg))
}
"ServiceException" => {
return RusotoError::Service(ListServicesError::Service(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(ListServicesError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListServicesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListServicesError::AccessDenied(ref cause) => write!(f, "{}", cause),
ListServicesError::IllegalArgument(ref cause) => write!(f, "{}", cause),
ListServicesError::InvalidPaginationToken(ref cause) => write!(f, "{}", cause),
ListServicesError::Service(ref cause) => write!(f, "{}", cause),
ListServicesError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListServicesError {}
#[derive(Debug, PartialEq)]
pub enum PutServiceQuotaIncreaseRequestIntoTemplateError {
AWSServiceAccessNotEnabled(String),
AccessDenied(String),
DependencyAccessDenied(String),
IllegalArgument(String),
NoAvailableOrganization(String),
NoSuchResource(String),
QuotaExceeded(String),
Service(String),
TemplatesNotAvailableInRegion(String),
TooManyRequests(String),
}
impl PutServiceQuotaIncreaseRequestIntoTemplateError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<PutServiceQuotaIncreaseRequestIntoTemplateError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AWSServiceAccessNotEnabledException" => {
return RusotoError::Service(
PutServiceQuotaIncreaseRequestIntoTemplateError::AWSServiceAccessNotEnabled(
err.msg,
),
)
}
"AccessDeniedException" => {
return RusotoError::Service(
PutServiceQuotaIncreaseRequestIntoTemplateError::AccessDenied(err.msg),
)
}
"DependencyAccessDeniedException" => {
return RusotoError::Service(
PutServiceQuotaIncreaseRequestIntoTemplateError::DependencyAccessDenied(
err.msg,
),
)
}
"IllegalArgumentException" => {
return RusotoError::Service(
PutServiceQuotaIncreaseRequestIntoTemplateError::IllegalArgument(err.msg),
)
}
"NoAvailableOrganizationException" => {
return RusotoError::Service(
PutServiceQuotaIncreaseRequestIntoTemplateError::NoAvailableOrganization(
err.msg,
),
)
}
"NoSuchResourceException" => {
return RusotoError::Service(
PutServiceQuotaIncreaseRequestIntoTemplateError::NoSuchResource(err.msg),
)
}
"QuotaExceededException" => {
return RusotoError::Service(
PutServiceQuotaIncreaseRequestIntoTemplateError::QuotaExceeded(err.msg),
)
}
"ServiceException" => {
return RusotoError::Service(
PutServiceQuotaIncreaseRequestIntoTemplateError::Service(err.msg),
)
}
"TemplatesNotAvailableInRegionException" => return RusotoError::Service(
PutServiceQuotaIncreaseRequestIntoTemplateError::TemplatesNotAvailableInRegion(
err.msg,
),
),
"TooManyRequestsException" => {
return RusotoError::Service(
PutServiceQuotaIncreaseRequestIntoTemplateError::TooManyRequests(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for PutServiceQuotaIncreaseRequestIntoTemplateError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PutServiceQuotaIncreaseRequestIntoTemplateError::AWSServiceAccessNotEnabled(
ref cause,
) => write!(f, "{}", cause),
PutServiceQuotaIncreaseRequestIntoTemplateError::AccessDenied(ref cause) => {
write!(f, "{}", cause)
}
PutServiceQuotaIncreaseRequestIntoTemplateError::DependencyAccessDenied(ref cause) => {
write!(f, "{}", cause)
}
PutServiceQuotaIncreaseRequestIntoTemplateError::IllegalArgument(ref cause) => {
write!(f, "{}", cause)
}
PutServiceQuotaIncreaseRequestIntoTemplateError::NoAvailableOrganization(ref cause) => {
write!(f, "{}", cause)
}
PutServiceQuotaIncreaseRequestIntoTemplateError::NoSuchResource(ref cause) => {
write!(f, "{}", cause)
}
PutServiceQuotaIncreaseRequestIntoTemplateError::QuotaExceeded(ref cause) => {
write!(f, "{}", cause)
}
PutServiceQuotaIncreaseRequestIntoTemplateError::Service(ref cause) => {
write!(f, "{}", cause)
}
PutServiceQuotaIncreaseRequestIntoTemplateError::TemplatesNotAvailableInRegion(
ref cause,
) => write!(f, "{}", cause),
PutServiceQuotaIncreaseRequestIntoTemplateError::TooManyRequests(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for PutServiceQuotaIncreaseRequestIntoTemplateError {}
#[derive(Debug, PartialEq)]
pub enum RequestServiceQuotaIncreaseError {
AccessDenied(String),
DependencyAccessDenied(String),
IllegalArgument(String),
InvalidResourceState(String),
NoSuchResource(String),
QuotaExceeded(String),
ResourceAlreadyExists(String),
Service(String),
TooManyRequests(String),
}
impl RequestServiceQuotaIncreaseError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<RequestServiceQuotaIncreaseError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(RequestServiceQuotaIncreaseError::AccessDenied(
err.msg,
))
}
"DependencyAccessDeniedException" => {
return RusotoError::Service(
RequestServiceQuotaIncreaseError::DependencyAccessDenied(err.msg),
)
}
"IllegalArgumentException" => {
return RusotoError::Service(RequestServiceQuotaIncreaseError::IllegalArgument(
err.msg,
))
}
"InvalidResourceStateException" => {
return RusotoError::Service(
RequestServiceQuotaIncreaseError::InvalidResourceState(err.msg),
)
}
"NoSuchResourceException" => {
return RusotoError::Service(RequestServiceQuotaIncreaseError::NoSuchResource(
err.msg,
))
}
"QuotaExceededException" => {
return RusotoError::Service(RequestServiceQuotaIncreaseError::QuotaExceeded(
err.msg,
))
}
"ResourceAlreadyExistsException" => {
return RusotoError::Service(
RequestServiceQuotaIncreaseError::ResourceAlreadyExists(err.msg),
)
}
"ServiceException" => {
return RusotoError::Service(RequestServiceQuotaIncreaseError::Service(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(RequestServiceQuotaIncreaseError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for RequestServiceQuotaIncreaseError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
RequestServiceQuotaIncreaseError::AccessDenied(ref cause) => write!(f, "{}", cause),
RequestServiceQuotaIncreaseError::DependencyAccessDenied(ref cause) => {
write!(f, "{}", cause)
}
RequestServiceQuotaIncreaseError::IllegalArgument(ref cause) => write!(f, "{}", cause),
RequestServiceQuotaIncreaseError::InvalidResourceState(ref cause) => {
write!(f, "{}", cause)
}
RequestServiceQuotaIncreaseError::NoSuchResource(ref cause) => write!(f, "{}", cause),
RequestServiceQuotaIncreaseError::QuotaExceeded(ref cause) => write!(f, "{}", cause),
RequestServiceQuotaIncreaseError::ResourceAlreadyExists(ref cause) => {
write!(f, "{}", cause)
}
RequestServiceQuotaIncreaseError::Service(ref cause) => write!(f, "{}", cause),
RequestServiceQuotaIncreaseError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for RequestServiceQuotaIncreaseError {}
#[async_trait]
pub trait ServiceQuotas {
async fn associate_service_quota_template(
&self,
) -> Result<
AssociateServiceQuotaTemplateResponse,
RusotoError<AssociateServiceQuotaTemplateError>,
>;
async fn delete_service_quota_increase_request_from_template(
&self,
input: DeleteServiceQuotaIncreaseRequestFromTemplateRequest,
) -> Result<
DeleteServiceQuotaIncreaseRequestFromTemplateResponse,
RusotoError<DeleteServiceQuotaIncreaseRequestFromTemplateError>,
>;
async fn disassociate_service_quota_template(
&self,
) -> Result<
DisassociateServiceQuotaTemplateResponse,
RusotoError<DisassociateServiceQuotaTemplateError>,
>;
async fn get_aws_default_service_quota(
&self,
input: GetAWSDefaultServiceQuotaRequest,
) -> Result<GetAWSDefaultServiceQuotaResponse, RusotoError<GetAWSDefaultServiceQuotaError>>;
async fn get_association_for_service_quota_template(
&self,
) -> Result<
GetAssociationForServiceQuotaTemplateResponse,
RusotoError<GetAssociationForServiceQuotaTemplateError>,
>;
async fn get_requested_service_quota_change(
&self,
input: GetRequestedServiceQuotaChangeRequest,
) -> Result<
GetRequestedServiceQuotaChangeResponse,
RusotoError<GetRequestedServiceQuotaChangeError>,
>;
async fn get_service_quota(
&self,
input: GetServiceQuotaRequest,
) -> Result<GetServiceQuotaResponse, RusotoError<GetServiceQuotaError>>;
async fn get_service_quota_increase_request_from_template(
&self,
input: GetServiceQuotaIncreaseRequestFromTemplateRequest,
) -> Result<
GetServiceQuotaIncreaseRequestFromTemplateResponse,
RusotoError<GetServiceQuotaIncreaseRequestFromTemplateError>,
>;
async fn list_aws_default_service_quotas(
&self,
input: ListAWSDefaultServiceQuotasRequest,
) -> Result<ListAWSDefaultServiceQuotasResponse, RusotoError<ListAWSDefaultServiceQuotasError>>;
async fn list_requested_service_quota_change_history(
&self,
input: ListRequestedServiceQuotaChangeHistoryRequest,
) -> Result<
ListRequestedServiceQuotaChangeHistoryResponse,
RusotoError<ListRequestedServiceQuotaChangeHistoryError>,
>;
async fn list_requested_service_quota_change_history_by_quota(
&self,
input: ListRequestedServiceQuotaChangeHistoryByQuotaRequest,
) -> Result<
ListRequestedServiceQuotaChangeHistoryByQuotaResponse,
RusotoError<ListRequestedServiceQuotaChangeHistoryByQuotaError>,
>;
async fn list_service_quota_increase_requests_in_template(
&self,
input: ListServiceQuotaIncreaseRequestsInTemplateRequest,
) -> Result<
ListServiceQuotaIncreaseRequestsInTemplateResponse,
RusotoError<ListServiceQuotaIncreaseRequestsInTemplateError>,
>;
async fn list_service_quotas(
&self,
input: ListServiceQuotasRequest,
) -> Result<ListServiceQuotasResponse, RusotoError<ListServiceQuotasError>>;
async fn list_services(
&self,
input: ListServicesRequest,
) -> Result<ListServicesResponse, RusotoError<ListServicesError>>;
async fn put_service_quota_increase_request_into_template(
&self,
input: PutServiceQuotaIncreaseRequestIntoTemplateRequest,
) -> Result<
PutServiceQuotaIncreaseRequestIntoTemplateResponse,
RusotoError<PutServiceQuotaIncreaseRequestIntoTemplateError>,
>;
async fn request_service_quota_increase(
&self,
input: RequestServiceQuotaIncreaseRequest,
) -> Result<RequestServiceQuotaIncreaseResponse, RusotoError<RequestServiceQuotaIncreaseError>>;
}
#[derive(Clone)]
pub struct ServiceQuotasClient {
client: Client,
region: region::Region,
}
impl ServiceQuotasClient {
pub fn new(region: region::Region) -> ServiceQuotasClient {
ServiceQuotasClient {
client: Client::shared(),
region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> ServiceQuotasClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
D: DispatchSignedRequest + Send + Sync + 'static,
{
ServiceQuotasClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region,
}
}
pub fn new_with_client(client: Client, region: region::Region) -> ServiceQuotasClient {
ServiceQuotasClient { client, region }
}
}
#[async_trait]
impl ServiceQuotas for ServiceQuotasClient {
async fn associate_service_quota_template(
&self,
) -> Result<
AssociateServiceQuotaTemplateResponse,
RusotoError<AssociateServiceQuotaTemplateError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"ServiceQuotasV20190624.AssociateServiceQuotaTemplate",
);
request.set_payload(Some(bytes::Bytes::from_static(b"{}")));
let response = self
.sign_and_dispatch(request, AssociateServiceQuotaTemplateError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<AssociateServiceQuotaTemplateResponse, _>()
}
async fn delete_service_quota_increase_request_from_template(
&self,
input: DeleteServiceQuotaIncreaseRequestFromTemplateRequest,
) -> Result<
DeleteServiceQuotaIncreaseRequestFromTemplateResponse,
RusotoError<DeleteServiceQuotaIncreaseRequestFromTemplateError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"ServiceQuotasV20190624.DeleteServiceQuotaIncreaseRequestFromTemplate",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
DeleteServiceQuotaIncreaseRequestFromTemplateError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteServiceQuotaIncreaseRequestFromTemplateResponse, _>()
}
async fn disassociate_service_quota_template(
&self,
) -> Result<
DisassociateServiceQuotaTemplateResponse,
RusotoError<DisassociateServiceQuotaTemplateError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"ServiceQuotasV20190624.DisassociateServiceQuotaTemplate",
);
request.set_payload(Some(bytes::Bytes::from_static(b"{}")));
let response = self
.sign_and_dispatch(
request,
DisassociateServiceQuotaTemplateError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DisassociateServiceQuotaTemplateResponse, _>()
}
async fn get_aws_default_service_quota(
&self,
input: GetAWSDefaultServiceQuotaRequest,
) -> Result<GetAWSDefaultServiceQuotaResponse, RusotoError<GetAWSDefaultServiceQuotaError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"ServiceQuotasV20190624.GetAWSDefaultServiceQuota",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetAWSDefaultServiceQuotaError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<GetAWSDefaultServiceQuotaResponse, _>()
}
async fn get_association_for_service_quota_template(
&self,
) -> Result<
GetAssociationForServiceQuotaTemplateResponse,
RusotoError<GetAssociationForServiceQuotaTemplateError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"ServiceQuotasV20190624.GetAssociationForServiceQuotaTemplate",
);
request.set_payload(Some(bytes::Bytes::from_static(b"{}")));
let response = self
.sign_and_dispatch(
request,
GetAssociationForServiceQuotaTemplateError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<GetAssociationForServiceQuotaTemplateResponse, _>()
}
async fn get_requested_service_quota_change(
&self,
input: GetRequestedServiceQuotaChangeRequest,
) -> Result<
GetRequestedServiceQuotaChangeResponse,
RusotoError<GetRequestedServiceQuotaChangeError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"ServiceQuotasV20190624.GetRequestedServiceQuotaChange",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetRequestedServiceQuotaChangeError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<GetRequestedServiceQuotaChangeResponse, _>()
}
async fn get_service_quota(
&self,
input: GetServiceQuotaRequest,
) -> Result<GetServiceQuotaResponse, RusotoError<GetServiceQuotaError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "ServiceQuotasV20190624.GetServiceQuota");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetServiceQuotaError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetServiceQuotaResponse, _>()
}
async fn get_service_quota_increase_request_from_template(
&self,
input: GetServiceQuotaIncreaseRequestFromTemplateRequest,
) -> Result<
GetServiceQuotaIncreaseRequestFromTemplateResponse,
RusotoError<GetServiceQuotaIncreaseRequestFromTemplateError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"ServiceQuotasV20190624.GetServiceQuotaIncreaseRequestFromTemplate",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
GetServiceQuotaIncreaseRequestFromTemplateError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<GetServiceQuotaIncreaseRequestFromTemplateResponse, _>()
}
async fn list_aws_default_service_quotas(
&self,
input: ListAWSDefaultServiceQuotasRequest,
) -> Result<ListAWSDefaultServiceQuotasResponse, RusotoError<ListAWSDefaultServiceQuotasError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"ServiceQuotasV20190624.ListAWSDefaultServiceQuotas",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListAWSDefaultServiceQuotasError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListAWSDefaultServiceQuotasResponse, _>()
}
async fn list_requested_service_quota_change_history(
&self,
input: ListRequestedServiceQuotaChangeHistoryRequest,
) -> Result<
ListRequestedServiceQuotaChangeHistoryResponse,
RusotoError<ListRequestedServiceQuotaChangeHistoryError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"ServiceQuotasV20190624.ListRequestedServiceQuotaChangeHistory",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
ListRequestedServiceQuotaChangeHistoryError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListRequestedServiceQuotaChangeHistoryResponse, _>()
}
async fn list_requested_service_quota_change_history_by_quota(
&self,
input: ListRequestedServiceQuotaChangeHistoryByQuotaRequest,
) -> Result<
ListRequestedServiceQuotaChangeHistoryByQuotaResponse,
RusotoError<ListRequestedServiceQuotaChangeHistoryByQuotaError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"ServiceQuotasV20190624.ListRequestedServiceQuotaChangeHistoryByQuota",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
ListRequestedServiceQuotaChangeHistoryByQuotaError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListRequestedServiceQuotaChangeHistoryByQuotaResponse, _>()
}
async fn list_service_quota_increase_requests_in_template(
&self,
input: ListServiceQuotaIncreaseRequestsInTemplateRequest,
) -> Result<
ListServiceQuotaIncreaseRequestsInTemplateResponse,
RusotoError<ListServiceQuotaIncreaseRequestsInTemplateError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"ServiceQuotasV20190624.ListServiceQuotaIncreaseRequestsInTemplate",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
ListServiceQuotaIncreaseRequestsInTemplateError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListServiceQuotaIncreaseRequestsInTemplateResponse, _>()
}
async fn list_service_quotas(
&self,
input: ListServiceQuotasRequest,
) -> Result<ListServiceQuotasResponse, RusotoError<ListServiceQuotasError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "ServiceQuotasV20190624.ListServiceQuotas");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListServiceQuotasError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListServiceQuotasResponse, _>()
}
async fn list_services(
&self,
input: ListServicesRequest,
) -> Result<ListServicesResponse, RusotoError<ListServicesError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "ServiceQuotasV20190624.ListServices");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListServicesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListServicesResponse, _>()
}
async fn put_service_quota_increase_request_into_template(
&self,
input: PutServiceQuotaIncreaseRequestIntoTemplateRequest,
) -> Result<
PutServiceQuotaIncreaseRequestIntoTemplateResponse,
RusotoError<PutServiceQuotaIncreaseRequestIntoTemplateError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"ServiceQuotasV20190624.PutServiceQuotaIncreaseRequestIntoTemplate",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
PutServiceQuotaIncreaseRequestIntoTemplateError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<PutServiceQuotaIncreaseRequestIntoTemplateResponse, _>()
}
async fn request_service_quota_increase(
&self,
input: RequestServiceQuotaIncreaseRequest,
) -> Result<RequestServiceQuotaIncreaseResponse, RusotoError<RequestServiceQuotaIncreaseError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"ServiceQuotasV20190624.RequestServiceQuotaIncrease",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, RequestServiceQuotaIncreaseError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<RequestServiceQuotaIncreaseResponse, _>()
}
}