use std::error::Error;
use std::fmt;
use async_trait::async_trait;
use rusoto_core::credential::ProvideAwsCredentials;
use rusoto_core::region;
use rusoto_core::request::{BufferedHttpResponse, DispatchSignedRequest};
use rusoto_core::{Client, RusotoError};
use rusoto_core::proto;
use rusoto_core::signature::SignedRequest;
#[allow(unused_imports)]
use serde::{Deserialize, Serialize};
use serde_json;
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AssociateResolverEndpointIpAddressRequest {
#[serde(rename = "IpAddress")]
pub ip_address: IpAddressUpdate,
#[serde(rename = "ResolverEndpointId")]
pub resolver_endpoint_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AssociateResolverEndpointIpAddressResponse {
#[serde(rename = "ResolverEndpoint")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resolver_endpoint: Option<ResolverEndpoint>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AssociateResolverRuleRequest {
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "ResolverRuleId")]
pub resolver_rule_id: String,
#[serde(rename = "VPCId")]
pub vpc_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AssociateResolverRuleResponse {
#[serde(rename = "ResolverRuleAssociation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resolver_rule_association: Option<ResolverRuleAssociation>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateResolverEndpointRequest {
#[serde(rename = "CreatorRequestId")]
pub creator_request_id: String,
#[serde(rename = "Direction")]
pub direction: String,
#[serde(rename = "IpAddresses")]
pub ip_addresses: Vec<IpAddressRequest>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "SecurityGroupIds")]
pub security_group_ids: Vec<String>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateResolverEndpointResponse {
#[serde(rename = "ResolverEndpoint")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resolver_endpoint: Option<ResolverEndpoint>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateResolverRuleRequest {
#[serde(rename = "CreatorRequestId")]
pub creator_request_id: String,
#[serde(rename = "DomainName")]
pub domain_name: String,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "ResolverEndpointId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resolver_endpoint_id: Option<String>,
#[serde(rename = "RuleType")]
pub rule_type: String,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
#[serde(rename = "TargetIps")]
#[serde(skip_serializing_if = "Option::is_none")]
pub target_ips: Option<Vec<TargetAddress>>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateResolverRuleResponse {
#[serde(rename = "ResolverRule")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resolver_rule: Option<ResolverRule>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteResolverEndpointRequest {
#[serde(rename = "ResolverEndpointId")]
pub resolver_endpoint_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteResolverEndpointResponse {
#[serde(rename = "ResolverEndpoint")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resolver_endpoint: Option<ResolverEndpoint>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteResolverRuleRequest {
#[serde(rename = "ResolverRuleId")]
pub resolver_rule_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteResolverRuleResponse {
#[serde(rename = "ResolverRule")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resolver_rule: Option<ResolverRule>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DisassociateResolverEndpointIpAddressRequest {
#[serde(rename = "IpAddress")]
pub ip_address: IpAddressUpdate,
#[serde(rename = "ResolverEndpointId")]
pub resolver_endpoint_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DisassociateResolverEndpointIpAddressResponse {
#[serde(rename = "ResolverEndpoint")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resolver_endpoint: Option<ResolverEndpoint>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DisassociateResolverRuleRequest {
#[serde(rename = "ResolverRuleId")]
pub resolver_rule_id: String,
#[serde(rename = "VPCId")]
pub vpc_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DisassociateResolverRuleResponse {
#[serde(rename = "ResolverRuleAssociation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resolver_rule_association: Option<ResolverRuleAssociation>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct Filter {
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "Values")]
#[serde(skip_serializing_if = "Option::is_none")]
pub values: Option<Vec<String>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetResolverEndpointRequest {
#[serde(rename = "ResolverEndpointId")]
pub resolver_endpoint_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetResolverEndpointResponse {
#[serde(rename = "ResolverEndpoint")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resolver_endpoint: Option<ResolverEndpoint>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetResolverRuleAssociationRequest {
#[serde(rename = "ResolverRuleAssociationId")]
pub resolver_rule_association_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetResolverRuleAssociationResponse {
#[serde(rename = "ResolverRuleAssociation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resolver_rule_association: Option<ResolverRuleAssociation>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetResolverRulePolicyRequest {
#[serde(rename = "Arn")]
pub arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetResolverRulePolicyResponse {
#[serde(rename = "ResolverRulePolicy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resolver_rule_policy: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetResolverRuleRequest {
#[serde(rename = "ResolverRuleId")]
pub resolver_rule_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetResolverRuleResponse {
#[serde(rename = "ResolverRule")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resolver_rule: Option<ResolverRule>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct IpAddressRequest {
#[serde(rename = "Ip")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ip: Option<String>,
#[serde(rename = "SubnetId")]
pub subnet_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct IpAddressResponse {
#[serde(rename = "CreationTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_time: Option<String>,
#[serde(rename = "Ip")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ip: Option<String>,
#[serde(rename = "IpId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ip_id: Option<String>,
#[serde(rename = "ModificationTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub modification_time: Option<String>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "StatusMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status_message: Option<String>,
#[serde(rename = "SubnetId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub subnet_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct IpAddressUpdate {
#[serde(rename = "Ip")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ip: Option<String>,
#[serde(rename = "IpId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ip_id: Option<String>,
#[serde(rename = "SubnetId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub subnet_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListResolverEndpointIpAddressesRequest {
#[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 = "ResolverEndpointId")]
pub resolver_endpoint_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListResolverEndpointIpAddressesResponse {
#[serde(rename = "IpAddresses")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ip_addresses: Option<Vec<IpAddressResponse>>,
#[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(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListResolverEndpointsRequest {
#[serde(rename = "Filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<Vec<Filter>>,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListResolverEndpointsResponse {
#[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 = "ResolverEndpoints")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resolver_endpoints: Option<Vec<ResolverEndpoint>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListResolverRuleAssociationsRequest {
#[serde(rename = "Filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<Vec<Filter>>,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListResolverRuleAssociationsResponse {
#[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 = "ResolverRuleAssociations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resolver_rule_associations: Option<Vec<ResolverRuleAssociation>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListResolverRulesRequest {
#[serde(rename = "Filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<Vec<Filter>>,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListResolverRulesResponse {
#[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 = "ResolverRules")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resolver_rules: Option<Vec<ResolverRule>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListTagsForResourceRequest {
#[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 = "ResourceArn")]
pub resource_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListTagsForResourceResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PutResolverRulePolicyRequest {
#[serde(rename = "Arn")]
pub arn: String,
#[serde(rename = "ResolverRulePolicy")]
pub resolver_rule_policy: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PutResolverRulePolicyResponse {
#[serde(rename = "ReturnValue")]
#[serde(skip_serializing_if = "Option::is_none")]
pub return_value: Option<bool>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ResolverEndpoint {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreationTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_time: Option<String>,
#[serde(rename = "CreatorRequestId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creator_request_id: Option<String>,
#[serde(rename = "Direction")]
#[serde(skip_serializing_if = "Option::is_none")]
pub direction: Option<String>,
#[serde(rename = "HostVPCId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub host_vpc_id: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "IpAddressCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ip_address_count: Option<i64>,
#[serde(rename = "ModificationTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub modification_time: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "SecurityGroupIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub security_group_ids: Option<Vec<String>>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "StatusMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status_message: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ResolverRule {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreatorRequestId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creator_request_id: Option<String>,
#[serde(rename = "DomainName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain_name: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "OwnerId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub owner_id: Option<String>,
#[serde(rename = "ResolverEndpointId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resolver_endpoint_id: Option<String>,
#[serde(rename = "RuleType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub rule_type: Option<String>,
#[serde(rename = "ShareStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub share_status: Option<String>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "StatusMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status_message: Option<String>,
#[serde(rename = "TargetIps")]
#[serde(skip_serializing_if = "Option::is_none")]
pub target_ips: Option<Vec<TargetAddress>>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ResolverRuleAssociation {
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "ResolverRuleId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resolver_rule_id: Option<String>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "StatusMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status_message: Option<String>,
#[serde(rename = "VPCId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpc_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ResolverRuleConfig {
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "ResolverEndpointId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resolver_endpoint_id: Option<String>,
#[serde(rename = "TargetIps")]
#[serde(skip_serializing_if = "Option::is_none")]
pub target_ips: Option<Vec<TargetAddress>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Tag {
#[serde(rename = "Key")]
#[serde(skip_serializing_if = "Option::is_none")]
pub key: Option<String>,
#[serde(rename = "Value")]
#[serde(skip_serializing_if = "Option::is_none")]
pub value: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct TagResourceRequest {
#[serde(rename = "ResourceArn")]
pub resource_arn: String,
#[serde(rename = "Tags")]
pub tags: Vec<Tag>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct TagResourceResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct TargetAddress {
#[serde(rename = "Ip")]
pub ip: String,
#[serde(rename = "Port")]
#[serde(skip_serializing_if = "Option::is_none")]
pub port: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UntagResourceRequest {
#[serde(rename = "ResourceArn")]
pub resource_arn: String,
#[serde(rename = "TagKeys")]
pub tag_keys: Vec<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UntagResourceResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateResolverEndpointRequest {
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "ResolverEndpointId")]
pub resolver_endpoint_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateResolverEndpointResponse {
#[serde(rename = "ResolverEndpoint")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resolver_endpoint: Option<ResolverEndpoint>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateResolverRuleRequest {
#[serde(rename = "Config")]
pub config: ResolverRuleConfig,
#[serde(rename = "ResolverRuleId")]
pub resolver_rule_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateResolverRuleResponse {
#[serde(rename = "ResolverRule")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resolver_rule: Option<ResolverRule>,
}
#[derive(Debug, PartialEq)]
pub enum AssociateResolverEndpointIpAddressError {
InternalServiceError(String),
InvalidParameter(String),
InvalidRequest(String),
LimitExceeded(String),
ResourceExists(String),
ResourceNotFound(String),
Throttling(String),
}
impl AssociateResolverEndpointIpAddressError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<AssociateResolverEndpointIpAddressError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServiceErrorException" => {
return RusotoError::Service(
AssociateResolverEndpointIpAddressError::InternalServiceError(err.msg),
)
}
"InvalidParameterException" => {
return RusotoError::Service(
AssociateResolverEndpointIpAddressError::InvalidParameter(err.msg),
)
}
"InvalidRequestException" => {
return RusotoError::Service(
AssociateResolverEndpointIpAddressError::InvalidRequest(err.msg),
)
}
"LimitExceededException" => {
return RusotoError::Service(
AssociateResolverEndpointIpAddressError::LimitExceeded(err.msg),
)
}
"ResourceExistsException" => {
return RusotoError::Service(
AssociateResolverEndpointIpAddressError::ResourceExists(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
AssociateResolverEndpointIpAddressError::ResourceNotFound(err.msg),
)
}
"ThrottlingException" => {
return RusotoError::Service(
AssociateResolverEndpointIpAddressError::Throttling(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AssociateResolverEndpointIpAddressError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AssociateResolverEndpointIpAddressError::InternalServiceError(ref cause) => {
write!(f, "{}", cause)
}
AssociateResolverEndpointIpAddressError::InvalidParameter(ref cause) => {
write!(f, "{}", cause)
}
AssociateResolverEndpointIpAddressError::InvalidRequest(ref cause) => {
write!(f, "{}", cause)
}
AssociateResolverEndpointIpAddressError::LimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
AssociateResolverEndpointIpAddressError::ResourceExists(ref cause) => {
write!(f, "{}", cause)
}
AssociateResolverEndpointIpAddressError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
AssociateResolverEndpointIpAddressError::Throttling(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for AssociateResolverEndpointIpAddressError {}
#[derive(Debug, PartialEq)]
pub enum AssociateResolverRuleError {
InternalServiceError(String),
InvalidParameter(String),
InvalidRequest(String),
ResourceExists(String),
ResourceNotFound(String),
ResourceUnavailable(String),
Throttling(String),
}
impl AssociateResolverRuleError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AssociateResolverRuleError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServiceErrorException" => {
return RusotoError::Service(AssociateResolverRuleError::InternalServiceError(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(AssociateResolverRuleError::InvalidParameter(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(AssociateResolverRuleError::InvalidRequest(
err.msg,
))
}
"ResourceExistsException" => {
return RusotoError::Service(AssociateResolverRuleError::ResourceExists(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(AssociateResolverRuleError::ResourceNotFound(
err.msg,
))
}
"ResourceUnavailableException" => {
return RusotoError::Service(AssociateResolverRuleError::ResourceUnavailable(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(AssociateResolverRuleError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AssociateResolverRuleError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AssociateResolverRuleError::InternalServiceError(ref cause) => write!(f, "{}", cause),
AssociateResolverRuleError::InvalidParameter(ref cause) => write!(f, "{}", cause),
AssociateResolverRuleError::InvalidRequest(ref cause) => write!(f, "{}", cause),
AssociateResolverRuleError::ResourceExists(ref cause) => write!(f, "{}", cause),
AssociateResolverRuleError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
AssociateResolverRuleError::ResourceUnavailable(ref cause) => write!(f, "{}", cause),
AssociateResolverRuleError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for AssociateResolverRuleError {}
#[derive(Debug, PartialEq)]
pub enum CreateResolverEndpointError {
InternalServiceError(String),
InvalidParameter(String),
InvalidRequest(String),
LimitExceeded(String),
ResourceExists(String),
ResourceNotFound(String),
Throttling(String),
}
impl CreateResolverEndpointError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateResolverEndpointError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServiceErrorException" => {
return RusotoError::Service(CreateResolverEndpointError::InternalServiceError(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(CreateResolverEndpointError::InvalidParameter(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(CreateResolverEndpointError::InvalidRequest(
err.msg,
))
}
"LimitExceededException" => {
return RusotoError::Service(CreateResolverEndpointError::LimitExceeded(
err.msg,
))
}
"ResourceExistsException" => {
return RusotoError::Service(CreateResolverEndpointError::ResourceExists(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(CreateResolverEndpointError::ResourceNotFound(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(CreateResolverEndpointError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateResolverEndpointError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateResolverEndpointError::InternalServiceError(ref cause) => write!(f, "{}", cause),
CreateResolverEndpointError::InvalidParameter(ref cause) => write!(f, "{}", cause),
CreateResolverEndpointError::InvalidRequest(ref cause) => write!(f, "{}", cause),
CreateResolverEndpointError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreateResolverEndpointError::ResourceExists(ref cause) => write!(f, "{}", cause),
CreateResolverEndpointError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
CreateResolverEndpointError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateResolverEndpointError {}
#[derive(Debug, PartialEq)]
pub enum CreateResolverRuleError {
InternalServiceError(String),
InvalidParameter(String),
InvalidRequest(String),
LimitExceeded(String),
ResourceExists(String),
ResourceNotFound(String),
ResourceUnavailable(String),
Throttling(String),
}
impl CreateResolverRuleError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateResolverRuleError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServiceErrorException" => {
return RusotoError::Service(CreateResolverRuleError::InternalServiceError(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(CreateResolverRuleError::InvalidParameter(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(CreateResolverRuleError::InvalidRequest(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(CreateResolverRuleError::LimitExceeded(err.msg))
}
"ResourceExistsException" => {
return RusotoError::Service(CreateResolverRuleError::ResourceExists(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(CreateResolverRuleError::ResourceNotFound(err.msg))
}
"ResourceUnavailableException" => {
return RusotoError::Service(CreateResolverRuleError::ResourceUnavailable(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(CreateResolverRuleError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateResolverRuleError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateResolverRuleError::InternalServiceError(ref cause) => write!(f, "{}", cause),
CreateResolverRuleError::InvalidParameter(ref cause) => write!(f, "{}", cause),
CreateResolverRuleError::InvalidRequest(ref cause) => write!(f, "{}", cause),
CreateResolverRuleError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreateResolverRuleError::ResourceExists(ref cause) => write!(f, "{}", cause),
CreateResolverRuleError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
CreateResolverRuleError::ResourceUnavailable(ref cause) => write!(f, "{}", cause),
CreateResolverRuleError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateResolverRuleError {}
#[derive(Debug, PartialEq)]
pub enum DeleteResolverEndpointError {
InternalServiceError(String),
InvalidParameter(String),
InvalidRequest(String),
ResourceNotFound(String),
Throttling(String),
}
impl DeleteResolverEndpointError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteResolverEndpointError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServiceErrorException" => {
return RusotoError::Service(DeleteResolverEndpointError::InternalServiceError(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(DeleteResolverEndpointError::InvalidParameter(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(DeleteResolverEndpointError::InvalidRequest(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DeleteResolverEndpointError::ResourceNotFound(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(DeleteResolverEndpointError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteResolverEndpointError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteResolverEndpointError::InternalServiceError(ref cause) => write!(f, "{}", cause),
DeleteResolverEndpointError::InvalidParameter(ref cause) => write!(f, "{}", cause),
DeleteResolverEndpointError::InvalidRequest(ref cause) => write!(f, "{}", cause),
DeleteResolverEndpointError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DeleteResolverEndpointError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteResolverEndpointError {}
#[derive(Debug, PartialEq)]
pub enum DeleteResolverRuleError {
InternalServiceError(String),
InvalidParameter(String),
ResourceInUse(String),
ResourceNotFound(String),
Throttling(String),
}
impl DeleteResolverRuleError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteResolverRuleError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServiceErrorException" => {
return RusotoError::Service(DeleteResolverRuleError::InternalServiceError(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(DeleteResolverRuleError::InvalidParameter(err.msg))
}
"ResourceInUseException" => {
return RusotoError::Service(DeleteResolverRuleError::ResourceInUse(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DeleteResolverRuleError::ResourceNotFound(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(DeleteResolverRuleError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteResolverRuleError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteResolverRuleError::InternalServiceError(ref cause) => write!(f, "{}", cause),
DeleteResolverRuleError::InvalidParameter(ref cause) => write!(f, "{}", cause),
DeleteResolverRuleError::ResourceInUse(ref cause) => write!(f, "{}", cause),
DeleteResolverRuleError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DeleteResolverRuleError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteResolverRuleError {}
#[derive(Debug, PartialEq)]
pub enum DisassociateResolverEndpointIpAddressError {
InternalServiceError(String),
InvalidParameter(String),
InvalidRequest(String),
ResourceExists(String),
ResourceNotFound(String),
Throttling(String),
}
impl DisassociateResolverEndpointIpAddressError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DisassociateResolverEndpointIpAddressError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServiceErrorException" => {
return RusotoError::Service(
DisassociateResolverEndpointIpAddressError::InternalServiceError(err.msg),
)
}
"InvalidParameterException" => {
return RusotoError::Service(
DisassociateResolverEndpointIpAddressError::InvalidParameter(err.msg),
)
}
"InvalidRequestException" => {
return RusotoError::Service(
DisassociateResolverEndpointIpAddressError::InvalidRequest(err.msg),
)
}
"ResourceExistsException" => {
return RusotoError::Service(
DisassociateResolverEndpointIpAddressError::ResourceExists(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
DisassociateResolverEndpointIpAddressError::ResourceNotFound(err.msg),
)
}
"ThrottlingException" => {
return RusotoError::Service(
DisassociateResolverEndpointIpAddressError::Throttling(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DisassociateResolverEndpointIpAddressError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DisassociateResolverEndpointIpAddressError::InternalServiceError(ref cause) => {
write!(f, "{}", cause)
}
DisassociateResolverEndpointIpAddressError::InvalidParameter(ref cause) => {
write!(f, "{}", cause)
}
DisassociateResolverEndpointIpAddressError::InvalidRequest(ref cause) => {
write!(f, "{}", cause)
}
DisassociateResolverEndpointIpAddressError::ResourceExists(ref cause) => {
write!(f, "{}", cause)
}
DisassociateResolverEndpointIpAddressError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
DisassociateResolverEndpointIpAddressError::Throttling(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DisassociateResolverEndpointIpAddressError {}
#[derive(Debug, PartialEq)]
pub enum DisassociateResolverRuleError {
InternalServiceError(String),
InvalidParameter(String),
ResourceNotFound(String),
Throttling(String),
}
impl DisassociateResolverRuleError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DisassociateResolverRuleError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServiceErrorException" => {
return RusotoError::Service(
DisassociateResolverRuleError::InternalServiceError(err.msg),
)
}
"InvalidParameterException" => {
return RusotoError::Service(DisassociateResolverRuleError::InvalidParameter(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DisassociateResolverRuleError::ResourceNotFound(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(DisassociateResolverRuleError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DisassociateResolverRuleError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DisassociateResolverRuleError::InternalServiceError(ref cause) => {
write!(f, "{}", cause)
}
DisassociateResolverRuleError::InvalidParameter(ref cause) => write!(f, "{}", cause),
DisassociateResolverRuleError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DisassociateResolverRuleError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DisassociateResolverRuleError {}
#[derive(Debug, PartialEq)]
pub enum GetResolverEndpointError {
InternalServiceError(String),
InvalidParameter(String),
ResourceNotFound(String),
Throttling(String),
}
impl GetResolverEndpointError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetResolverEndpointError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServiceErrorException" => {
return RusotoError::Service(GetResolverEndpointError::InternalServiceError(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(GetResolverEndpointError::InvalidParameter(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(GetResolverEndpointError::ResourceNotFound(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(GetResolverEndpointError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetResolverEndpointError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetResolverEndpointError::InternalServiceError(ref cause) => write!(f, "{}", cause),
GetResolverEndpointError::InvalidParameter(ref cause) => write!(f, "{}", cause),
GetResolverEndpointError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
GetResolverEndpointError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetResolverEndpointError {}
#[derive(Debug, PartialEq)]
pub enum GetResolverRuleError {
InternalServiceError(String),
InvalidParameter(String),
ResourceNotFound(String),
Throttling(String),
}
impl GetResolverRuleError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetResolverRuleError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServiceErrorException" => {
return RusotoError::Service(GetResolverRuleError::InternalServiceError(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(GetResolverRuleError::InvalidParameter(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(GetResolverRuleError::ResourceNotFound(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(GetResolverRuleError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetResolverRuleError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetResolverRuleError::InternalServiceError(ref cause) => write!(f, "{}", cause),
GetResolverRuleError::InvalidParameter(ref cause) => write!(f, "{}", cause),
GetResolverRuleError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
GetResolverRuleError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetResolverRuleError {}
#[derive(Debug, PartialEq)]
pub enum GetResolverRuleAssociationError {
InternalServiceError(String),
InvalidParameter(String),
ResourceNotFound(String),
Throttling(String),
}
impl GetResolverRuleAssociationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetResolverRuleAssociationError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServiceErrorException" => {
return RusotoError::Service(
GetResolverRuleAssociationError::InternalServiceError(err.msg),
)
}
"InvalidParameterException" => {
return RusotoError::Service(GetResolverRuleAssociationError::InvalidParameter(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(GetResolverRuleAssociationError::ResourceNotFound(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(GetResolverRuleAssociationError::Throttling(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetResolverRuleAssociationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetResolverRuleAssociationError::InternalServiceError(ref cause) => {
write!(f, "{}", cause)
}
GetResolverRuleAssociationError::InvalidParameter(ref cause) => write!(f, "{}", cause),
GetResolverRuleAssociationError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
GetResolverRuleAssociationError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetResolverRuleAssociationError {}
#[derive(Debug, PartialEq)]
pub enum GetResolverRulePolicyError {
InternalServiceError(String),
InvalidParameter(String),
UnknownResource(String),
}
impl GetResolverRulePolicyError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetResolverRulePolicyError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServiceErrorException" => {
return RusotoError::Service(GetResolverRulePolicyError::InternalServiceError(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(GetResolverRulePolicyError::InvalidParameter(
err.msg,
))
}
"UnknownResourceException" => {
return RusotoError::Service(GetResolverRulePolicyError::UnknownResource(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetResolverRulePolicyError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetResolverRulePolicyError::InternalServiceError(ref cause) => write!(f, "{}", cause),
GetResolverRulePolicyError::InvalidParameter(ref cause) => write!(f, "{}", cause),
GetResolverRulePolicyError::UnknownResource(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetResolverRulePolicyError {}
#[derive(Debug, PartialEq)]
pub enum ListResolverEndpointIpAddressesError {
InternalServiceError(String),
InvalidNextToken(String),
InvalidParameter(String),
ResourceNotFound(String),
Throttling(String),
}
impl ListResolverEndpointIpAddressesError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListResolverEndpointIpAddressesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServiceErrorException" => {
return RusotoError::Service(
ListResolverEndpointIpAddressesError::InternalServiceError(err.msg),
)
}
"InvalidNextTokenException" => {
return RusotoError::Service(
ListResolverEndpointIpAddressesError::InvalidNextToken(err.msg),
)
}
"InvalidParameterException" => {
return RusotoError::Service(
ListResolverEndpointIpAddressesError::InvalidParameter(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
ListResolverEndpointIpAddressesError::ResourceNotFound(err.msg),
)
}
"ThrottlingException" => {
return RusotoError::Service(ListResolverEndpointIpAddressesError::Throttling(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListResolverEndpointIpAddressesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListResolverEndpointIpAddressesError::InternalServiceError(ref cause) => {
write!(f, "{}", cause)
}
ListResolverEndpointIpAddressesError::InvalidNextToken(ref cause) => {
write!(f, "{}", cause)
}
ListResolverEndpointIpAddressesError::InvalidParameter(ref cause) => {
write!(f, "{}", cause)
}
ListResolverEndpointIpAddressesError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
ListResolverEndpointIpAddressesError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListResolverEndpointIpAddressesError {}
#[derive(Debug, PartialEq)]
pub enum ListResolverEndpointsError {
InternalServiceError(String),
InvalidNextToken(String),
InvalidParameter(String),
InvalidRequest(String),
Throttling(String),
}
impl ListResolverEndpointsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListResolverEndpointsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServiceErrorException" => {
return RusotoError::Service(ListResolverEndpointsError::InternalServiceError(
err.msg,
))
}
"InvalidNextTokenException" => {
return RusotoError::Service(ListResolverEndpointsError::InvalidNextToken(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(ListResolverEndpointsError::InvalidParameter(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(ListResolverEndpointsError::InvalidRequest(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(ListResolverEndpointsError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListResolverEndpointsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListResolverEndpointsError::InternalServiceError(ref cause) => write!(f, "{}", cause),
ListResolverEndpointsError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
ListResolverEndpointsError::InvalidParameter(ref cause) => write!(f, "{}", cause),
ListResolverEndpointsError::InvalidRequest(ref cause) => write!(f, "{}", cause),
ListResolverEndpointsError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListResolverEndpointsError {}
#[derive(Debug, PartialEq)]
pub enum ListResolverRuleAssociationsError {
InternalServiceError(String),
InvalidNextToken(String),
InvalidParameter(String),
InvalidRequest(String),
Throttling(String),
}
impl ListResolverRuleAssociationsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListResolverRuleAssociationsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServiceErrorException" => {
return RusotoError::Service(
ListResolverRuleAssociationsError::InternalServiceError(err.msg),
)
}
"InvalidNextTokenException" => {
return RusotoError::Service(
ListResolverRuleAssociationsError::InvalidNextToken(err.msg),
)
}
"InvalidParameterException" => {
return RusotoError::Service(
ListResolverRuleAssociationsError::InvalidParameter(err.msg),
)
}
"InvalidRequestException" => {
return RusotoError::Service(ListResolverRuleAssociationsError::InvalidRequest(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(ListResolverRuleAssociationsError::Throttling(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListResolverRuleAssociationsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListResolverRuleAssociationsError::InternalServiceError(ref cause) => {
write!(f, "{}", cause)
}
ListResolverRuleAssociationsError::InvalidNextToken(ref cause) => {
write!(f, "{}", cause)
}
ListResolverRuleAssociationsError::InvalidParameter(ref cause) => {
write!(f, "{}", cause)
}
ListResolverRuleAssociationsError::InvalidRequest(ref cause) => write!(f, "{}", cause),
ListResolverRuleAssociationsError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListResolverRuleAssociationsError {}
#[derive(Debug, PartialEq)]
pub enum ListResolverRulesError {
InternalServiceError(String),
InvalidNextToken(String),
InvalidParameter(String),
InvalidRequest(String),
Throttling(String),
}
impl ListResolverRulesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListResolverRulesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServiceErrorException" => {
return RusotoError::Service(ListResolverRulesError::InternalServiceError(
err.msg,
))
}
"InvalidNextTokenException" => {
return RusotoError::Service(ListResolverRulesError::InvalidNextToken(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(ListResolverRulesError::InvalidParameter(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(ListResolverRulesError::InvalidRequest(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(ListResolverRulesError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListResolverRulesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListResolverRulesError::InternalServiceError(ref cause) => write!(f, "{}", cause),
ListResolverRulesError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
ListResolverRulesError::InvalidParameter(ref cause) => write!(f, "{}", cause),
ListResolverRulesError::InvalidRequest(ref cause) => write!(f, "{}", cause),
ListResolverRulesError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListResolverRulesError {}
#[derive(Debug, PartialEq)]
pub enum ListTagsForResourceError {
InternalServiceError(String),
InvalidNextToken(String),
InvalidParameter(String),
InvalidRequest(String),
ResourceNotFound(String),
Throttling(String),
}
impl ListTagsForResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListTagsForResourceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServiceErrorException" => {
return RusotoError::Service(ListTagsForResourceError::InternalServiceError(
err.msg,
))
}
"InvalidNextTokenException" => {
return RusotoError::Service(ListTagsForResourceError::InvalidNextToken(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(ListTagsForResourceError::InvalidParameter(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(ListTagsForResourceError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListTagsForResourceError::ResourceNotFound(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(ListTagsForResourceError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListTagsForResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListTagsForResourceError::InternalServiceError(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::InvalidParameter(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::InvalidRequest(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListTagsForResourceError {}
#[derive(Debug, PartialEq)]
pub enum PutResolverRulePolicyError {
InternalServiceError(String),
InvalidParameter(String),
InvalidPolicyDocument(String),
UnknownResource(String),
}
impl PutResolverRulePolicyError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<PutResolverRulePolicyError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServiceErrorException" => {
return RusotoError::Service(PutResolverRulePolicyError::InternalServiceError(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(PutResolverRulePolicyError::InvalidParameter(
err.msg,
))
}
"InvalidPolicyDocument" => {
return RusotoError::Service(PutResolverRulePolicyError::InvalidPolicyDocument(
err.msg,
))
}
"UnknownResourceException" => {
return RusotoError::Service(PutResolverRulePolicyError::UnknownResource(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for PutResolverRulePolicyError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PutResolverRulePolicyError::InternalServiceError(ref cause) => write!(f, "{}", cause),
PutResolverRulePolicyError::InvalidParameter(ref cause) => write!(f, "{}", cause),
PutResolverRulePolicyError::InvalidPolicyDocument(ref cause) => write!(f, "{}", cause),
PutResolverRulePolicyError::UnknownResource(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for PutResolverRulePolicyError {}
#[derive(Debug, PartialEq)]
pub enum TagResourceError {
InternalServiceError(String),
InvalidParameter(String),
InvalidTag(String),
LimitExceeded(String),
ResourceNotFound(String),
Throttling(String),
}
impl TagResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<TagResourceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServiceErrorException" => {
return RusotoError::Service(TagResourceError::InternalServiceError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(TagResourceError::InvalidParameter(err.msg))
}
"InvalidTagException" => {
return RusotoError::Service(TagResourceError::InvalidTag(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(TagResourceError::LimitExceeded(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(TagResourceError::ResourceNotFound(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(TagResourceError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for TagResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
TagResourceError::InternalServiceError(ref cause) => write!(f, "{}", cause),
TagResourceError::InvalidParameter(ref cause) => write!(f, "{}", cause),
TagResourceError::InvalidTag(ref cause) => write!(f, "{}", cause),
TagResourceError::LimitExceeded(ref cause) => write!(f, "{}", cause),
TagResourceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
TagResourceError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for TagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UntagResourceError {
InternalServiceError(String),
InvalidParameter(String),
ResourceNotFound(String),
Throttling(String),
}
impl UntagResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UntagResourceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServiceErrorException" => {
return RusotoError::Service(UntagResourceError::InternalServiceError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(UntagResourceError::InvalidParameter(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UntagResourceError::ResourceNotFound(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(UntagResourceError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UntagResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UntagResourceError::InternalServiceError(ref cause) => write!(f, "{}", cause),
UntagResourceError::InvalidParameter(ref cause) => write!(f, "{}", cause),
UntagResourceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
UntagResourceError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UntagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UpdateResolverEndpointError {
InternalServiceError(String),
InvalidParameter(String),
InvalidRequest(String),
ResourceNotFound(String),
Throttling(String),
}
impl UpdateResolverEndpointError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateResolverEndpointError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServiceErrorException" => {
return RusotoError::Service(UpdateResolverEndpointError::InternalServiceError(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(UpdateResolverEndpointError::InvalidParameter(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(UpdateResolverEndpointError::InvalidRequest(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UpdateResolverEndpointError::ResourceNotFound(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(UpdateResolverEndpointError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateResolverEndpointError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateResolverEndpointError::InternalServiceError(ref cause) => write!(f, "{}", cause),
UpdateResolverEndpointError::InvalidParameter(ref cause) => write!(f, "{}", cause),
UpdateResolverEndpointError::InvalidRequest(ref cause) => write!(f, "{}", cause),
UpdateResolverEndpointError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
UpdateResolverEndpointError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateResolverEndpointError {}
#[derive(Debug, PartialEq)]
pub enum UpdateResolverRuleError {
InternalServiceError(String),
InvalidParameter(String),
InvalidRequest(String),
LimitExceeded(String),
ResourceNotFound(String),
ResourceUnavailable(String),
Throttling(String),
}
impl UpdateResolverRuleError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateResolverRuleError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServiceErrorException" => {
return RusotoError::Service(UpdateResolverRuleError::InternalServiceError(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(UpdateResolverRuleError::InvalidParameter(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(UpdateResolverRuleError::InvalidRequest(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(UpdateResolverRuleError::LimitExceeded(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UpdateResolverRuleError::ResourceNotFound(err.msg))
}
"ResourceUnavailableException" => {
return RusotoError::Service(UpdateResolverRuleError::ResourceUnavailable(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(UpdateResolverRuleError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateResolverRuleError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateResolverRuleError::InternalServiceError(ref cause) => write!(f, "{}", cause),
UpdateResolverRuleError::InvalidParameter(ref cause) => write!(f, "{}", cause),
UpdateResolverRuleError::InvalidRequest(ref cause) => write!(f, "{}", cause),
UpdateResolverRuleError::LimitExceeded(ref cause) => write!(f, "{}", cause),
UpdateResolverRuleError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
UpdateResolverRuleError::ResourceUnavailable(ref cause) => write!(f, "{}", cause),
UpdateResolverRuleError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateResolverRuleError {}
#[async_trait]
pub trait Route53Resolver {
async fn associate_resolver_endpoint_ip_address(
&self,
input: AssociateResolverEndpointIpAddressRequest,
) -> Result<
AssociateResolverEndpointIpAddressResponse,
RusotoError<AssociateResolverEndpointIpAddressError>,
>;
async fn associate_resolver_rule(
&self,
input: AssociateResolverRuleRequest,
) -> Result<AssociateResolverRuleResponse, RusotoError<AssociateResolverRuleError>>;
async fn create_resolver_endpoint(
&self,
input: CreateResolverEndpointRequest,
) -> Result<CreateResolverEndpointResponse, RusotoError<CreateResolverEndpointError>>;
async fn create_resolver_rule(
&self,
input: CreateResolverRuleRequest,
) -> Result<CreateResolverRuleResponse, RusotoError<CreateResolverRuleError>>;
async fn delete_resolver_endpoint(
&self,
input: DeleteResolverEndpointRequest,
) -> Result<DeleteResolverEndpointResponse, RusotoError<DeleteResolverEndpointError>>;
async fn delete_resolver_rule(
&self,
input: DeleteResolverRuleRequest,
) -> Result<DeleteResolverRuleResponse, RusotoError<DeleteResolverRuleError>>;
async fn disassociate_resolver_endpoint_ip_address(
&self,
input: DisassociateResolverEndpointIpAddressRequest,
) -> Result<
DisassociateResolverEndpointIpAddressResponse,
RusotoError<DisassociateResolverEndpointIpAddressError>,
>;
async fn disassociate_resolver_rule(
&self,
input: DisassociateResolverRuleRequest,
) -> Result<DisassociateResolverRuleResponse, RusotoError<DisassociateResolverRuleError>>;
async fn get_resolver_endpoint(
&self,
input: GetResolverEndpointRequest,
) -> Result<GetResolverEndpointResponse, RusotoError<GetResolverEndpointError>>;
async fn get_resolver_rule(
&self,
input: GetResolverRuleRequest,
) -> Result<GetResolverRuleResponse, RusotoError<GetResolverRuleError>>;
async fn get_resolver_rule_association(
&self,
input: GetResolverRuleAssociationRequest,
) -> Result<GetResolverRuleAssociationResponse, RusotoError<GetResolverRuleAssociationError>>;
async fn get_resolver_rule_policy(
&self,
input: GetResolverRulePolicyRequest,
) -> Result<GetResolverRulePolicyResponse, RusotoError<GetResolverRulePolicyError>>;
async fn list_resolver_endpoint_ip_addresses(
&self,
input: ListResolverEndpointIpAddressesRequest,
) -> Result<
ListResolverEndpointIpAddressesResponse,
RusotoError<ListResolverEndpointIpAddressesError>,
>;
async fn list_resolver_endpoints(
&self,
input: ListResolverEndpointsRequest,
) -> Result<ListResolverEndpointsResponse, RusotoError<ListResolverEndpointsError>>;
async fn list_resolver_rule_associations(
&self,
input: ListResolverRuleAssociationsRequest,
) -> Result<ListResolverRuleAssociationsResponse, RusotoError<ListResolverRuleAssociationsError>>;
async fn list_resolver_rules(
&self,
input: ListResolverRulesRequest,
) -> Result<ListResolverRulesResponse, RusotoError<ListResolverRulesError>>;
async fn list_tags_for_resource(
&self,
input: ListTagsForResourceRequest,
) -> Result<ListTagsForResourceResponse, RusotoError<ListTagsForResourceError>>;
async fn put_resolver_rule_policy(
&self,
input: PutResolverRulePolicyRequest,
) -> Result<PutResolverRulePolicyResponse, RusotoError<PutResolverRulePolicyError>>;
async fn tag_resource(
&self,
input: TagResourceRequest,
) -> Result<TagResourceResponse, RusotoError<TagResourceError>>;
async fn untag_resource(
&self,
input: UntagResourceRequest,
) -> Result<UntagResourceResponse, RusotoError<UntagResourceError>>;
async fn update_resolver_endpoint(
&self,
input: UpdateResolverEndpointRequest,
) -> Result<UpdateResolverEndpointResponse, RusotoError<UpdateResolverEndpointError>>;
async fn update_resolver_rule(
&self,
input: UpdateResolverRuleRequest,
) -> Result<UpdateResolverRuleResponse, RusotoError<UpdateResolverRuleError>>;
}
#[derive(Clone)]
pub struct Route53ResolverClient {
client: Client,
region: region::Region,
}
impl Route53ResolverClient {
pub fn new(region: region::Region) -> Route53ResolverClient {
Route53ResolverClient {
client: Client::shared(),
region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> Route53ResolverClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
D: DispatchSignedRequest + Send + Sync + 'static,
{
Route53ResolverClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region,
}
}
pub fn new_with_client(client: Client, region: region::Region) -> Route53ResolverClient {
Route53ResolverClient { client, region }
}
}
#[async_trait]
impl Route53Resolver for Route53ResolverClient {
async fn associate_resolver_endpoint_ip_address(
&self,
input: AssociateResolverEndpointIpAddressRequest,
) -> Result<
AssociateResolverEndpointIpAddressResponse,
RusotoError<AssociateResolverEndpointIpAddressError>,
> {
let mut request = SignedRequest::new("POST", "route53resolver", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"Route53Resolver.AssociateResolverEndpointIpAddress",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<AssociateResolverEndpointIpAddressResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(AssociateResolverEndpointIpAddressError::from_response(
response,
))
}
}
async fn associate_resolver_rule(
&self,
input: AssociateResolverRuleRequest,
) -> Result<AssociateResolverRuleResponse, RusotoError<AssociateResolverRuleError>> {
let mut request = SignedRequest::new("POST", "route53resolver", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "Route53Resolver.AssociateResolverRule");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<AssociateResolverRuleResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(AssociateResolverRuleError::from_response(response))
}
}
async fn create_resolver_endpoint(
&self,
input: CreateResolverEndpointRequest,
) -> Result<CreateResolverEndpointResponse, RusotoError<CreateResolverEndpointError>> {
let mut request = SignedRequest::new("POST", "route53resolver", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "Route53Resolver.CreateResolverEndpoint");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<CreateResolverEndpointResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(CreateResolverEndpointError::from_response(response))
}
}
async fn create_resolver_rule(
&self,
input: CreateResolverRuleRequest,
) -> Result<CreateResolverRuleResponse, RusotoError<CreateResolverRuleError>> {
let mut request = SignedRequest::new("POST", "route53resolver", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "Route53Resolver.CreateResolverRule");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<CreateResolverRuleResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(CreateResolverRuleError::from_response(response))
}
}
async fn delete_resolver_endpoint(
&self,
input: DeleteResolverEndpointRequest,
) -> Result<DeleteResolverEndpointResponse, RusotoError<DeleteResolverEndpointError>> {
let mut request = SignedRequest::new("POST", "route53resolver", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "Route53Resolver.DeleteResolverEndpoint");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteResolverEndpointResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(DeleteResolverEndpointError::from_response(response))
}
}
async fn delete_resolver_rule(
&self,
input: DeleteResolverRuleRequest,
) -> Result<DeleteResolverRuleResponse, RusotoError<DeleteResolverRuleError>> {
let mut request = SignedRequest::new("POST", "route53resolver", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "Route53Resolver.DeleteResolverRule");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteResolverRuleResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(DeleteResolverRuleError::from_response(response))
}
}
async fn disassociate_resolver_endpoint_ip_address(
&self,
input: DisassociateResolverEndpointIpAddressRequest,
) -> Result<
DisassociateResolverEndpointIpAddressResponse,
RusotoError<DisassociateResolverEndpointIpAddressError>,
> {
let mut request = SignedRequest::new("POST", "route53resolver", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"Route53Resolver.DisassociateResolverEndpointIpAddress",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DisassociateResolverEndpointIpAddressResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(DisassociateResolverEndpointIpAddressError::from_response(
response,
))
}
}
async fn disassociate_resolver_rule(
&self,
input: DisassociateResolverRuleRequest,
) -> Result<DisassociateResolverRuleResponse, RusotoError<DisassociateResolverRuleError>> {
let mut request = SignedRequest::new("POST", "route53resolver", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "Route53Resolver.DisassociateResolverRule");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DisassociateResolverRuleResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(DisassociateResolverRuleError::from_response(response))
}
}
async fn get_resolver_endpoint(
&self,
input: GetResolverEndpointRequest,
) -> Result<GetResolverEndpointResponse, RusotoError<GetResolverEndpointError>> {
let mut request = SignedRequest::new("POST", "route53resolver", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "Route53Resolver.GetResolverEndpoint");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<GetResolverEndpointResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(GetResolverEndpointError::from_response(response))
}
}
async fn get_resolver_rule(
&self,
input: GetResolverRuleRequest,
) -> Result<GetResolverRuleResponse, RusotoError<GetResolverRuleError>> {
let mut request = SignedRequest::new("POST", "route53resolver", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "Route53Resolver.GetResolverRule");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetResolverRuleResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(GetResolverRuleError::from_response(response))
}
}
async fn get_resolver_rule_association(
&self,
input: GetResolverRuleAssociationRequest,
) -> Result<GetResolverRuleAssociationResponse, RusotoError<GetResolverRuleAssociationError>>
{
let mut request = SignedRequest::new("POST", "route53resolver", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "Route53Resolver.GetResolverRuleAssociation");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<GetResolverRuleAssociationResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(GetResolverRuleAssociationError::from_response(response))
}
}
async fn get_resolver_rule_policy(
&self,
input: GetResolverRulePolicyRequest,
) -> Result<GetResolverRulePolicyResponse, RusotoError<GetResolverRulePolicyError>> {
let mut request = SignedRequest::new("POST", "route53resolver", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "Route53Resolver.GetResolverRulePolicy");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<GetResolverRulePolicyResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(GetResolverRulePolicyError::from_response(response))
}
}
async fn list_resolver_endpoint_ip_addresses(
&self,
input: ListResolverEndpointIpAddressesRequest,
) -> Result<
ListResolverEndpointIpAddressesResponse,
RusotoError<ListResolverEndpointIpAddressesError>,
> {
let mut request = SignedRequest::new("POST", "route53resolver", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"Route53Resolver.ListResolverEndpointIpAddresses",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListResolverEndpointIpAddressesResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(ListResolverEndpointIpAddressesError::from_response(
response,
))
}
}
async fn list_resolver_endpoints(
&self,
input: ListResolverEndpointsRequest,
) -> Result<ListResolverEndpointsResponse, RusotoError<ListResolverEndpointsError>> {
let mut request = SignedRequest::new("POST", "route53resolver", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "Route53Resolver.ListResolverEndpoints");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListResolverEndpointsResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(ListResolverEndpointsError::from_response(response))
}
}
async fn list_resolver_rule_associations(
&self,
input: ListResolverRuleAssociationsRequest,
) -> Result<ListResolverRuleAssociationsResponse, RusotoError<ListResolverRuleAssociationsError>>
{
let mut request = SignedRequest::new("POST", "route53resolver", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"Route53Resolver.ListResolverRuleAssociations",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListResolverRuleAssociationsResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(ListResolverRuleAssociationsError::from_response(response))
}
}
async fn list_resolver_rules(
&self,
input: ListResolverRulesRequest,
) -> Result<ListResolverRulesResponse, RusotoError<ListResolverRulesError>> {
let mut request = SignedRequest::new("POST", "route53resolver", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "Route53Resolver.ListResolverRules");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListResolverRulesResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(ListResolverRulesError::from_response(response))
}
}
async fn list_tags_for_resource(
&self,
input: ListTagsForResourceRequest,
) -> Result<ListTagsForResourceResponse, RusotoError<ListTagsForResourceError>> {
let mut request = SignedRequest::new("POST", "route53resolver", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "Route53Resolver.ListTagsForResource");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListTagsForResourceResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(ListTagsForResourceError::from_response(response))
}
}
async fn put_resolver_rule_policy(
&self,
input: PutResolverRulePolicyRequest,
) -> Result<PutResolverRulePolicyResponse, RusotoError<PutResolverRulePolicyError>> {
let mut request = SignedRequest::new("POST", "route53resolver", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "Route53Resolver.PutResolverRulePolicy");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<PutResolverRulePolicyResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(PutResolverRulePolicyError::from_response(response))
}
}
async fn tag_resource(
&self,
input: TagResourceRequest,
) -> Result<TagResourceResponse, RusotoError<TagResourceError>> {
let mut request = SignedRequest::new("POST", "route53resolver", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "Route53Resolver.TagResource");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<TagResourceResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(TagResourceError::from_response(response))
}
}
async fn untag_resource(
&self,
input: UntagResourceRequest,
) -> Result<UntagResourceResponse, RusotoError<UntagResourceError>> {
let mut request = SignedRequest::new("POST", "route53resolver", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "Route53Resolver.UntagResource");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<UntagResourceResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(UntagResourceError::from_response(response))
}
}
async fn update_resolver_endpoint(
&self,
input: UpdateResolverEndpointRequest,
) -> Result<UpdateResolverEndpointResponse, RusotoError<UpdateResolverEndpointError>> {
let mut request = SignedRequest::new("POST", "route53resolver", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "Route53Resolver.UpdateResolverEndpoint");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateResolverEndpointResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(UpdateResolverEndpointError::from_response(response))
}
}
async fn update_resolver_rule(
&self,
input: UpdateResolverRuleRequest,
) -> Result<UpdateResolverRuleResponse, RusotoError<UpdateResolverRuleError>> {
let mut request = SignedRequest::new("POST", "route53resolver", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "Route53Resolver.UpdateResolverRule");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateResolverRuleResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(UpdateResolverRuleError::from_response(response))
}
}
}