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 DirectConnectClient {
fn new_signed_request(&self, http_method: &str, request_uri: &str) -> SignedRequest {
let mut request =
SignedRequest::new(http_method, "directconnect", &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 AcceptDirectConnectGatewayAssociationProposalRequest {
#[serde(rename = "associatedGatewayOwnerAccount")]
pub associated_gateway_owner_account: String,
#[serde(rename = "directConnectGatewayId")]
pub direct_connect_gateway_id: String,
#[serde(rename = "overrideAllowedPrefixesToDirectConnectGateway")]
#[serde(skip_serializing_if = "Option::is_none")]
pub override_allowed_prefixes_to_direct_connect_gateway: Option<Vec<RouteFilterPrefix>>,
#[serde(rename = "proposalId")]
pub proposal_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AcceptDirectConnectGatewayAssociationProposalResult {
#[serde(rename = "directConnectGatewayAssociation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub direct_connect_gateway_association: Option<DirectConnectGatewayAssociation>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AllocateConnectionOnInterconnectRequest {
#[serde(rename = "bandwidth")]
pub bandwidth: String,
#[serde(rename = "connectionName")]
pub connection_name: String,
#[serde(rename = "interconnectId")]
pub interconnect_id: String,
#[serde(rename = "ownerAccount")]
pub owner_account: String,
#[serde(rename = "vlan")]
pub vlan: i64,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AllocateHostedConnectionRequest {
#[serde(rename = "bandwidth")]
pub bandwidth: String,
#[serde(rename = "connectionId")]
pub connection_id: String,
#[serde(rename = "connectionName")]
pub connection_name: String,
#[serde(rename = "ownerAccount")]
pub owner_account: String,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
#[serde(rename = "vlan")]
pub vlan: i64,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AllocatePrivateVirtualInterfaceRequest {
#[serde(rename = "connectionId")]
pub connection_id: String,
#[serde(rename = "newPrivateVirtualInterfaceAllocation")]
pub new_private_virtual_interface_allocation: NewPrivateVirtualInterfaceAllocation,
#[serde(rename = "ownerAccount")]
pub owner_account: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AllocatePublicVirtualInterfaceRequest {
#[serde(rename = "connectionId")]
pub connection_id: String,
#[serde(rename = "newPublicVirtualInterfaceAllocation")]
pub new_public_virtual_interface_allocation: NewPublicVirtualInterfaceAllocation,
#[serde(rename = "ownerAccount")]
pub owner_account: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AllocateTransitVirtualInterfaceRequest {
#[serde(rename = "connectionId")]
pub connection_id: String,
#[serde(rename = "newTransitVirtualInterfaceAllocation")]
pub new_transit_virtual_interface_allocation: NewTransitVirtualInterfaceAllocation,
#[serde(rename = "ownerAccount")]
pub owner_account: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AllocateTransitVirtualInterfaceResult {
#[serde(rename = "virtualInterface")]
#[serde(skip_serializing_if = "Option::is_none")]
pub virtual_interface: Option<VirtualInterface>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AssociateConnectionWithLagRequest {
#[serde(rename = "connectionId")]
pub connection_id: String,
#[serde(rename = "lagId")]
pub lag_id: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AssociateHostedConnectionRequest {
#[serde(rename = "connectionId")]
pub connection_id: String,
#[serde(rename = "parentConnectionId")]
pub parent_connection_id: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AssociateVirtualInterfaceRequest {
#[serde(rename = "connectionId")]
pub connection_id: String,
#[serde(rename = "virtualInterfaceId")]
pub virtual_interface_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AssociatedGateway {
#[serde(rename = "id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "ownerAccount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub owner_account: Option<String>,
#[serde(rename = "region")]
#[serde(skip_serializing_if = "Option::is_none")]
pub region: Option<String>,
#[serde(rename = "type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BGPPeer {
#[serde(rename = "addressFamily")]
#[serde(skip_serializing_if = "Option::is_none")]
pub address_family: Option<String>,
#[serde(rename = "amazonAddress")]
#[serde(skip_serializing_if = "Option::is_none")]
pub amazon_address: Option<String>,
#[serde(rename = "asn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub asn: Option<i64>,
#[serde(rename = "authKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auth_key: Option<String>,
#[serde(rename = "awsDeviceV2")]
#[serde(skip_serializing_if = "Option::is_none")]
pub aws_device_v2: Option<String>,
#[serde(rename = "bgpPeerId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bgp_peer_id: Option<String>,
#[serde(rename = "bgpPeerState")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bgp_peer_state: Option<String>,
#[serde(rename = "bgpStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bgp_status: Option<String>,
#[serde(rename = "customerAddress")]
#[serde(skip_serializing_if = "Option::is_none")]
pub customer_address: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ConfirmConnectionRequest {
#[serde(rename = "connectionId")]
pub connection_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ConfirmConnectionResponse {
#[serde(rename = "connectionState")]
#[serde(skip_serializing_if = "Option::is_none")]
pub connection_state: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ConfirmPrivateVirtualInterfaceRequest {
#[serde(rename = "directConnectGatewayId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub direct_connect_gateway_id: Option<String>,
#[serde(rename = "virtualGatewayId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub virtual_gateway_id: Option<String>,
#[serde(rename = "virtualInterfaceId")]
pub virtual_interface_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ConfirmPrivateVirtualInterfaceResponse {
#[serde(rename = "virtualInterfaceState")]
#[serde(skip_serializing_if = "Option::is_none")]
pub virtual_interface_state: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ConfirmPublicVirtualInterfaceRequest {
#[serde(rename = "virtualInterfaceId")]
pub virtual_interface_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ConfirmPublicVirtualInterfaceResponse {
#[serde(rename = "virtualInterfaceState")]
#[serde(skip_serializing_if = "Option::is_none")]
pub virtual_interface_state: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ConfirmTransitVirtualInterfaceRequest {
#[serde(rename = "directConnectGatewayId")]
pub direct_connect_gateway_id: String,
#[serde(rename = "virtualInterfaceId")]
pub virtual_interface_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ConfirmTransitVirtualInterfaceResponse {
#[serde(rename = "virtualInterfaceState")]
#[serde(skip_serializing_if = "Option::is_none")]
pub virtual_interface_state: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Connection {
#[serde(rename = "awsDevice")]
#[serde(skip_serializing_if = "Option::is_none")]
pub aws_device: Option<String>,
#[serde(rename = "awsDeviceV2")]
#[serde(skip_serializing_if = "Option::is_none")]
pub aws_device_v2: Option<String>,
#[serde(rename = "bandwidth")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bandwidth: Option<String>,
#[serde(rename = "connectionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub connection_id: Option<String>,
#[serde(rename = "connectionName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub connection_name: Option<String>,
#[serde(rename = "connectionState")]
#[serde(skip_serializing_if = "Option::is_none")]
pub connection_state: Option<String>,
#[serde(rename = "hasLogicalRedundancy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub has_logical_redundancy: Option<String>,
#[serde(rename = "jumboFrameCapable")]
#[serde(skip_serializing_if = "Option::is_none")]
pub jumbo_frame_capable: Option<bool>,
#[serde(rename = "lagId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub lag_id: Option<String>,
#[serde(rename = "loaIssueTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub loa_issue_time: Option<f64>,
#[serde(rename = "location")]
#[serde(skip_serializing_if = "Option::is_none")]
pub location: Option<String>,
#[serde(rename = "ownerAccount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub owner_account: Option<String>,
#[serde(rename = "partnerName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub partner_name: Option<String>,
#[serde(rename = "providerName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub provider_name: Option<String>,
#[serde(rename = "region")]
#[serde(skip_serializing_if = "Option::is_none")]
pub region: Option<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
#[serde(rename = "vlan")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vlan: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Connections {
#[serde(rename = "connections")]
#[serde(skip_serializing_if = "Option::is_none")]
pub connections: Option<Vec<Connection>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateBGPPeerRequest {
#[serde(rename = "newBGPPeer")]
#[serde(skip_serializing_if = "Option::is_none")]
pub new_bgp_peer: Option<NewBGPPeer>,
#[serde(rename = "virtualInterfaceId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub virtual_interface_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateBGPPeerResponse {
#[serde(rename = "virtualInterface")]
#[serde(skip_serializing_if = "Option::is_none")]
pub virtual_interface: Option<VirtualInterface>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateConnectionRequest {
#[serde(rename = "bandwidth")]
pub bandwidth: String,
#[serde(rename = "connectionName")]
pub connection_name: String,
#[serde(rename = "lagId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub lag_id: Option<String>,
#[serde(rename = "location")]
pub location: String,
#[serde(rename = "providerName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub provider_name: Option<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateDirectConnectGatewayAssociationProposalRequest {
#[serde(rename = "addAllowedPrefixesToDirectConnectGateway")]
#[serde(skip_serializing_if = "Option::is_none")]
pub add_allowed_prefixes_to_direct_connect_gateway: Option<Vec<RouteFilterPrefix>>,
#[serde(rename = "directConnectGatewayId")]
pub direct_connect_gateway_id: String,
#[serde(rename = "directConnectGatewayOwnerAccount")]
pub direct_connect_gateway_owner_account: String,
#[serde(rename = "gatewayId")]
pub gateway_id: String,
#[serde(rename = "removeAllowedPrefixesToDirectConnectGateway")]
#[serde(skip_serializing_if = "Option::is_none")]
pub remove_allowed_prefixes_to_direct_connect_gateway: Option<Vec<RouteFilterPrefix>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateDirectConnectGatewayAssociationProposalResult {
#[serde(rename = "directConnectGatewayAssociationProposal")]
#[serde(skip_serializing_if = "Option::is_none")]
pub direct_connect_gateway_association_proposal:
Option<DirectConnectGatewayAssociationProposal>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateDirectConnectGatewayAssociationRequest {
#[serde(rename = "addAllowedPrefixesToDirectConnectGateway")]
#[serde(skip_serializing_if = "Option::is_none")]
pub add_allowed_prefixes_to_direct_connect_gateway: Option<Vec<RouteFilterPrefix>>,
#[serde(rename = "directConnectGatewayId")]
pub direct_connect_gateway_id: String,
#[serde(rename = "gatewayId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub gateway_id: Option<String>,
#[serde(rename = "virtualGatewayId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub virtual_gateway_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateDirectConnectGatewayAssociationResult {
#[serde(rename = "directConnectGatewayAssociation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub direct_connect_gateway_association: Option<DirectConnectGatewayAssociation>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateDirectConnectGatewayRequest {
#[serde(rename = "amazonSideAsn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub amazon_side_asn: Option<i64>,
#[serde(rename = "directConnectGatewayName")]
pub direct_connect_gateway_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateDirectConnectGatewayResult {
#[serde(rename = "directConnectGateway")]
#[serde(skip_serializing_if = "Option::is_none")]
pub direct_connect_gateway: Option<DirectConnectGateway>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateInterconnectRequest {
#[serde(rename = "bandwidth")]
pub bandwidth: String,
#[serde(rename = "interconnectName")]
pub interconnect_name: String,
#[serde(rename = "lagId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub lag_id: Option<String>,
#[serde(rename = "location")]
pub location: String,
#[serde(rename = "providerName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub provider_name: Option<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateLagRequest {
#[serde(rename = "childConnectionTags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub child_connection_tags: Option<Vec<Tag>>,
#[serde(rename = "connectionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub connection_id: Option<String>,
#[serde(rename = "connectionsBandwidth")]
pub connections_bandwidth: String,
#[serde(rename = "lagName")]
pub lag_name: String,
#[serde(rename = "location")]
pub location: String,
#[serde(rename = "numberOfConnections")]
pub number_of_connections: i64,
#[serde(rename = "providerName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub provider_name: Option<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreatePrivateVirtualInterfaceRequest {
#[serde(rename = "connectionId")]
pub connection_id: String,
#[serde(rename = "newPrivateVirtualInterface")]
pub new_private_virtual_interface: NewPrivateVirtualInterface,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreatePublicVirtualInterfaceRequest {
#[serde(rename = "connectionId")]
pub connection_id: String,
#[serde(rename = "newPublicVirtualInterface")]
pub new_public_virtual_interface: NewPublicVirtualInterface,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateTransitVirtualInterfaceRequest {
#[serde(rename = "connectionId")]
pub connection_id: String,
#[serde(rename = "newTransitVirtualInterface")]
pub new_transit_virtual_interface: NewTransitVirtualInterface,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateTransitVirtualInterfaceResult {
#[serde(rename = "virtualInterface")]
#[serde(skip_serializing_if = "Option::is_none")]
pub virtual_interface: Option<VirtualInterface>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteBGPPeerRequest {
#[serde(rename = "asn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub asn: Option<i64>,
#[serde(rename = "bgpPeerId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bgp_peer_id: Option<String>,
#[serde(rename = "customerAddress")]
#[serde(skip_serializing_if = "Option::is_none")]
pub customer_address: Option<String>,
#[serde(rename = "virtualInterfaceId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub virtual_interface_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteBGPPeerResponse {
#[serde(rename = "virtualInterface")]
#[serde(skip_serializing_if = "Option::is_none")]
pub virtual_interface: Option<VirtualInterface>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteConnectionRequest {
#[serde(rename = "connectionId")]
pub connection_id: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteDirectConnectGatewayAssociationProposalRequest {
#[serde(rename = "proposalId")]
pub proposal_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteDirectConnectGatewayAssociationProposalResult {
#[serde(rename = "directConnectGatewayAssociationProposal")]
#[serde(skip_serializing_if = "Option::is_none")]
pub direct_connect_gateway_association_proposal:
Option<DirectConnectGatewayAssociationProposal>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteDirectConnectGatewayAssociationRequest {
#[serde(rename = "associationId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub association_id: Option<String>,
#[serde(rename = "directConnectGatewayId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub direct_connect_gateway_id: Option<String>,
#[serde(rename = "virtualGatewayId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub virtual_gateway_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteDirectConnectGatewayAssociationResult {
#[serde(rename = "directConnectGatewayAssociation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub direct_connect_gateway_association: Option<DirectConnectGatewayAssociation>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteDirectConnectGatewayRequest {
#[serde(rename = "directConnectGatewayId")]
pub direct_connect_gateway_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteDirectConnectGatewayResult {
#[serde(rename = "directConnectGateway")]
#[serde(skip_serializing_if = "Option::is_none")]
pub direct_connect_gateway: Option<DirectConnectGateway>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteInterconnectRequest {
#[serde(rename = "interconnectId")]
pub interconnect_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteInterconnectResponse {
#[serde(rename = "interconnectState")]
#[serde(skip_serializing_if = "Option::is_none")]
pub interconnect_state: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteLagRequest {
#[serde(rename = "lagId")]
pub lag_id: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteVirtualInterfaceRequest {
#[serde(rename = "virtualInterfaceId")]
pub virtual_interface_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteVirtualInterfaceResponse {
#[serde(rename = "virtualInterfaceState")]
#[serde(skip_serializing_if = "Option::is_none")]
pub virtual_interface_state: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeConnectionLoaRequest {
#[serde(rename = "connectionId")]
pub connection_id: String,
#[serde(rename = "loaContentType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub loa_content_type: Option<String>,
#[serde(rename = "providerName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub provider_name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeConnectionLoaResponse {
#[serde(rename = "loa")]
#[serde(skip_serializing_if = "Option::is_none")]
pub loa: Option<Loa>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeConnectionsOnInterconnectRequest {
#[serde(rename = "interconnectId")]
pub interconnect_id: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeConnectionsRequest {
#[serde(rename = "connectionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub connection_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeDirectConnectGatewayAssociationProposalsRequest {
#[serde(rename = "associatedGatewayId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub associated_gateway_id: Option<String>,
#[serde(rename = "directConnectGatewayId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub direct_connect_gateway_id: 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 = "proposalId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub proposal_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeDirectConnectGatewayAssociationProposalsResult {
#[serde(rename = "directConnectGatewayAssociationProposals")]
#[serde(skip_serializing_if = "Option::is_none")]
pub direct_connect_gateway_association_proposals:
Option<Vec<DirectConnectGatewayAssociationProposal>>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeDirectConnectGatewayAssociationsRequest {
#[serde(rename = "associatedGatewayId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub associated_gateway_id: Option<String>,
#[serde(rename = "associationId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub association_id: Option<String>,
#[serde(rename = "directConnectGatewayId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub direct_connect_gateway_id: 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 = "virtualGatewayId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub virtual_gateway_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeDirectConnectGatewayAssociationsResult {
#[serde(rename = "directConnectGatewayAssociations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub direct_connect_gateway_associations: Option<Vec<DirectConnectGatewayAssociation>>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeDirectConnectGatewayAttachmentsRequest {
#[serde(rename = "directConnectGatewayId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub direct_connect_gateway_id: 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 = "virtualInterfaceId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub virtual_interface_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeDirectConnectGatewayAttachmentsResult {
#[serde(rename = "directConnectGatewayAttachments")]
#[serde(skip_serializing_if = "Option::is_none")]
pub direct_connect_gateway_attachments: Option<Vec<DirectConnectGatewayAttachment>>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeDirectConnectGatewaysRequest {
#[serde(rename = "directConnectGatewayId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub direct_connect_gateway_id: 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>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeDirectConnectGatewaysResult {
#[serde(rename = "directConnectGateways")]
#[serde(skip_serializing_if = "Option::is_none")]
pub direct_connect_gateways: Option<Vec<DirectConnectGateway>>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeHostedConnectionsRequest {
#[serde(rename = "connectionId")]
pub connection_id: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeInterconnectLoaRequest {
#[serde(rename = "interconnectId")]
pub interconnect_id: String,
#[serde(rename = "loaContentType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub loa_content_type: Option<String>,
#[serde(rename = "providerName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub provider_name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeInterconnectLoaResponse {
#[serde(rename = "loa")]
#[serde(skip_serializing_if = "Option::is_none")]
pub loa: Option<Loa>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeInterconnectsRequest {
#[serde(rename = "interconnectId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub interconnect_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeLagsRequest {
#[serde(rename = "lagId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub lag_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeLoaRequest {
#[serde(rename = "connectionId")]
pub connection_id: String,
#[serde(rename = "loaContentType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub loa_content_type: Option<String>,
#[serde(rename = "providerName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub provider_name: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeTagsRequest {
#[serde(rename = "resourceArns")]
pub resource_arns: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeTagsResponse {
#[serde(rename = "resourceTags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_tags: Option<Vec<ResourceTag>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeVirtualInterfacesRequest {
#[serde(rename = "connectionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub connection_id: Option<String>,
#[serde(rename = "virtualInterfaceId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub virtual_interface_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DirectConnectGateway {
#[serde(rename = "amazonSideAsn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub amazon_side_asn: Option<i64>,
#[serde(rename = "directConnectGatewayId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub direct_connect_gateway_id: Option<String>,
#[serde(rename = "directConnectGatewayName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub direct_connect_gateway_name: Option<String>,
#[serde(rename = "directConnectGatewayState")]
#[serde(skip_serializing_if = "Option::is_none")]
pub direct_connect_gateway_state: Option<String>,
#[serde(rename = "ownerAccount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub owner_account: Option<String>,
#[serde(rename = "stateChangeError")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state_change_error: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DirectConnectGatewayAssociation {
#[serde(rename = "allowedPrefixesToDirectConnectGateway")]
#[serde(skip_serializing_if = "Option::is_none")]
pub allowed_prefixes_to_direct_connect_gateway: Option<Vec<RouteFilterPrefix>>,
#[serde(rename = "associatedGateway")]
#[serde(skip_serializing_if = "Option::is_none")]
pub associated_gateway: Option<AssociatedGateway>,
#[serde(rename = "associationId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub association_id: Option<String>,
#[serde(rename = "associationState")]
#[serde(skip_serializing_if = "Option::is_none")]
pub association_state: Option<String>,
#[serde(rename = "directConnectGatewayId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub direct_connect_gateway_id: Option<String>,
#[serde(rename = "directConnectGatewayOwnerAccount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub direct_connect_gateway_owner_account: Option<String>,
#[serde(rename = "stateChangeError")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state_change_error: Option<String>,
#[serde(rename = "virtualGatewayId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub virtual_gateway_id: Option<String>,
#[serde(rename = "virtualGatewayOwnerAccount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub virtual_gateway_owner_account: Option<String>,
#[serde(rename = "virtualGatewayRegion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub virtual_gateway_region: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DirectConnectGatewayAssociationProposal {
#[serde(rename = "associatedGateway")]
#[serde(skip_serializing_if = "Option::is_none")]
pub associated_gateway: Option<AssociatedGateway>,
#[serde(rename = "directConnectGatewayId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub direct_connect_gateway_id: Option<String>,
#[serde(rename = "directConnectGatewayOwnerAccount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub direct_connect_gateway_owner_account: Option<String>,
#[serde(rename = "existingAllowedPrefixesToDirectConnectGateway")]
#[serde(skip_serializing_if = "Option::is_none")]
pub existing_allowed_prefixes_to_direct_connect_gateway: Option<Vec<RouteFilterPrefix>>,
#[serde(rename = "proposalId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub proposal_id: Option<String>,
#[serde(rename = "proposalState")]
#[serde(skip_serializing_if = "Option::is_none")]
pub proposal_state: Option<String>,
#[serde(rename = "requestedAllowedPrefixesToDirectConnectGateway")]
#[serde(skip_serializing_if = "Option::is_none")]
pub requested_allowed_prefixes_to_direct_connect_gateway: Option<Vec<RouteFilterPrefix>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DirectConnectGatewayAttachment {
#[serde(rename = "attachmentState")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attachment_state: Option<String>,
#[serde(rename = "attachmentType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attachment_type: Option<String>,
#[serde(rename = "directConnectGatewayId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub direct_connect_gateway_id: Option<String>,
#[serde(rename = "stateChangeError")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state_change_error: Option<String>,
#[serde(rename = "virtualInterfaceId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub virtual_interface_id: Option<String>,
#[serde(rename = "virtualInterfaceOwnerAccount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub virtual_interface_owner_account: Option<String>,
#[serde(rename = "virtualInterfaceRegion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub virtual_interface_region: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DisassociateConnectionFromLagRequest {
#[serde(rename = "connectionId")]
pub connection_id: String,
#[serde(rename = "lagId")]
pub lag_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Interconnect {
#[serde(rename = "awsDevice")]
#[serde(skip_serializing_if = "Option::is_none")]
pub aws_device: Option<String>,
#[serde(rename = "awsDeviceV2")]
#[serde(skip_serializing_if = "Option::is_none")]
pub aws_device_v2: Option<String>,
#[serde(rename = "bandwidth")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bandwidth: Option<String>,
#[serde(rename = "hasLogicalRedundancy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub has_logical_redundancy: Option<String>,
#[serde(rename = "interconnectId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub interconnect_id: Option<String>,
#[serde(rename = "interconnectName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub interconnect_name: Option<String>,
#[serde(rename = "interconnectState")]
#[serde(skip_serializing_if = "Option::is_none")]
pub interconnect_state: Option<String>,
#[serde(rename = "jumboFrameCapable")]
#[serde(skip_serializing_if = "Option::is_none")]
pub jumbo_frame_capable: Option<bool>,
#[serde(rename = "lagId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub lag_id: Option<String>,
#[serde(rename = "loaIssueTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub loa_issue_time: Option<f64>,
#[serde(rename = "location")]
#[serde(skip_serializing_if = "Option::is_none")]
pub location: Option<String>,
#[serde(rename = "providerName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub provider_name: Option<String>,
#[serde(rename = "region")]
#[serde(skip_serializing_if = "Option::is_none")]
pub region: Option<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Interconnects {
#[serde(rename = "interconnects")]
#[serde(skip_serializing_if = "Option::is_none")]
pub interconnects: Option<Vec<Interconnect>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Lag {
#[serde(rename = "allowsHostedConnections")]
#[serde(skip_serializing_if = "Option::is_none")]
pub allows_hosted_connections: Option<bool>,
#[serde(rename = "awsDevice")]
#[serde(skip_serializing_if = "Option::is_none")]
pub aws_device: Option<String>,
#[serde(rename = "awsDeviceV2")]
#[serde(skip_serializing_if = "Option::is_none")]
pub aws_device_v2: Option<String>,
#[serde(rename = "connections")]
#[serde(skip_serializing_if = "Option::is_none")]
pub connections: Option<Vec<Connection>>,
#[serde(rename = "connectionsBandwidth")]
#[serde(skip_serializing_if = "Option::is_none")]
pub connections_bandwidth: Option<String>,
#[serde(rename = "hasLogicalRedundancy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub has_logical_redundancy: Option<String>,
#[serde(rename = "jumboFrameCapable")]
#[serde(skip_serializing_if = "Option::is_none")]
pub jumbo_frame_capable: Option<bool>,
#[serde(rename = "lagId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub lag_id: Option<String>,
#[serde(rename = "lagName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub lag_name: Option<String>,
#[serde(rename = "lagState")]
#[serde(skip_serializing_if = "Option::is_none")]
pub lag_state: Option<String>,
#[serde(rename = "location")]
#[serde(skip_serializing_if = "Option::is_none")]
pub location: Option<String>,
#[serde(rename = "minimumLinks")]
#[serde(skip_serializing_if = "Option::is_none")]
pub minimum_links: Option<i64>,
#[serde(rename = "numberOfConnections")]
#[serde(skip_serializing_if = "Option::is_none")]
pub number_of_connections: Option<i64>,
#[serde(rename = "ownerAccount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub owner_account: Option<String>,
#[serde(rename = "providerName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub provider_name: Option<String>,
#[serde(rename = "region")]
#[serde(skip_serializing_if = "Option::is_none")]
pub region: Option<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Lags {
#[serde(rename = "lags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub lags: Option<Vec<Lag>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListVirtualInterfaceTestHistoryRequest {
#[serde(rename = "bgpPeers")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bgp_peers: Option<Vec<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 = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "testId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub test_id: Option<String>,
#[serde(rename = "virtualInterfaceId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub virtual_interface_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListVirtualInterfaceTestHistoryResponse {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "virtualInterfaceTestHistory")]
#[serde(skip_serializing_if = "Option::is_none")]
pub virtual_interface_test_history: Option<Vec<VirtualInterfaceTestHistory>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Loa {
#[serde(rename = "loaContent")]
#[serde(
deserialize_with = "::rusoto_core::serialization::SerdeBlob::deserialize_blob",
serialize_with = "::rusoto_core::serialization::SerdeBlob::serialize_blob",
default
)]
#[serde(skip_serializing_if = "Option::is_none")]
pub loa_content: Option<bytes::Bytes>,
#[serde(rename = "loaContentType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub loa_content_type: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Location {
#[serde(rename = "availablePortSpeeds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub available_port_speeds: Option<Vec<String>>,
#[serde(rename = "availableProviders")]
#[serde(skip_serializing_if = "Option::is_none")]
pub available_providers: Option<Vec<String>>,
#[serde(rename = "locationCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub location_code: Option<String>,
#[serde(rename = "locationName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub location_name: Option<String>,
#[serde(rename = "region")]
#[serde(skip_serializing_if = "Option::is_none")]
pub region: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Locations {
#[serde(rename = "locations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub locations: Option<Vec<Location>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct NewBGPPeer {
#[serde(rename = "addressFamily")]
#[serde(skip_serializing_if = "Option::is_none")]
pub address_family: Option<String>,
#[serde(rename = "amazonAddress")]
#[serde(skip_serializing_if = "Option::is_none")]
pub amazon_address: Option<String>,
#[serde(rename = "asn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub asn: Option<i64>,
#[serde(rename = "authKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auth_key: Option<String>,
#[serde(rename = "customerAddress")]
#[serde(skip_serializing_if = "Option::is_none")]
pub customer_address: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct NewPrivateVirtualInterface {
#[serde(rename = "addressFamily")]
#[serde(skip_serializing_if = "Option::is_none")]
pub address_family: Option<String>,
#[serde(rename = "amazonAddress")]
#[serde(skip_serializing_if = "Option::is_none")]
pub amazon_address: Option<String>,
#[serde(rename = "asn")]
pub asn: i64,
#[serde(rename = "authKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auth_key: Option<String>,
#[serde(rename = "customerAddress")]
#[serde(skip_serializing_if = "Option::is_none")]
pub customer_address: Option<String>,
#[serde(rename = "directConnectGatewayId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub direct_connect_gateway_id: Option<String>,
#[serde(rename = "mtu")]
#[serde(skip_serializing_if = "Option::is_none")]
pub mtu: Option<i64>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
#[serde(rename = "virtualGatewayId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub virtual_gateway_id: Option<String>,
#[serde(rename = "virtualInterfaceName")]
pub virtual_interface_name: String,
#[serde(rename = "vlan")]
pub vlan: i64,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct NewPrivateVirtualInterfaceAllocation {
#[serde(rename = "addressFamily")]
#[serde(skip_serializing_if = "Option::is_none")]
pub address_family: Option<String>,
#[serde(rename = "amazonAddress")]
#[serde(skip_serializing_if = "Option::is_none")]
pub amazon_address: Option<String>,
#[serde(rename = "asn")]
pub asn: i64,
#[serde(rename = "authKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auth_key: Option<String>,
#[serde(rename = "customerAddress")]
#[serde(skip_serializing_if = "Option::is_none")]
pub customer_address: Option<String>,
#[serde(rename = "mtu")]
#[serde(skip_serializing_if = "Option::is_none")]
pub mtu: Option<i64>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
#[serde(rename = "virtualInterfaceName")]
pub virtual_interface_name: String,
#[serde(rename = "vlan")]
pub vlan: i64,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct NewPublicVirtualInterface {
#[serde(rename = "addressFamily")]
#[serde(skip_serializing_if = "Option::is_none")]
pub address_family: Option<String>,
#[serde(rename = "amazonAddress")]
#[serde(skip_serializing_if = "Option::is_none")]
pub amazon_address: Option<String>,
#[serde(rename = "asn")]
pub asn: i64,
#[serde(rename = "authKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auth_key: Option<String>,
#[serde(rename = "customerAddress")]
#[serde(skip_serializing_if = "Option::is_none")]
pub customer_address: Option<String>,
#[serde(rename = "routeFilterPrefixes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub route_filter_prefixes: Option<Vec<RouteFilterPrefix>>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
#[serde(rename = "virtualInterfaceName")]
pub virtual_interface_name: String,
#[serde(rename = "vlan")]
pub vlan: i64,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct NewPublicVirtualInterfaceAllocation {
#[serde(rename = "addressFamily")]
#[serde(skip_serializing_if = "Option::is_none")]
pub address_family: Option<String>,
#[serde(rename = "amazonAddress")]
#[serde(skip_serializing_if = "Option::is_none")]
pub amazon_address: Option<String>,
#[serde(rename = "asn")]
pub asn: i64,
#[serde(rename = "authKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auth_key: Option<String>,
#[serde(rename = "customerAddress")]
#[serde(skip_serializing_if = "Option::is_none")]
pub customer_address: Option<String>,
#[serde(rename = "routeFilterPrefixes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub route_filter_prefixes: Option<Vec<RouteFilterPrefix>>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
#[serde(rename = "virtualInterfaceName")]
pub virtual_interface_name: String,
#[serde(rename = "vlan")]
pub vlan: i64,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct NewTransitVirtualInterface {
#[serde(rename = "addressFamily")]
#[serde(skip_serializing_if = "Option::is_none")]
pub address_family: Option<String>,
#[serde(rename = "amazonAddress")]
#[serde(skip_serializing_if = "Option::is_none")]
pub amazon_address: Option<String>,
#[serde(rename = "asn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub asn: Option<i64>,
#[serde(rename = "authKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auth_key: Option<String>,
#[serde(rename = "customerAddress")]
#[serde(skip_serializing_if = "Option::is_none")]
pub customer_address: Option<String>,
#[serde(rename = "directConnectGatewayId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub direct_connect_gateway_id: Option<String>,
#[serde(rename = "mtu")]
#[serde(skip_serializing_if = "Option::is_none")]
pub mtu: Option<i64>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
#[serde(rename = "virtualInterfaceName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub virtual_interface_name: Option<String>,
#[serde(rename = "vlan")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vlan: Option<i64>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct NewTransitVirtualInterfaceAllocation {
#[serde(rename = "addressFamily")]
#[serde(skip_serializing_if = "Option::is_none")]
pub address_family: Option<String>,
#[serde(rename = "amazonAddress")]
#[serde(skip_serializing_if = "Option::is_none")]
pub amazon_address: Option<String>,
#[serde(rename = "asn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub asn: Option<i64>,
#[serde(rename = "authKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auth_key: Option<String>,
#[serde(rename = "customerAddress")]
#[serde(skip_serializing_if = "Option::is_none")]
pub customer_address: Option<String>,
#[serde(rename = "mtu")]
#[serde(skip_serializing_if = "Option::is_none")]
pub mtu: Option<i64>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
#[serde(rename = "virtualInterfaceName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub virtual_interface_name: Option<String>,
#[serde(rename = "vlan")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vlan: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ResourceTag {
#[serde(rename = "resourceArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_arn: Option<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct RouteFilterPrefix {
#[serde(rename = "cidr")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cidr: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StartBgpFailoverTestRequest {
#[serde(rename = "bgpPeers")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bgp_peers: Option<Vec<String>>,
#[serde(rename = "testDurationInMinutes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub test_duration_in_minutes: Option<i64>,
#[serde(rename = "virtualInterfaceId")]
pub virtual_interface_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct StartBgpFailoverTestResponse {
#[serde(rename = "virtualInterfaceTest")]
#[serde(skip_serializing_if = "Option::is_none")]
pub virtual_interface_test: Option<VirtualInterfaceTestHistory>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StopBgpFailoverTestRequest {
#[serde(rename = "virtualInterfaceId")]
pub virtual_interface_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct StopBgpFailoverTestResponse {
#[serde(rename = "virtualInterfaceTest")]
#[serde(skip_serializing_if = "Option::is_none")]
pub virtual_interface_test: Option<VirtualInterfaceTestHistory>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct Tag {
#[serde(rename = "key")]
pub key: String,
#[serde(rename = "value")]
#[serde(skip_serializing_if = "Option::is_none")]
pub value: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct TagResourceRequest {
#[serde(rename = "resourceArn")]
pub resource_arn: String,
#[serde(rename = "tags")]
pub tags: Vec<Tag>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct TagResourceResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UntagResourceRequest {
#[serde(rename = "resourceArn")]
pub resource_arn: String,
#[serde(rename = "tagKeys")]
pub tag_keys: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UntagResourceResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateDirectConnectGatewayAssociationRequest {
#[serde(rename = "addAllowedPrefixesToDirectConnectGateway")]
#[serde(skip_serializing_if = "Option::is_none")]
pub add_allowed_prefixes_to_direct_connect_gateway: Option<Vec<RouteFilterPrefix>>,
#[serde(rename = "associationId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub association_id: Option<String>,
#[serde(rename = "removeAllowedPrefixesToDirectConnectGateway")]
#[serde(skip_serializing_if = "Option::is_none")]
pub remove_allowed_prefixes_to_direct_connect_gateway: Option<Vec<RouteFilterPrefix>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateDirectConnectGatewayAssociationResult {
#[serde(rename = "directConnectGatewayAssociation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub direct_connect_gateway_association: Option<DirectConnectGatewayAssociation>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateLagRequest {
#[serde(rename = "lagId")]
pub lag_id: String,
#[serde(rename = "lagName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub lag_name: Option<String>,
#[serde(rename = "minimumLinks")]
#[serde(skip_serializing_if = "Option::is_none")]
pub minimum_links: Option<i64>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateVirtualInterfaceAttributesRequest {
#[serde(rename = "mtu")]
#[serde(skip_serializing_if = "Option::is_none")]
pub mtu: Option<i64>,
#[serde(rename = "virtualInterfaceId")]
pub virtual_interface_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct VirtualGateway {
#[serde(rename = "virtualGatewayId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub virtual_gateway_id: Option<String>,
#[serde(rename = "virtualGatewayState")]
#[serde(skip_serializing_if = "Option::is_none")]
pub virtual_gateway_state: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct VirtualGateways {
#[serde(rename = "virtualGateways")]
#[serde(skip_serializing_if = "Option::is_none")]
pub virtual_gateways: Option<Vec<VirtualGateway>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct VirtualInterface {
#[serde(rename = "addressFamily")]
#[serde(skip_serializing_if = "Option::is_none")]
pub address_family: Option<String>,
#[serde(rename = "amazonAddress")]
#[serde(skip_serializing_if = "Option::is_none")]
pub amazon_address: Option<String>,
#[serde(rename = "amazonSideAsn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub amazon_side_asn: Option<i64>,
#[serde(rename = "asn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub asn: Option<i64>,
#[serde(rename = "authKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auth_key: Option<String>,
#[serde(rename = "awsDeviceV2")]
#[serde(skip_serializing_if = "Option::is_none")]
pub aws_device_v2: Option<String>,
#[serde(rename = "bgpPeers")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bgp_peers: Option<Vec<BGPPeer>>,
#[serde(rename = "connectionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub connection_id: Option<String>,
#[serde(rename = "customerAddress")]
#[serde(skip_serializing_if = "Option::is_none")]
pub customer_address: Option<String>,
#[serde(rename = "customerRouterConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub customer_router_config: Option<String>,
#[serde(rename = "directConnectGatewayId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub direct_connect_gateway_id: Option<String>,
#[serde(rename = "jumboFrameCapable")]
#[serde(skip_serializing_if = "Option::is_none")]
pub jumbo_frame_capable: Option<bool>,
#[serde(rename = "location")]
#[serde(skip_serializing_if = "Option::is_none")]
pub location: Option<String>,
#[serde(rename = "mtu")]
#[serde(skip_serializing_if = "Option::is_none")]
pub mtu: Option<i64>,
#[serde(rename = "ownerAccount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub owner_account: Option<String>,
#[serde(rename = "region")]
#[serde(skip_serializing_if = "Option::is_none")]
pub region: Option<String>,
#[serde(rename = "routeFilterPrefixes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub route_filter_prefixes: Option<Vec<RouteFilterPrefix>>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
#[serde(rename = "virtualGatewayId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub virtual_gateway_id: Option<String>,
#[serde(rename = "virtualInterfaceId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub virtual_interface_id: Option<String>,
#[serde(rename = "virtualInterfaceName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub virtual_interface_name: Option<String>,
#[serde(rename = "virtualInterfaceState")]
#[serde(skip_serializing_if = "Option::is_none")]
pub virtual_interface_state: Option<String>,
#[serde(rename = "virtualInterfaceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub virtual_interface_type: Option<String>,
#[serde(rename = "vlan")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vlan: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct VirtualInterfaceTestHistory {
#[serde(rename = "bgpPeers")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bgp_peers: Option<Vec<String>>,
#[serde(rename = "endTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub end_time: Option<f64>,
#[serde(rename = "ownerAccount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub owner_account: Option<String>,
#[serde(rename = "startTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub start_time: Option<f64>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "testDurationInMinutes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub test_duration_in_minutes: Option<i64>,
#[serde(rename = "testId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub test_id: Option<String>,
#[serde(rename = "virtualInterfaceId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub virtual_interface_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct VirtualInterfaces {
#[serde(rename = "virtualInterfaces")]
#[serde(skip_serializing_if = "Option::is_none")]
pub virtual_interfaces: Option<Vec<VirtualInterface>>,
}
#[derive(Debug, PartialEq)]
pub enum AcceptDirectConnectGatewayAssociationProposalError {
DirectConnectClient(String),
DirectConnectServer(String),
}
impl AcceptDirectConnectGatewayAssociationProposalError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<AcceptDirectConnectGatewayAssociationProposalError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"DirectConnectClientException" => {
return RusotoError::Service(
AcceptDirectConnectGatewayAssociationProposalError::DirectConnectClient(
err.msg,
),
)
}
"DirectConnectServerException" => {
return RusotoError::Service(
AcceptDirectConnectGatewayAssociationProposalError::DirectConnectServer(
err.msg,
),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AcceptDirectConnectGatewayAssociationProposalError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AcceptDirectConnectGatewayAssociationProposalError::DirectConnectClient(ref cause) => {
write!(f, "{}", cause)
}
AcceptDirectConnectGatewayAssociationProposalError::DirectConnectServer(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for AcceptDirectConnectGatewayAssociationProposalError {}
#[derive(Debug, PartialEq)]
pub enum AllocateConnectionOnInterconnectError {
DirectConnectClient(String),
DirectConnectServer(String),
}
impl AllocateConnectionOnInterconnectError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<AllocateConnectionOnInterconnectError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"DirectConnectClientException" => {
return RusotoError::Service(
AllocateConnectionOnInterconnectError::DirectConnectClient(err.msg),
)
}
"DirectConnectServerException" => {
return RusotoError::Service(
AllocateConnectionOnInterconnectError::DirectConnectServer(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AllocateConnectionOnInterconnectError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AllocateConnectionOnInterconnectError::DirectConnectClient(ref cause) => {
write!(f, "{}", cause)
}
AllocateConnectionOnInterconnectError::DirectConnectServer(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for AllocateConnectionOnInterconnectError {}
#[derive(Debug, PartialEq)]
pub enum AllocateHostedConnectionError {
DirectConnectClient(String),
DirectConnectServer(String),
DuplicateTagKeys(String),
TooManyTags(String),
}
impl AllocateHostedConnectionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AllocateHostedConnectionError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"DirectConnectClientException" => {
return RusotoError::Service(
AllocateHostedConnectionError::DirectConnectClient(err.msg),
)
}
"DirectConnectServerException" => {
return RusotoError::Service(
AllocateHostedConnectionError::DirectConnectServer(err.msg),
)
}
"DuplicateTagKeysException" => {
return RusotoError::Service(AllocateHostedConnectionError::DuplicateTagKeys(
err.msg,
))
}
"TooManyTagsException" => {
return RusotoError::Service(AllocateHostedConnectionError::TooManyTags(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AllocateHostedConnectionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AllocateHostedConnectionError::DirectConnectClient(ref cause) => write!(f, "{}", cause),
AllocateHostedConnectionError::DirectConnectServer(ref cause) => write!(f, "{}", cause),
AllocateHostedConnectionError::DuplicateTagKeys(ref cause) => write!(f, "{}", cause),
AllocateHostedConnectionError::TooManyTags(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for AllocateHostedConnectionError {}
#[derive(Debug, PartialEq)]
pub enum AllocatePrivateVirtualInterfaceError {
DirectConnectClient(String),
DirectConnectServer(String),
DuplicateTagKeys(String),
TooManyTags(String),
}
impl AllocatePrivateVirtualInterfaceError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<AllocatePrivateVirtualInterfaceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"DirectConnectClientException" => {
return RusotoError::Service(
AllocatePrivateVirtualInterfaceError::DirectConnectClient(err.msg),
)
}
"DirectConnectServerException" => {
return RusotoError::Service(
AllocatePrivateVirtualInterfaceError::DirectConnectServer(err.msg),
)
}
"DuplicateTagKeysException" => {
return RusotoError::Service(
AllocatePrivateVirtualInterfaceError::DuplicateTagKeys(err.msg),
)
}
"TooManyTagsException" => {
return RusotoError::Service(AllocatePrivateVirtualInterfaceError::TooManyTags(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AllocatePrivateVirtualInterfaceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AllocatePrivateVirtualInterfaceError::DirectConnectClient(ref cause) => {
write!(f, "{}", cause)
}
AllocatePrivateVirtualInterfaceError::DirectConnectServer(ref cause) => {
write!(f, "{}", cause)
}
AllocatePrivateVirtualInterfaceError::DuplicateTagKeys(ref cause) => {
write!(f, "{}", cause)
}
AllocatePrivateVirtualInterfaceError::TooManyTags(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for AllocatePrivateVirtualInterfaceError {}
#[derive(Debug, PartialEq)]
pub enum AllocatePublicVirtualInterfaceError {
DirectConnectClient(String),
DirectConnectServer(String),
DuplicateTagKeys(String),
TooManyTags(String),
}
impl AllocatePublicVirtualInterfaceError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<AllocatePublicVirtualInterfaceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"DirectConnectClientException" => {
return RusotoError::Service(
AllocatePublicVirtualInterfaceError::DirectConnectClient(err.msg),
)
}
"DirectConnectServerException" => {
return RusotoError::Service(
AllocatePublicVirtualInterfaceError::DirectConnectServer(err.msg),
)
}
"DuplicateTagKeysException" => {
return RusotoError::Service(
AllocatePublicVirtualInterfaceError::DuplicateTagKeys(err.msg),
)
}
"TooManyTagsException" => {
return RusotoError::Service(AllocatePublicVirtualInterfaceError::TooManyTags(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AllocatePublicVirtualInterfaceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AllocatePublicVirtualInterfaceError::DirectConnectClient(ref cause) => {
write!(f, "{}", cause)
}
AllocatePublicVirtualInterfaceError::DirectConnectServer(ref cause) => {
write!(f, "{}", cause)
}
AllocatePublicVirtualInterfaceError::DuplicateTagKeys(ref cause) => {
write!(f, "{}", cause)
}
AllocatePublicVirtualInterfaceError::TooManyTags(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for AllocatePublicVirtualInterfaceError {}
#[derive(Debug, PartialEq)]
pub enum AllocateTransitVirtualInterfaceError {
DirectConnectClient(String),
DirectConnectServer(String),
DuplicateTagKeys(String),
TooManyTags(String),
}
impl AllocateTransitVirtualInterfaceError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<AllocateTransitVirtualInterfaceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"DirectConnectClientException" => {
return RusotoError::Service(
AllocateTransitVirtualInterfaceError::DirectConnectClient(err.msg),
)
}
"DirectConnectServerException" => {
return RusotoError::Service(
AllocateTransitVirtualInterfaceError::DirectConnectServer(err.msg),
)
}
"DuplicateTagKeysException" => {
return RusotoError::Service(
AllocateTransitVirtualInterfaceError::DuplicateTagKeys(err.msg),
)
}
"TooManyTagsException" => {
return RusotoError::Service(AllocateTransitVirtualInterfaceError::TooManyTags(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AllocateTransitVirtualInterfaceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AllocateTransitVirtualInterfaceError::DirectConnectClient(ref cause) => {
write!(f, "{}", cause)
}
AllocateTransitVirtualInterfaceError::DirectConnectServer(ref cause) => {
write!(f, "{}", cause)
}
AllocateTransitVirtualInterfaceError::DuplicateTagKeys(ref cause) => {
write!(f, "{}", cause)
}
AllocateTransitVirtualInterfaceError::TooManyTags(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for AllocateTransitVirtualInterfaceError {}
#[derive(Debug, PartialEq)]
pub enum AssociateConnectionWithLagError {
DirectConnectClient(String),
DirectConnectServer(String),
}
impl AssociateConnectionWithLagError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<AssociateConnectionWithLagError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"DirectConnectClientException" => {
return RusotoError::Service(
AssociateConnectionWithLagError::DirectConnectClient(err.msg),
)
}
"DirectConnectServerException" => {
return RusotoError::Service(
AssociateConnectionWithLagError::DirectConnectServer(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AssociateConnectionWithLagError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AssociateConnectionWithLagError::DirectConnectClient(ref cause) => {
write!(f, "{}", cause)
}
AssociateConnectionWithLagError::DirectConnectServer(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for AssociateConnectionWithLagError {}
#[derive(Debug, PartialEq)]
pub enum AssociateHostedConnectionError {
DirectConnectClient(String),
DirectConnectServer(String),
}
impl AssociateHostedConnectionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AssociateHostedConnectionError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"DirectConnectClientException" => {
return RusotoError::Service(
AssociateHostedConnectionError::DirectConnectClient(err.msg),
)
}
"DirectConnectServerException" => {
return RusotoError::Service(
AssociateHostedConnectionError::DirectConnectServer(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AssociateHostedConnectionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AssociateHostedConnectionError::DirectConnectClient(ref cause) => {
write!(f, "{}", cause)
}
AssociateHostedConnectionError::DirectConnectServer(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for AssociateHostedConnectionError {}
#[derive(Debug, PartialEq)]
pub enum AssociateVirtualInterfaceError {
DirectConnectClient(String),
DirectConnectServer(String),
}
impl AssociateVirtualInterfaceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AssociateVirtualInterfaceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"DirectConnectClientException" => {
return RusotoError::Service(
AssociateVirtualInterfaceError::DirectConnectClient(err.msg),
)
}
"DirectConnectServerException" => {
return RusotoError::Service(
AssociateVirtualInterfaceError::DirectConnectServer(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AssociateVirtualInterfaceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AssociateVirtualInterfaceError::DirectConnectClient(ref cause) => {
write!(f, "{}", cause)
}
AssociateVirtualInterfaceError::DirectConnectServer(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for AssociateVirtualInterfaceError {}
#[derive(Debug, PartialEq)]
pub enum ConfirmConnectionError {
DirectConnectClient(String),
DirectConnectServer(String),
}
impl ConfirmConnectionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ConfirmConnectionError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"DirectConnectClientException" => {
return RusotoError::Service(ConfirmConnectionError::DirectConnectClient(
err.msg,
))
}
"DirectConnectServerException" => {
return RusotoError::Service(ConfirmConnectionError::DirectConnectServer(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ConfirmConnectionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ConfirmConnectionError::DirectConnectClient(ref cause) => write!(f, "{}", cause),
ConfirmConnectionError::DirectConnectServer(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ConfirmConnectionError {}
#[derive(Debug, PartialEq)]
pub enum ConfirmPrivateVirtualInterfaceError {
DirectConnectClient(String),
DirectConnectServer(String),
}
impl ConfirmPrivateVirtualInterfaceError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ConfirmPrivateVirtualInterfaceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"DirectConnectClientException" => {
return RusotoError::Service(
ConfirmPrivateVirtualInterfaceError::DirectConnectClient(err.msg),
)
}
"DirectConnectServerException" => {
return RusotoError::Service(
ConfirmPrivateVirtualInterfaceError::DirectConnectServer(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ConfirmPrivateVirtualInterfaceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ConfirmPrivateVirtualInterfaceError::DirectConnectClient(ref cause) => {
write!(f, "{}", cause)
}
ConfirmPrivateVirtualInterfaceError::DirectConnectServer(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ConfirmPrivateVirtualInterfaceError {}
#[derive(Debug, PartialEq)]
pub enum ConfirmPublicVirtualInterfaceError {
DirectConnectClient(String),
DirectConnectServer(String),
}
impl ConfirmPublicVirtualInterfaceError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ConfirmPublicVirtualInterfaceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"DirectConnectClientException" => {
return RusotoError::Service(
ConfirmPublicVirtualInterfaceError::DirectConnectClient(err.msg),
)
}
"DirectConnectServerException" => {
return RusotoError::Service(
ConfirmPublicVirtualInterfaceError::DirectConnectServer(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ConfirmPublicVirtualInterfaceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ConfirmPublicVirtualInterfaceError::DirectConnectClient(ref cause) => {
write!(f, "{}", cause)
}
ConfirmPublicVirtualInterfaceError::DirectConnectServer(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ConfirmPublicVirtualInterfaceError {}
#[derive(Debug, PartialEq)]
pub enum ConfirmTransitVirtualInterfaceError {
DirectConnectClient(String),
DirectConnectServer(String),
}
impl ConfirmTransitVirtualInterfaceError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ConfirmTransitVirtualInterfaceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"DirectConnectClientException" => {
return RusotoError::Service(
ConfirmTransitVirtualInterfaceError::DirectConnectClient(err.msg),
)
}
"DirectConnectServerException" => {
return RusotoError::Service(
ConfirmTransitVirtualInterfaceError::DirectConnectServer(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ConfirmTransitVirtualInterfaceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ConfirmTransitVirtualInterfaceError::DirectConnectClient(ref cause) => {
write!(f, "{}", cause)
}
ConfirmTransitVirtualInterfaceError::DirectConnectServer(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ConfirmTransitVirtualInterfaceError {}
#[derive(Debug, PartialEq)]
pub enum CreateBGPPeerError {
DirectConnectClient(String),
DirectConnectServer(String),
}
impl CreateBGPPeerError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateBGPPeerError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"DirectConnectClientException" => {
return RusotoError::Service(CreateBGPPeerError::DirectConnectClient(err.msg))
}
"DirectConnectServerException" => {
return RusotoError::Service(CreateBGPPeerError::DirectConnectServer(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateBGPPeerError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateBGPPeerError::DirectConnectClient(ref cause) => write!(f, "{}", cause),
CreateBGPPeerError::DirectConnectServer(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateBGPPeerError {}
#[derive(Debug, PartialEq)]
pub enum CreateConnectionError {
DirectConnectClient(String),
DirectConnectServer(String),
DuplicateTagKeys(String),
TooManyTags(String),
}
impl CreateConnectionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateConnectionError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"DirectConnectClientException" => {
return RusotoError::Service(CreateConnectionError::DirectConnectClient(
err.msg,
))
}
"DirectConnectServerException" => {
return RusotoError::Service(CreateConnectionError::DirectConnectServer(
err.msg,
))
}
"DuplicateTagKeysException" => {
return RusotoError::Service(CreateConnectionError::DuplicateTagKeys(err.msg))
}
"TooManyTagsException" => {
return RusotoError::Service(CreateConnectionError::TooManyTags(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateConnectionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateConnectionError::DirectConnectClient(ref cause) => write!(f, "{}", cause),
CreateConnectionError::DirectConnectServer(ref cause) => write!(f, "{}", cause),
CreateConnectionError::DuplicateTagKeys(ref cause) => write!(f, "{}", cause),
CreateConnectionError::TooManyTags(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateConnectionError {}
#[derive(Debug, PartialEq)]
pub enum CreateDirectConnectGatewayError {
DirectConnectClient(String),
DirectConnectServer(String),
}
impl CreateDirectConnectGatewayError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<CreateDirectConnectGatewayError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"DirectConnectClientException" => {
return RusotoError::Service(
CreateDirectConnectGatewayError::DirectConnectClient(err.msg),
)
}
"DirectConnectServerException" => {
return RusotoError::Service(
CreateDirectConnectGatewayError::DirectConnectServer(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateDirectConnectGatewayError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateDirectConnectGatewayError::DirectConnectClient(ref cause) => {
write!(f, "{}", cause)
}
CreateDirectConnectGatewayError::DirectConnectServer(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for CreateDirectConnectGatewayError {}
#[derive(Debug, PartialEq)]
pub enum CreateDirectConnectGatewayAssociationError {
DirectConnectClient(String),
DirectConnectServer(String),
}
impl CreateDirectConnectGatewayAssociationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<CreateDirectConnectGatewayAssociationError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"DirectConnectClientException" => {
return RusotoError::Service(
CreateDirectConnectGatewayAssociationError::DirectConnectClient(err.msg),
)
}
"DirectConnectServerException" => {
return RusotoError::Service(
CreateDirectConnectGatewayAssociationError::DirectConnectServer(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateDirectConnectGatewayAssociationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateDirectConnectGatewayAssociationError::DirectConnectClient(ref cause) => {
write!(f, "{}", cause)
}
CreateDirectConnectGatewayAssociationError::DirectConnectServer(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for CreateDirectConnectGatewayAssociationError {}
#[derive(Debug, PartialEq)]
pub enum CreateDirectConnectGatewayAssociationProposalError {
DirectConnectClient(String),
DirectConnectServer(String),
}
impl CreateDirectConnectGatewayAssociationProposalError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<CreateDirectConnectGatewayAssociationProposalError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"DirectConnectClientException" => {
return RusotoError::Service(
CreateDirectConnectGatewayAssociationProposalError::DirectConnectClient(
err.msg,
),
)
}
"DirectConnectServerException" => {
return RusotoError::Service(
CreateDirectConnectGatewayAssociationProposalError::DirectConnectServer(
err.msg,
),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateDirectConnectGatewayAssociationProposalError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateDirectConnectGatewayAssociationProposalError::DirectConnectClient(ref cause) => {
write!(f, "{}", cause)
}
CreateDirectConnectGatewayAssociationProposalError::DirectConnectServer(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for CreateDirectConnectGatewayAssociationProposalError {}
#[derive(Debug, PartialEq)]
pub enum CreateInterconnectError {
DirectConnectClient(String),
DirectConnectServer(String),
DuplicateTagKeys(String),
TooManyTags(String),
}
impl CreateInterconnectError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateInterconnectError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"DirectConnectClientException" => {
return RusotoError::Service(CreateInterconnectError::DirectConnectClient(
err.msg,
))
}
"DirectConnectServerException" => {
return RusotoError::Service(CreateInterconnectError::DirectConnectServer(
err.msg,
))
}
"DuplicateTagKeysException" => {
return RusotoError::Service(CreateInterconnectError::DuplicateTagKeys(err.msg))
}
"TooManyTagsException" => {
return RusotoError::Service(CreateInterconnectError::TooManyTags(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateInterconnectError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateInterconnectError::DirectConnectClient(ref cause) => write!(f, "{}", cause),
CreateInterconnectError::DirectConnectServer(ref cause) => write!(f, "{}", cause),
CreateInterconnectError::DuplicateTagKeys(ref cause) => write!(f, "{}", cause),
CreateInterconnectError::TooManyTags(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateInterconnectError {}
#[derive(Debug, PartialEq)]
pub enum CreateLagError {
DirectConnectClient(String),
DirectConnectServer(String),
DuplicateTagKeys(String),
TooManyTags(String),
}
impl CreateLagError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateLagError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"DirectConnectClientException" => {
return RusotoError::Service(CreateLagError::DirectConnectClient(err.msg))
}
"DirectConnectServerException" => {
return RusotoError::Service(CreateLagError::DirectConnectServer(err.msg))
}
"DuplicateTagKeysException" => {
return RusotoError::Service(CreateLagError::DuplicateTagKeys(err.msg))
}
"TooManyTagsException" => {
return RusotoError::Service(CreateLagError::TooManyTags(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateLagError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateLagError::DirectConnectClient(ref cause) => write!(f, "{}", cause),
CreateLagError::DirectConnectServer(ref cause) => write!(f, "{}", cause),
CreateLagError::DuplicateTagKeys(ref cause) => write!(f, "{}", cause),
CreateLagError::TooManyTags(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateLagError {}
#[derive(Debug, PartialEq)]
pub enum CreatePrivateVirtualInterfaceError {
DirectConnectClient(String),
DirectConnectServer(String),
DuplicateTagKeys(String),
TooManyTags(String),
}
impl CreatePrivateVirtualInterfaceError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<CreatePrivateVirtualInterfaceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"DirectConnectClientException" => {
return RusotoError::Service(
CreatePrivateVirtualInterfaceError::DirectConnectClient(err.msg),
)
}
"DirectConnectServerException" => {
return RusotoError::Service(
CreatePrivateVirtualInterfaceError::DirectConnectServer(err.msg),
)
}
"DuplicateTagKeysException" => {
return RusotoError::Service(
CreatePrivateVirtualInterfaceError::DuplicateTagKeys(err.msg),
)
}
"TooManyTagsException" => {
return RusotoError::Service(CreatePrivateVirtualInterfaceError::TooManyTags(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreatePrivateVirtualInterfaceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreatePrivateVirtualInterfaceError::DirectConnectClient(ref cause) => {
write!(f, "{}", cause)
}
CreatePrivateVirtualInterfaceError::DirectConnectServer(ref cause) => {
write!(f, "{}", cause)
}
CreatePrivateVirtualInterfaceError::DuplicateTagKeys(ref cause) => {
write!(f, "{}", cause)
}
CreatePrivateVirtualInterfaceError::TooManyTags(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreatePrivateVirtualInterfaceError {}
#[derive(Debug, PartialEq)]
pub enum CreatePublicVirtualInterfaceError {
DirectConnectClient(String),
DirectConnectServer(String),
DuplicateTagKeys(String),
TooManyTags(String),
}
impl CreatePublicVirtualInterfaceError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<CreatePublicVirtualInterfaceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"DirectConnectClientException" => {
return RusotoError::Service(
CreatePublicVirtualInterfaceError::DirectConnectClient(err.msg),
)
}
"DirectConnectServerException" => {
return RusotoError::Service(
CreatePublicVirtualInterfaceError::DirectConnectServer(err.msg),
)
}
"DuplicateTagKeysException" => {
return RusotoError::Service(
CreatePublicVirtualInterfaceError::DuplicateTagKeys(err.msg),
)
}
"TooManyTagsException" => {
return RusotoError::Service(CreatePublicVirtualInterfaceError::TooManyTags(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreatePublicVirtualInterfaceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreatePublicVirtualInterfaceError::DirectConnectClient(ref cause) => {
write!(f, "{}", cause)
}
CreatePublicVirtualInterfaceError::DirectConnectServer(ref cause) => {
write!(f, "{}", cause)
}
CreatePublicVirtualInterfaceError::DuplicateTagKeys(ref cause) => {
write!(f, "{}", cause)
}
CreatePublicVirtualInterfaceError::TooManyTags(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreatePublicVirtualInterfaceError {}
#[derive(Debug, PartialEq)]
pub enum CreateTransitVirtualInterfaceError {
DirectConnectClient(String),
DirectConnectServer(String),
DuplicateTagKeys(String),
TooManyTags(String),
}
impl CreateTransitVirtualInterfaceError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<CreateTransitVirtualInterfaceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"DirectConnectClientException" => {
return RusotoError::Service(
CreateTransitVirtualInterfaceError::DirectConnectClient(err.msg),
)
}
"DirectConnectServerException" => {
return RusotoError::Service(
CreateTransitVirtualInterfaceError::DirectConnectServer(err.msg),
)
}
"DuplicateTagKeysException" => {
return RusotoError::Service(
CreateTransitVirtualInterfaceError::DuplicateTagKeys(err.msg),
)
}
"TooManyTagsException" => {
return RusotoError::Service(CreateTransitVirtualInterfaceError::TooManyTags(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateTransitVirtualInterfaceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateTransitVirtualInterfaceError::DirectConnectClient(ref cause) => {
write!(f, "{}", cause)
}
CreateTransitVirtualInterfaceError::DirectConnectServer(ref cause) => {
write!(f, "{}", cause)
}
CreateTransitVirtualInterfaceError::DuplicateTagKeys(ref cause) => {
write!(f, "{}", cause)
}
CreateTransitVirtualInterfaceError::TooManyTags(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateTransitVirtualInterfaceError {}
#[derive(Debug, PartialEq)]
pub enum DeleteBGPPeerError {
DirectConnectClient(String),
DirectConnectServer(String),
}
impl DeleteBGPPeerError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteBGPPeerError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"DirectConnectClientException" => {
return RusotoError::Service(DeleteBGPPeerError::DirectConnectClient(err.msg))
}
"DirectConnectServerException" => {
return RusotoError::Service(DeleteBGPPeerError::DirectConnectServer(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteBGPPeerError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteBGPPeerError::DirectConnectClient(ref cause) => write!(f, "{}", cause),
DeleteBGPPeerError::DirectConnectServer(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteBGPPeerError {}
#[derive(Debug, PartialEq)]
pub enum DeleteConnectionError {
DirectConnectClient(String),
DirectConnectServer(String),
}
impl DeleteConnectionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteConnectionError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"DirectConnectClientException" => {
return RusotoError::Service(DeleteConnectionError::DirectConnectClient(
err.msg,
))
}
"DirectConnectServerException" => {
return RusotoError::Service(DeleteConnectionError::DirectConnectServer(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteConnectionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteConnectionError::DirectConnectClient(ref cause) => write!(f, "{}", cause),
DeleteConnectionError::DirectConnectServer(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteConnectionError {}
#[derive(Debug, PartialEq)]
pub enum DeleteDirectConnectGatewayError {
DirectConnectClient(String),
DirectConnectServer(String),
}
impl DeleteDirectConnectGatewayError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DeleteDirectConnectGatewayError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"DirectConnectClientException" => {
return RusotoError::Service(
DeleteDirectConnectGatewayError::DirectConnectClient(err.msg),
)
}
"DirectConnectServerException" => {
return RusotoError::Service(
DeleteDirectConnectGatewayError::DirectConnectServer(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteDirectConnectGatewayError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteDirectConnectGatewayError::DirectConnectClient(ref cause) => {
write!(f, "{}", cause)
}
DeleteDirectConnectGatewayError::DirectConnectServer(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DeleteDirectConnectGatewayError {}
#[derive(Debug, PartialEq)]
pub enum DeleteDirectConnectGatewayAssociationError {
DirectConnectClient(String),
DirectConnectServer(String),
}
impl DeleteDirectConnectGatewayAssociationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DeleteDirectConnectGatewayAssociationError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"DirectConnectClientException" => {
return RusotoError::Service(
DeleteDirectConnectGatewayAssociationError::DirectConnectClient(err.msg),
)
}
"DirectConnectServerException" => {
return RusotoError::Service(
DeleteDirectConnectGatewayAssociationError::DirectConnectServer(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteDirectConnectGatewayAssociationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteDirectConnectGatewayAssociationError::DirectConnectClient(ref cause) => {
write!(f, "{}", cause)
}
DeleteDirectConnectGatewayAssociationError::DirectConnectServer(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DeleteDirectConnectGatewayAssociationError {}
#[derive(Debug, PartialEq)]
pub enum DeleteDirectConnectGatewayAssociationProposalError {
DirectConnectClient(String),
DirectConnectServer(String),
}
impl DeleteDirectConnectGatewayAssociationProposalError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DeleteDirectConnectGatewayAssociationProposalError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"DirectConnectClientException" => {
return RusotoError::Service(
DeleteDirectConnectGatewayAssociationProposalError::DirectConnectClient(
err.msg,
),
)
}
"DirectConnectServerException" => {
return RusotoError::Service(
DeleteDirectConnectGatewayAssociationProposalError::DirectConnectServer(
err.msg,
),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteDirectConnectGatewayAssociationProposalError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteDirectConnectGatewayAssociationProposalError::DirectConnectClient(ref cause) => {
write!(f, "{}", cause)
}
DeleteDirectConnectGatewayAssociationProposalError::DirectConnectServer(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DeleteDirectConnectGatewayAssociationProposalError {}
#[derive(Debug, PartialEq)]
pub enum DeleteInterconnectError {
DirectConnectClient(String),
DirectConnectServer(String),
}
impl DeleteInterconnectError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteInterconnectError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"DirectConnectClientException" => {
return RusotoError::Service(DeleteInterconnectError::DirectConnectClient(
err.msg,
))
}
"DirectConnectServerException" => {
return RusotoError::Service(DeleteInterconnectError::DirectConnectServer(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteInterconnectError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteInterconnectError::DirectConnectClient(ref cause) => write!(f, "{}", cause),
DeleteInterconnectError::DirectConnectServer(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteInterconnectError {}
#[derive(Debug, PartialEq)]
pub enum DeleteLagError {
DirectConnectClient(String),
DirectConnectServer(String),
}
impl DeleteLagError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteLagError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"DirectConnectClientException" => {
return RusotoError::Service(DeleteLagError::DirectConnectClient(err.msg))
}
"DirectConnectServerException" => {
return RusotoError::Service(DeleteLagError::DirectConnectServer(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteLagError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteLagError::DirectConnectClient(ref cause) => write!(f, "{}", cause),
DeleteLagError::DirectConnectServer(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteLagError {}
#[derive(Debug, PartialEq)]
pub enum DeleteVirtualInterfaceError {
DirectConnectClient(String),
DirectConnectServer(String),
}
impl DeleteVirtualInterfaceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteVirtualInterfaceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"DirectConnectClientException" => {
return RusotoError::Service(DeleteVirtualInterfaceError::DirectConnectClient(
err.msg,
))
}
"DirectConnectServerException" => {
return RusotoError::Service(DeleteVirtualInterfaceError::DirectConnectServer(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteVirtualInterfaceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteVirtualInterfaceError::DirectConnectClient(ref cause) => write!(f, "{}", cause),
DeleteVirtualInterfaceError::DirectConnectServer(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteVirtualInterfaceError {}
#[derive(Debug, PartialEq)]
pub enum DescribeConnectionLoaError {
DirectConnectClient(String),
DirectConnectServer(String),
}
impl DescribeConnectionLoaError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeConnectionLoaError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"DirectConnectClientException" => {
return RusotoError::Service(DescribeConnectionLoaError::DirectConnectClient(
err.msg,
))
}
"DirectConnectServerException" => {
return RusotoError::Service(DescribeConnectionLoaError::DirectConnectServer(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeConnectionLoaError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeConnectionLoaError::DirectConnectClient(ref cause) => write!(f, "{}", cause),
DescribeConnectionLoaError::DirectConnectServer(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeConnectionLoaError {}
#[derive(Debug, PartialEq)]
pub enum DescribeConnectionsError {
DirectConnectClient(String),
DirectConnectServer(String),
}
impl DescribeConnectionsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeConnectionsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"DirectConnectClientException" => {
return RusotoError::Service(DescribeConnectionsError::DirectConnectClient(
err.msg,
))
}
"DirectConnectServerException" => {
return RusotoError::Service(DescribeConnectionsError::DirectConnectServer(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeConnectionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeConnectionsError::DirectConnectClient(ref cause) => write!(f, "{}", cause),
DescribeConnectionsError::DirectConnectServer(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeConnectionsError {}
#[derive(Debug, PartialEq)]
pub enum DescribeConnectionsOnInterconnectError {
DirectConnectClient(String),
DirectConnectServer(String),
}
impl DescribeConnectionsOnInterconnectError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeConnectionsOnInterconnectError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"DirectConnectClientException" => {
return RusotoError::Service(
DescribeConnectionsOnInterconnectError::DirectConnectClient(err.msg),
)
}
"DirectConnectServerException" => {
return RusotoError::Service(
DescribeConnectionsOnInterconnectError::DirectConnectServer(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeConnectionsOnInterconnectError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeConnectionsOnInterconnectError::DirectConnectClient(ref cause) => {
write!(f, "{}", cause)
}
DescribeConnectionsOnInterconnectError::DirectConnectServer(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeConnectionsOnInterconnectError {}
#[derive(Debug, PartialEq)]
pub enum DescribeDirectConnectGatewayAssociationProposalsError {
DirectConnectClient(String),
DirectConnectServer(String),
}
impl DescribeDirectConnectGatewayAssociationProposalsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeDirectConnectGatewayAssociationProposalsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"DirectConnectClientException" => {
return RusotoError::Service(
DescribeDirectConnectGatewayAssociationProposalsError::DirectConnectClient(
err.msg,
),
)
}
"DirectConnectServerException" => {
return RusotoError::Service(
DescribeDirectConnectGatewayAssociationProposalsError::DirectConnectServer(
err.msg,
),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeDirectConnectGatewayAssociationProposalsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeDirectConnectGatewayAssociationProposalsError::DirectConnectClient(
ref cause,
) => write!(f, "{}", cause),
DescribeDirectConnectGatewayAssociationProposalsError::DirectConnectServer(
ref cause,
) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeDirectConnectGatewayAssociationProposalsError {}
#[derive(Debug, PartialEq)]
pub enum DescribeDirectConnectGatewayAssociationsError {
DirectConnectClient(String),
DirectConnectServer(String),
}
impl DescribeDirectConnectGatewayAssociationsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeDirectConnectGatewayAssociationsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"DirectConnectClientException" => {
return RusotoError::Service(
DescribeDirectConnectGatewayAssociationsError::DirectConnectClient(err.msg),
)
}
"DirectConnectServerException" => {
return RusotoError::Service(
DescribeDirectConnectGatewayAssociationsError::DirectConnectServer(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeDirectConnectGatewayAssociationsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeDirectConnectGatewayAssociationsError::DirectConnectClient(ref cause) => {
write!(f, "{}", cause)
}
DescribeDirectConnectGatewayAssociationsError::DirectConnectServer(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeDirectConnectGatewayAssociationsError {}
#[derive(Debug, PartialEq)]
pub enum DescribeDirectConnectGatewayAttachmentsError {
DirectConnectClient(String),
DirectConnectServer(String),
}
impl DescribeDirectConnectGatewayAttachmentsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeDirectConnectGatewayAttachmentsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"DirectConnectClientException" => {
return RusotoError::Service(
DescribeDirectConnectGatewayAttachmentsError::DirectConnectClient(err.msg),
)
}
"DirectConnectServerException" => {
return RusotoError::Service(
DescribeDirectConnectGatewayAttachmentsError::DirectConnectServer(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeDirectConnectGatewayAttachmentsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeDirectConnectGatewayAttachmentsError::DirectConnectClient(ref cause) => {
write!(f, "{}", cause)
}
DescribeDirectConnectGatewayAttachmentsError::DirectConnectServer(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeDirectConnectGatewayAttachmentsError {}
#[derive(Debug, PartialEq)]
pub enum DescribeDirectConnectGatewaysError {
DirectConnectClient(String),
DirectConnectServer(String),
}
impl DescribeDirectConnectGatewaysError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeDirectConnectGatewaysError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"DirectConnectClientException" => {
return RusotoError::Service(
DescribeDirectConnectGatewaysError::DirectConnectClient(err.msg),
)
}
"DirectConnectServerException" => {
return RusotoError::Service(
DescribeDirectConnectGatewaysError::DirectConnectServer(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeDirectConnectGatewaysError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeDirectConnectGatewaysError::DirectConnectClient(ref cause) => {
write!(f, "{}", cause)
}
DescribeDirectConnectGatewaysError::DirectConnectServer(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeDirectConnectGatewaysError {}
#[derive(Debug, PartialEq)]
pub enum DescribeHostedConnectionsError {
DirectConnectClient(String),
DirectConnectServer(String),
}
impl DescribeHostedConnectionsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeHostedConnectionsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"DirectConnectClientException" => {
return RusotoError::Service(
DescribeHostedConnectionsError::DirectConnectClient(err.msg),
)
}
"DirectConnectServerException" => {
return RusotoError::Service(
DescribeHostedConnectionsError::DirectConnectServer(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeHostedConnectionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeHostedConnectionsError::DirectConnectClient(ref cause) => {
write!(f, "{}", cause)
}
DescribeHostedConnectionsError::DirectConnectServer(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeHostedConnectionsError {}
#[derive(Debug, PartialEq)]
pub enum DescribeInterconnectLoaError {
DirectConnectClient(String),
DirectConnectServer(String),
}
impl DescribeInterconnectLoaError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeInterconnectLoaError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"DirectConnectClientException" => {
return RusotoError::Service(DescribeInterconnectLoaError::DirectConnectClient(
err.msg,
))
}
"DirectConnectServerException" => {
return RusotoError::Service(DescribeInterconnectLoaError::DirectConnectServer(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeInterconnectLoaError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeInterconnectLoaError::DirectConnectClient(ref cause) => write!(f, "{}", cause),
DescribeInterconnectLoaError::DirectConnectServer(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeInterconnectLoaError {}
#[derive(Debug, PartialEq)]
pub enum DescribeInterconnectsError {
DirectConnectClient(String),
DirectConnectServer(String),
}
impl DescribeInterconnectsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeInterconnectsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"DirectConnectClientException" => {
return RusotoError::Service(DescribeInterconnectsError::DirectConnectClient(
err.msg,
))
}
"DirectConnectServerException" => {
return RusotoError::Service(DescribeInterconnectsError::DirectConnectServer(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeInterconnectsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeInterconnectsError::DirectConnectClient(ref cause) => write!(f, "{}", cause),
DescribeInterconnectsError::DirectConnectServer(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeInterconnectsError {}
#[derive(Debug, PartialEq)]
pub enum DescribeLagsError {
DirectConnectClient(String),
DirectConnectServer(String),
}
impl DescribeLagsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeLagsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"DirectConnectClientException" => {
return RusotoError::Service(DescribeLagsError::DirectConnectClient(err.msg))
}
"DirectConnectServerException" => {
return RusotoError::Service(DescribeLagsError::DirectConnectServer(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeLagsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeLagsError::DirectConnectClient(ref cause) => write!(f, "{}", cause),
DescribeLagsError::DirectConnectServer(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeLagsError {}
#[derive(Debug, PartialEq)]
pub enum DescribeLoaError {
DirectConnectClient(String),
DirectConnectServer(String),
}
impl DescribeLoaError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeLoaError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"DirectConnectClientException" => {
return RusotoError::Service(DescribeLoaError::DirectConnectClient(err.msg))
}
"DirectConnectServerException" => {
return RusotoError::Service(DescribeLoaError::DirectConnectServer(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeLoaError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeLoaError::DirectConnectClient(ref cause) => write!(f, "{}", cause),
DescribeLoaError::DirectConnectServer(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeLoaError {}
#[derive(Debug, PartialEq)]
pub enum DescribeLocationsError {
DirectConnectClient(String),
DirectConnectServer(String),
}
impl DescribeLocationsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeLocationsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"DirectConnectClientException" => {
return RusotoError::Service(DescribeLocationsError::DirectConnectClient(
err.msg,
))
}
"DirectConnectServerException" => {
return RusotoError::Service(DescribeLocationsError::DirectConnectServer(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeLocationsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeLocationsError::DirectConnectClient(ref cause) => write!(f, "{}", cause),
DescribeLocationsError::DirectConnectServer(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeLocationsError {}
#[derive(Debug, PartialEq)]
pub enum DescribeTagsError {
DirectConnectClient(String),
DirectConnectServer(String),
}
impl DescribeTagsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeTagsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"DirectConnectClientException" => {
return RusotoError::Service(DescribeTagsError::DirectConnectClient(err.msg))
}
"DirectConnectServerException" => {
return RusotoError::Service(DescribeTagsError::DirectConnectServer(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeTagsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeTagsError::DirectConnectClient(ref cause) => write!(f, "{}", cause),
DescribeTagsError::DirectConnectServer(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeTagsError {}
#[derive(Debug, PartialEq)]
pub enum DescribeVirtualGatewaysError {
DirectConnectClient(String),
DirectConnectServer(String),
}
impl DescribeVirtualGatewaysError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeVirtualGatewaysError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"DirectConnectClientException" => {
return RusotoError::Service(DescribeVirtualGatewaysError::DirectConnectClient(
err.msg,
))
}
"DirectConnectServerException" => {
return RusotoError::Service(DescribeVirtualGatewaysError::DirectConnectServer(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeVirtualGatewaysError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeVirtualGatewaysError::DirectConnectClient(ref cause) => write!(f, "{}", cause),
DescribeVirtualGatewaysError::DirectConnectServer(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeVirtualGatewaysError {}
#[derive(Debug, PartialEq)]
pub enum DescribeVirtualInterfacesError {
DirectConnectClient(String),
DirectConnectServer(String),
}
impl DescribeVirtualInterfacesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeVirtualInterfacesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"DirectConnectClientException" => {
return RusotoError::Service(
DescribeVirtualInterfacesError::DirectConnectClient(err.msg),
)
}
"DirectConnectServerException" => {
return RusotoError::Service(
DescribeVirtualInterfacesError::DirectConnectServer(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeVirtualInterfacesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeVirtualInterfacesError::DirectConnectClient(ref cause) => {
write!(f, "{}", cause)
}
DescribeVirtualInterfacesError::DirectConnectServer(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeVirtualInterfacesError {}
#[derive(Debug, PartialEq)]
pub enum DisassociateConnectionFromLagError {
DirectConnectClient(String),
DirectConnectServer(String),
}
impl DisassociateConnectionFromLagError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DisassociateConnectionFromLagError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"DirectConnectClientException" => {
return RusotoError::Service(
DisassociateConnectionFromLagError::DirectConnectClient(err.msg),
)
}
"DirectConnectServerException" => {
return RusotoError::Service(
DisassociateConnectionFromLagError::DirectConnectServer(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DisassociateConnectionFromLagError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DisassociateConnectionFromLagError::DirectConnectClient(ref cause) => {
write!(f, "{}", cause)
}
DisassociateConnectionFromLagError::DirectConnectServer(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DisassociateConnectionFromLagError {}
#[derive(Debug, PartialEq)]
pub enum ListVirtualInterfaceTestHistoryError {
DirectConnectClient(String),
DirectConnectServer(String),
}
impl ListVirtualInterfaceTestHistoryError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListVirtualInterfaceTestHistoryError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"DirectConnectClientException" => {
return RusotoError::Service(
ListVirtualInterfaceTestHistoryError::DirectConnectClient(err.msg),
)
}
"DirectConnectServerException" => {
return RusotoError::Service(
ListVirtualInterfaceTestHistoryError::DirectConnectServer(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListVirtualInterfaceTestHistoryError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListVirtualInterfaceTestHistoryError::DirectConnectClient(ref cause) => {
write!(f, "{}", cause)
}
ListVirtualInterfaceTestHistoryError::DirectConnectServer(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ListVirtualInterfaceTestHistoryError {}
#[derive(Debug, PartialEq)]
pub enum StartBgpFailoverTestError {
DirectConnectClient(String),
DirectConnectServer(String),
}
impl StartBgpFailoverTestError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StartBgpFailoverTestError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"DirectConnectClientException" => {
return RusotoError::Service(StartBgpFailoverTestError::DirectConnectClient(
err.msg,
))
}
"DirectConnectServerException" => {
return RusotoError::Service(StartBgpFailoverTestError::DirectConnectServer(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for StartBgpFailoverTestError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
StartBgpFailoverTestError::DirectConnectClient(ref cause) => write!(f, "{}", cause),
StartBgpFailoverTestError::DirectConnectServer(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for StartBgpFailoverTestError {}
#[derive(Debug, PartialEq)]
pub enum StopBgpFailoverTestError {
DirectConnectClient(String),
DirectConnectServer(String),
}
impl StopBgpFailoverTestError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StopBgpFailoverTestError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"DirectConnectClientException" => {
return RusotoError::Service(StopBgpFailoverTestError::DirectConnectClient(
err.msg,
))
}
"DirectConnectServerException" => {
return RusotoError::Service(StopBgpFailoverTestError::DirectConnectServer(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for StopBgpFailoverTestError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
StopBgpFailoverTestError::DirectConnectClient(ref cause) => write!(f, "{}", cause),
StopBgpFailoverTestError::DirectConnectServer(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for StopBgpFailoverTestError {}
#[derive(Debug, PartialEq)]
pub enum TagResourceError {
DirectConnectClient(String),
DirectConnectServer(String),
DuplicateTagKeys(String),
TooManyTags(String),
}
impl TagResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<TagResourceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"DirectConnectClientException" => {
return RusotoError::Service(TagResourceError::DirectConnectClient(err.msg))
}
"DirectConnectServerException" => {
return RusotoError::Service(TagResourceError::DirectConnectServer(err.msg))
}
"DuplicateTagKeysException" => {
return RusotoError::Service(TagResourceError::DuplicateTagKeys(err.msg))
}
"TooManyTagsException" => {
return RusotoError::Service(TagResourceError::TooManyTags(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for TagResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
TagResourceError::DirectConnectClient(ref cause) => write!(f, "{}", cause),
TagResourceError::DirectConnectServer(ref cause) => write!(f, "{}", cause),
TagResourceError::DuplicateTagKeys(ref cause) => write!(f, "{}", cause),
TagResourceError::TooManyTags(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for TagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UntagResourceError {
DirectConnectClient(String),
DirectConnectServer(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() {
"DirectConnectClientException" => {
return RusotoError::Service(UntagResourceError::DirectConnectClient(err.msg))
}
"DirectConnectServerException" => {
return RusotoError::Service(UntagResourceError::DirectConnectServer(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::DirectConnectClient(ref cause) => write!(f, "{}", cause),
UntagResourceError::DirectConnectServer(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UntagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UpdateDirectConnectGatewayAssociationError {
DirectConnectClient(String),
DirectConnectServer(String),
}
impl UpdateDirectConnectGatewayAssociationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<UpdateDirectConnectGatewayAssociationError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"DirectConnectClientException" => {
return RusotoError::Service(
UpdateDirectConnectGatewayAssociationError::DirectConnectClient(err.msg),
)
}
"DirectConnectServerException" => {
return RusotoError::Service(
UpdateDirectConnectGatewayAssociationError::DirectConnectServer(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateDirectConnectGatewayAssociationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateDirectConnectGatewayAssociationError::DirectConnectClient(ref cause) => {
write!(f, "{}", cause)
}
UpdateDirectConnectGatewayAssociationError::DirectConnectServer(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for UpdateDirectConnectGatewayAssociationError {}
#[derive(Debug, PartialEq)]
pub enum UpdateLagError {
DirectConnectClient(String),
DirectConnectServer(String),
}
impl UpdateLagError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateLagError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"DirectConnectClientException" => {
return RusotoError::Service(UpdateLagError::DirectConnectClient(err.msg))
}
"DirectConnectServerException" => {
return RusotoError::Service(UpdateLagError::DirectConnectServer(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateLagError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateLagError::DirectConnectClient(ref cause) => write!(f, "{}", cause),
UpdateLagError::DirectConnectServer(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateLagError {}
#[derive(Debug, PartialEq)]
pub enum UpdateVirtualInterfaceAttributesError {
DirectConnectClient(String),
DirectConnectServer(String),
}
impl UpdateVirtualInterfaceAttributesError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<UpdateVirtualInterfaceAttributesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"DirectConnectClientException" => {
return RusotoError::Service(
UpdateVirtualInterfaceAttributesError::DirectConnectClient(err.msg),
)
}
"DirectConnectServerException" => {
return RusotoError::Service(
UpdateVirtualInterfaceAttributesError::DirectConnectServer(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateVirtualInterfaceAttributesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateVirtualInterfaceAttributesError::DirectConnectClient(ref cause) => {
write!(f, "{}", cause)
}
UpdateVirtualInterfaceAttributesError::DirectConnectServer(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for UpdateVirtualInterfaceAttributesError {}
#[async_trait]
pub trait DirectConnect {
async fn accept_direct_connect_gateway_association_proposal(
&self,
input: AcceptDirectConnectGatewayAssociationProposalRequest,
) -> Result<
AcceptDirectConnectGatewayAssociationProposalResult,
RusotoError<AcceptDirectConnectGatewayAssociationProposalError>,
>;
async fn allocate_connection_on_interconnect(
&self,
input: AllocateConnectionOnInterconnectRequest,
) -> Result<Connection, RusotoError<AllocateConnectionOnInterconnectError>>;
async fn allocate_hosted_connection(
&self,
input: AllocateHostedConnectionRequest,
) -> Result<Connection, RusotoError<AllocateHostedConnectionError>>;
async fn allocate_private_virtual_interface(
&self,
input: AllocatePrivateVirtualInterfaceRequest,
) -> Result<VirtualInterface, RusotoError<AllocatePrivateVirtualInterfaceError>>;
async fn allocate_public_virtual_interface(
&self,
input: AllocatePublicVirtualInterfaceRequest,
) -> Result<VirtualInterface, RusotoError<AllocatePublicVirtualInterfaceError>>;
async fn allocate_transit_virtual_interface(
&self,
input: AllocateTransitVirtualInterfaceRequest,
) -> Result<
AllocateTransitVirtualInterfaceResult,
RusotoError<AllocateTransitVirtualInterfaceError>,
>;
async fn associate_connection_with_lag(
&self,
input: AssociateConnectionWithLagRequest,
) -> Result<Connection, RusotoError<AssociateConnectionWithLagError>>;
async fn associate_hosted_connection(
&self,
input: AssociateHostedConnectionRequest,
) -> Result<Connection, RusotoError<AssociateHostedConnectionError>>;
async fn associate_virtual_interface(
&self,
input: AssociateVirtualInterfaceRequest,
) -> Result<VirtualInterface, RusotoError<AssociateVirtualInterfaceError>>;
async fn confirm_connection(
&self,
input: ConfirmConnectionRequest,
) -> Result<ConfirmConnectionResponse, RusotoError<ConfirmConnectionError>>;
async fn confirm_private_virtual_interface(
&self,
input: ConfirmPrivateVirtualInterfaceRequest,
) -> Result<
ConfirmPrivateVirtualInterfaceResponse,
RusotoError<ConfirmPrivateVirtualInterfaceError>,
>;
async fn confirm_public_virtual_interface(
&self,
input: ConfirmPublicVirtualInterfaceRequest,
) -> Result<
ConfirmPublicVirtualInterfaceResponse,
RusotoError<ConfirmPublicVirtualInterfaceError>,
>;
async fn confirm_transit_virtual_interface(
&self,
input: ConfirmTransitVirtualInterfaceRequest,
) -> Result<
ConfirmTransitVirtualInterfaceResponse,
RusotoError<ConfirmTransitVirtualInterfaceError>,
>;
async fn create_bgp_peer(
&self,
input: CreateBGPPeerRequest,
) -> Result<CreateBGPPeerResponse, RusotoError<CreateBGPPeerError>>;
async fn create_connection(
&self,
input: CreateConnectionRequest,
) -> Result<Connection, RusotoError<CreateConnectionError>>;
async fn create_direct_connect_gateway(
&self,
input: CreateDirectConnectGatewayRequest,
) -> Result<CreateDirectConnectGatewayResult, RusotoError<CreateDirectConnectGatewayError>>;
async fn create_direct_connect_gateway_association(
&self,
input: CreateDirectConnectGatewayAssociationRequest,
) -> Result<
CreateDirectConnectGatewayAssociationResult,
RusotoError<CreateDirectConnectGatewayAssociationError>,
>;
async fn create_direct_connect_gateway_association_proposal(
&self,
input: CreateDirectConnectGatewayAssociationProposalRequest,
) -> Result<
CreateDirectConnectGatewayAssociationProposalResult,
RusotoError<CreateDirectConnectGatewayAssociationProposalError>,
>;
async fn create_interconnect(
&self,
input: CreateInterconnectRequest,
) -> Result<Interconnect, RusotoError<CreateInterconnectError>>;
async fn create_lag(&self, input: CreateLagRequest)
-> Result<Lag, RusotoError<CreateLagError>>;
async fn create_private_virtual_interface(
&self,
input: CreatePrivateVirtualInterfaceRequest,
) -> Result<VirtualInterface, RusotoError<CreatePrivateVirtualInterfaceError>>;
async fn create_public_virtual_interface(
&self,
input: CreatePublicVirtualInterfaceRequest,
) -> Result<VirtualInterface, RusotoError<CreatePublicVirtualInterfaceError>>;
async fn create_transit_virtual_interface(
&self,
input: CreateTransitVirtualInterfaceRequest,
) -> Result<CreateTransitVirtualInterfaceResult, RusotoError<CreateTransitVirtualInterfaceError>>;
async fn delete_bgp_peer(
&self,
input: DeleteBGPPeerRequest,
) -> Result<DeleteBGPPeerResponse, RusotoError<DeleteBGPPeerError>>;
async fn delete_connection(
&self,
input: DeleteConnectionRequest,
) -> Result<Connection, RusotoError<DeleteConnectionError>>;
async fn delete_direct_connect_gateway(
&self,
input: DeleteDirectConnectGatewayRequest,
) -> Result<DeleteDirectConnectGatewayResult, RusotoError<DeleteDirectConnectGatewayError>>;
async fn delete_direct_connect_gateway_association(
&self,
input: DeleteDirectConnectGatewayAssociationRequest,
) -> Result<
DeleteDirectConnectGatewayAssociationResult,
RusotoError<DeleteDirectConnectGatewayAssociationError>,
>;
async fn delete_direct_connect_gateway_association_proposal(
&self,
input: DeleteDirectConnectGatewayAssociationProposalRequest,
) -> Result<
DeleteDirectConnectGatewayAssociationProposalResult,
RusotoError<DeleteDirectConnectGatewayAssociationProposalError>,
>;
async fn delete_interconnect(
&self,
input: DeleteInterconnectRequest,
) -> Result<DeleteInterconnectResponse, RusotoError<DeleteInterconnectError>>;
async fn delete_lag(&self, input: DeleteLagRequest)
-> Result<Lag, RusotoError<DeleteLagError>>;
async fn delete_virtual_interface(
&self,
input: DeleteVirtualInterfaceRequest,
) -> Result<DeleteVirtualInterfaceResponse, RusotoError<DeleteVirtualInterfaceError>>;
async fn describe_connection_loa(
&self,
input: DescribeConnectionLoaRequest,
) -> Result<DescribeConnectionLoaResponse, RusotoError<DescribeConnectionLoaError>>;
async fn describe_connections(
&self,
input: DescribeConnectionsRequest,
) -> Result<Connections, RusotoError<DescribeConnectionsError>>;
async fn describe_connections_on_interconnect(
&self,
input: DescribeConnectionsOnInterconnectRequest,
) -> Result<Connections, RusotoError<DescribeConnectionsOnInterconnectError>>;
async fn describe_direct_connect_gateway_association_proposals(
&self,
input: DescribeDirectConnectGatewayAssociationProposalsRequest,
) -> Result<
DescribeDirectConnectGatewayAssociationProposalsResult,
RusotoError<DescribeDirectConnectGatewayAssociationProposalsError>,
>;
async fn describe_direct_connect_gateway_associations(
&self,
input: DescribeDirectConnectGatewayAssociationsRequest,
) -> Result<
DescribeDirectConnectGatewayAssociationsResult,
RusotoError<DescribeDirectConnectGatewayAssociationsError>,
>;
async fn describe_direct_connect_gateway_attachments(
&self,
input: DescribeDirectConnectGatewayAttachmentsRequest,
) -> Result<
DescribeDirectConnectGatewayAttachmentsResult,
RusotoError<DescribeDirectConnectGatewayAttachmentsError>,
>;
async fn describe_direct_connect_gateways(
&self,
input: DescribeDirectConnectGatewaysRequest,
) -> Result<DescribeDirectConnectGatewaysResult, RusotoError<DescribeDirectConnectGatewaysError>>;
async fn describe_hosted_connections(
&self,
input: DescribeHostedConnectionsRequest,
) -> Result<Connections, RusotoError<DescribeHostedConnectionsError>>;
async fn describe_interconnect_loa(
&self,
input: DescribeInterconnectLoaRequest,
) -> Result<DescribeInterconnectLoaResponse, RusotoError<DescribeInterconnectLoaError>>;
async fn describe_interconnects(
&self,
input: DescribeInterconnectsRequest,
) -> Result<Interconnects, RusotoError<DescribeInterconnectsError>>;
async fn describe_lags(
&self,
input: DescribeLagsRequest,
) -> Result<Lags, RusotoError<DescribeLagsError>>;
async fn describe_loa(
&self,
input: DescribeLoaRequest,
) -> Result<Loa, RusotoError<DescribeLoaError>>;
async fn describe_locations(&self) -> Result<Locations, RusotoError<DescribeLocationsError>>;
async fn describe_tags(
&self,
input: DescribeTagsRequest,
) -> Result<DescribeTagsResponse, RusotoError<DescribeTagsError>>;
async fn describe_virtual_gateways(
&self,
) -> Result<VirtualGateways, RusotoError<DescribeVirtualGatewaysError>>;
async fn describe_virtual_interfaces(
&self,
input: DescribeVirtualInterfacesRequest,
) -> Result<VirtualInterfaces, RusotoError<DescribeVirtualInterfacesError>>;
async fn disassociate_connection_from_lag(
&self,
input: DisassociateConnectionFromLagRequest,
) -> Result<Connection, RusotoError<DisassociateConnectionFromLagError>>;
async fn list_virtual_interface_test_history(
&self,
input: ListVirtualInterfaceTestHistoryRequest,
) -> Result<
ListVirtualInterfaceTestHistoryResponse,
RusotoError<ListVirtualInterfaceTestHistoryError>,
>;
async fn start_bgp_failover_test(
&self,
input: StartBgpFailoverTestRequest,
) -> Result<StartBgpFailoverTestResponse, RusotoError<StartBgpFailoverTestError>>;
async fn stop_bgp_failover_test(
&self,
input: StopBgpFailoverTestRequest,
) -> Result<StopBgpFailoverTestResponse, RusotoError<StopBgpFailoverTestError>>;
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_direct_connect_gateway_association(
&self,
input: UpdateDirectConnectGatewayAssociationRequest,
) -> Result<
UpdateDirectConnectGatewayAssociationResult,
RusotoError<UpdateDirectConnectGatewayAssociationError>,
>;
async fn update_lag(&self, input: UpdateLagRequest)
-> Result<Lag, RusotoError<UpdateLagError>>;
async fn update_virtual_interface_attributes(
&self,
input: UpdateVirtualInterfaceAttributesRequest,
) -> Result<VirtualInterface, RusotoError<UpdateVirtualInterfaceAttributesError>>;
}
#[derive(Clone)]
pub struct DirectConnectClient {
client: Client,
region: region::Region,
}
impl DirectConnectClient {
pub fn new(region: region::Region) -> DirectConnectClient {
DirectConnectClient {
client: Client::shared(),
region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> DirectConnectClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
D: DispatchSignedRequest + Send + Sync + 'static,
{
DirectConnectClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region,
}
}
pub fn new_with_client(client: Client, region: region::Region) -> DirectConnectClient {
DirectConnectClient { client, region }
}
}
#[async_trait]
impl DirectConnect for DirectConnectClient {
async fn accept_direct_connect_gateway_association_proposal(
&self,
input: AcceptDirectConnectGatewayAssociationProposalRequest,
) -> Result<
AcceptDirectConnectGatewayAssociationProposalResult,
RusotoError<AcceptDirectConnectGatewayAssociationProposalError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"OvertureService.AcceptDirectConnectGatewayAssociationProposal",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
AcceptDirectConnectGatewayAssociationProposalError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<AcceptDirectConnectGatewayAssociationProposalResult, _>()
}
async fn allocate_connection_on_interconnect(
&self,
input: AllocateConnectionOnInterconnectRequest,
) -> Result<Connection, RusotoError<AllocateConnectionOnInterconnectError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"OvertureService.AllocateConnectionOnInterconnect",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
AllocateConnectionOnInterconnectError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<Connection, _>()
}
async fn allocate_hosted_connection(
&self,
input: AllocateHostedConnectionRequest,
) -> Result<Connection, RusotoError<AllocateHostedConnectionError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "OvertureService.AllocateHostedConnection");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, AllocateHostedConnectionError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<Connection, _>()
}
async fn allocate_private_virtual_interface(
&self,
input: AllocatePrivateVirtualInterfaceRequest,
) -> Result<VirtualInterface, RusotoError<AllocatePrivateVirtualInterfaceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"OvertureService.AllocatePrivateVirtualInterface",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, AllocatePrivateVirtualInterfaceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<VirtualInterface, _>()
}
async fn allocate_public_virtual_interface(
&self,
input: AllocatePublicVirtualInterfaceRequest,
) -> Result<VirtualInterface, RusotoError<AllocatePublicVirtualInterfaceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"OvertureService.AllocatePublicVirtualInterface",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, AllocatePublicVirtualInterfaceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<VirtualInterface, _>()
}
async fn allocate_transit_virtual_interface(
&self,
input: AllocateTransitVirtualInterfaceRequest,
) -> Result<
AllocateTransitVirtualInterfaceResult,
RusotoError<AllocateTransitVirtualInterfaceError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"OvertureService.AllocateTransitVirtualInterface",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, AllocateTransitVirtualInterfaceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<AllocateTransitVirtualInterfaceResult, _>()
}
async fn associate_connection_with_lag(
&self,
input: AssociateConnectionWithLagRequest,
) -> Result<Connection, RusotoError<AssociateConnectionWithLagError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "OvertureService.AssociateConnectionWithLag");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, AssociateConnectionWithLagError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<Connection, _>()
}
async fn associate_hosted_connection(
&self,
input: AssociateHostedConnectionRequest,
) -> Result<Connection, RusotoError<AssociateHostedConnectionError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "OvertureService.AssociateHostedConnection");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, AssociateHostedConnectionError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<Connection, _>()
}
async fn associate_virtual_interface(
&self,
input: AssociateVirtualInterfaceRequest,
) -> Result<VirtualInterface, RusotoError<AssociateVirtualInterfaceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "OvertureService.AssociateVirtualInterface");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, AssociateVirtualInterfaceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<VirtualInterface, _>()
}
async fn confirm_connection(
&self,
input: ConfirmConnectionRequest,
) -> Result<ConfirmConnectionResponse, RusotoError<ConfirmConnectionError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "OvertureService.ConfirmConnection");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ConfirmConnectionError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ConfirmConnectionResponse, _>()
}
async fn confirm_private_virtual_interface(
&self,
input: ConfirmPrivateVirtualInterfaceRequest,
) -> Result<
ConfirmPrivateVirtualInterfaceResponse,
RusotoError<ConfirmPrivateVirtualInterfaceError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"OvertureService.ConfirmPrivateVirtualInterface",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ConfirmPrivateVirtualInterfaceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ConfirmPrivateVirtualInterfaceResponse, _>()
}
async fn confirm_public_virtual_interface(
&self,
input: ConfirmPublicVirtualInterfaceRequest,
) -> Result<
ConfirmPublicVirtualInterfaceResponse,
RusotoError<ConfirmPublicVirtualInterfaceError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"OvertureService.ConfirmPublicVirtualInterface",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ConfirmPublicVirtualInterfaceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ConfirmPublicVirtualInterfaceResponse, _>()
}
async fn confirm_transit_virtual_interface(
&self,
input: ConfirmTransitVirtualInterfaceRequest,
) -> Result<
ConfirmTransitVirtualInterfaceResponse,
RusotoError<ConfirmTransitVirtualInterfaceError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"OvertureService.ConfirmTransitVirtualInterface",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ConfirmTransitVirtualInterfaceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ConfirmTransitVirtualInterfaceResponse, _>()
}
async fn create_bgp_peer(
&self,
input: CreateBGPPeerRequest,
) -> Result<CreateBGPPeerResponse, RusotoError<CreateBGPPeerError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "OvertureService.CreateBGPPeer");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateBGPPeerError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateBGPPeerResponse, _>()
}
async fn create_connection(
&self,
input: CreateConnectionRequest,
) -> Result<Connection, RusotoError<CreateConnectionError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "OvertureService.CreateConnection");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateConnectionError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<Connection, _>()
}
async fn create_direct_connect_gateway(
&self,
input: CreateDirectConnectGatewayRequest,
) -> Result<CreateDirectConnectGatewayResult, RusotoError<CreateDirectConnectGatewayError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "OvertureService.CreateDirectConnectGateway");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateDirectConnectGatewayError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<CreateDirectConnectGatewayResult, _>()
}
async fn create_direct_connect_gateway_association(
&self,
input: CreateDirectConnectGatewayAssociationRequest,
) -> Result<
CreateDirectConnectGatewayAssociationResult,
RusotoError<CreateDirectConnectGatewayAssociationError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"OvertureService.CreateDirectConnectGatewayAssociation",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
CreateDirectConnectGatewayAssociationError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<CreateDirectConnectGatewayAssociationResult, _>()
}
async fn create_direct_connect_gateway_association_proposal(
&self,
input: CreateDirectConnectGatewayAssociationProposalRequest,
) -> Result<
CreateDirectConnectGatewayAssociationProposalResult,
RusotoError<CreateDirectConnectGatewayAssociationProposalError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"OvertureService.CreateDirectConnectGatewayAssociationProposal",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
CreateDirectConnectGatewayAssociationProposalError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<CreateDirectConnectGatewayAssociationProposalResult, _>()
}
async fn create_interconnect(
&self,
input: CreateInterconnectRequest,
) -> Result<Interconnect, RusotoError<CreateInterconnectError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "OvertureService.CreateInterconnect");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateInterconnectError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<Interconnect, _>()
}
async fn create_lag(
&self,
input: CreateLagRequest,
) -> Result<Lag, RusotoError<CreateLagError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "OvertureService.CreateLag");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateLagError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<Lag, _>()
}
async fn create_private_virtual_interface(
&self,
input: CreatePrivateVirtualInterfaceRequest,
) -> Result<VirtualInterface, RusotoError<CreatePrivateVirtualInterfaceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"OvertureService.CreatePrivateVirtualInterface",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreatePrivateVirtualInterfaceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<VirtualInterface, _>()
}
async fn create_public_virtual_interface(
&self,
input: CreatePublicVirtualInterfaceRequest,
) -> Result<VirtualInterface, RusotoError<CreatePublicVirtualInterfaceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"OvertureService.CreatePublicVirtualInterface",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreatePublicVirtualInterfaceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<VirtualInterface, _>()
}
async fn create_transit_virtual_interface(
&self,
input: CreateTransitVirtualInterfaceRequest,
) -> Result<CreateTransitVirtualInterfaceResult, RusotoError<CreateTransitVirtualInterfaceError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"OvertureService.CreateTransitVirtualInterface",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateTransitVirtualInterfaceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<CreateTransitVirtualInterfaceResult, _>()
}
async fn delete_bgp_peer(
&self,
input: DeleteBGPPeerRequest,
) -> Result<DeleteBGPPeerResponse, RusotoError<DeleteBGPPeerError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "OvertureService.DeleteBGPPeer");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteBGPPeerError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DeleteBGPPeerResponse, _>()
}
async fn delete_connection(
&self,
input: DeleteConnectionRequest,
) -> Result<Connection, RusotoError<DeleteConnectionError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "OvertureService.DeleteConnection");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteConnectionError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<Connection, _>()
}
async fn delete_direct_connect_gateway(
&self,
input: DeleteDirectConnectGatewayRequest,
) -> Result<DeleteDirectConnectGatewayResult, RusotoError<DeleteDirectConnectGatewayError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "OvertureService.DeleteDirectConnectGateway");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteDirectConnectGatewayError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteDirectConnectGatewayResult, _>()
}
async fn delete_direct_connect_gateway_association(
&self,
input: DeleteDirectConnectGatewayAssociationRequest,
) -> Result<
DeleteDirectConnectGatewayAssociationResult,
RusotoError<DeleteDirectConnectGatewayAssociationError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"OvertureService.DeleteDirectConnectGatewayAssociation",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
DeleteDirectConnectGatewayAssociationError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteDirectConnectGatewayAssociationResult, _>()
}
async fn delete_direct_connect_gateway_association_proposal(
&self,
input: DeleteDirectConnectGatewayAssociationProposalRequest,
) -> Result<
DeleteDirectConnectGatewayAssociationProposalResult,
RusotoError<DeleteDirectConnectGatewayAssociationProposalError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"OvertureService.DeleteDirectConnectGatewayAssociationProposal",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
DeleteDirectConnectGatewayAssociationProposalError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteDirectConnectGatewayAssociationProposalResult, _>()
}
async fn delete_interconnect(
&self,
input: DeleteInterconnectRequest,
) -> Result<DeleteInterconnectResponse, RusotoError<DeleteInterconnectError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "OvertureService.DeleteInterconnect");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteInterconnectError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DeleteInterconnectResponse, _>()
}
async fn delete_lag(
&self,
input: DeleteLagRequest,
) -> Result<Lag, RusotoError<DeleteLagError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "OvertureService.DeleteLag");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteLagError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<Lag, _>()
}
async fn delete_virtual_interface(
&self,
input: DeleteVirtualInterfaceRequest,
) -> Result<DeleteVirtualInterfaceResponse, RusotoError<DeleteVirtualInterfaceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "OvertureService.DeleteVirtualInterface");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteVirtualInterfaceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteVirtualInterfaceResponse, _>()
}
async fn describe_connection_loa(
&self,
input: DescribeConnectionLoaRequest,
) -> Result<DescribeConnectionLoaResponse, RusotoError<DescribeConnectionLoaError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "OvertureService.DescribeConnectionLoa");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeConnectionLoaError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeConnectionLoaResponse, _>()
}
async fn describe_connections(
&self,
input: DescribeConnectionsRequest,
) -> Result<Connections, RusotoError<DescribeConnectionsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "OvertureService.DescribeConnections");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeConnectionsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<Connections, _>()
}
async fn describe_connections_on_interconnect(
&self,
input: DescribeConnectionsOnInterconnectRequest,
) -> Result<Connections, RusotoError<DescribeConnectionsOnInterconnectError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"OvertureService.DescribeConnectionsOnInterconnect",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
DescribeConnectionsOnInterconnectError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<Connections, _>()
}
async fn describe_direct_connect_gateway_association_proposals(
&self,
input: DescribeDirectConnectGatewayAssociationProposalsRequest,
) -> Result<
DescribeDirectConnectGatewayAssociationProposalsResult,
RusotoError<DescribeDirectConnectGatewayAssociationProposalsError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"OvertureService.DescribeDirectConnectGatewayAssociationProposals",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
DescribeDirectConnectGatewayAssociationProposalsError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeDirectConnectGatewayAssociationProposalsResult, _>()
}
async fn describe_direct_connect_gateway_associations(
&self,
input: DescribeDirectConnectGatewayAssociationsRequest,
) -> Result<
DescribeDirectConnectGatewayAssociationsResult,
RusotoError<DescribeDirectConnectGatewayAssociationsError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"OvertureService.DescribeDirectConnectGatewayAssociations",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
DescribeDirectConnectGatewayAssociationsError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeDirectConnectGatewayAssociationsResult, _>()
}
async fn describe_direct_connect_gateway_attachments(
&self,
input: DescribeDirectConnectGatewayAttachmentsRequest,
) -> Result<
DescribeDirectConnectGatewayAttachmentsResult,
RusotoError<DescribeDirectConnectGatewayAttachmentsError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"OvertureService.DescribeDirectConnectGatewayAttachments",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
DescribeDirectConnectGatewayAttachmentsError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeDirectConnectGatewayAttachmentsResult, _>()
}
async fn describe_direct_connect_gateways(
&self,
input: DescribeDirectConnectGatewaysRequest,
) -> Result<DescribeDirectConnectGatewaysResult, RusotoError<DescribeDirectConnectGatewaysError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"OvertureService.DescribeDirectConnectGateways",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeDirectConnectGatewaysError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeDirectConnectGatewaysResult, _>()
}
async fn describe_hosted_connections(
&self,
input: DescribeHostedConnectionsRequest,
) -> Result<Connections, RusotoError<DescribeHostedConnectionsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "OvertureService.DescribeHostedConnections");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeHostedConnectionsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<Connections, _>()
}
async fn describe_interconnect_loa(
&self,
input: DescribeInterconnectLoaRequest,
) -> Result<DescribeInterconnectLoaResponse, RusotoError<DescribeInterconnectLoaError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "OvertureService.DescribeInterconnectLoa");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeInterconnectLoaError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeInterconnectLoaResponse, _>()
}
async fn describe_interconnects(
&self,
input: DescribeInterconnectsRequest,
) -> Result<Interconnects, RusotoError<DescribeInterconnectsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "OvertureService.DescribeInterconnects");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeInterconnectsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<Interconnects, _>()
}
async fn describe_lags(
&self,
input: DescribeLagsRequest,
) -> Result<Lags, RusotoError<DescribeLagsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "OvertureService.DescribeLags");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeLagsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<Lags, _>()
}
async fn describe_loa(
&self,
input: DescribeLoaRequest,
) -> Result<Loa, RusotoError<DescribeLoaError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "OvertureService.DescribeLoa");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeLoaError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<Loa, _>()
}
async fn describe_locations(&self) -> Result<Locations, RusotoError<DescribeLocationsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "OvertureService.DescribeLocations");
request.set_payload(Some(bytes::Bytes::from_static(b"{}")));
let response = self
.sign_and_dispatch(request, DescribeLocationsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<Locations, _>()
}
async fn describe_tags(
&self,
input: DescribeTagsRequest,
) -> Result<DescribeTagsResponse, RusotoError<DescribeTagsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "OvertureService.DescribeTags");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeTagsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DescribeTagsResponse, _>()
}
async fn describe_virtual_gateways(
&self,
) -> Result<VirtualGateways, RusotoError<DescribeVirtualGatewaysError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "OvertureService.DescribeVirtualGateways");
request.set_payload(Some(bytes::Bytes::from_static(b"{}")));
let response = self
.sign_and_dispatch(request, DescribeVirtualGatewaysError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<VirtualGateways, _>()
}
async fn describe_virtual_interfaces(
&self,
input: DescribeVirtualInterfacesRequest,
) -> Result<VirtualInterfaces, RusotoError<DescribeVirtualInterfacesError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "OvertureService.DescribeVirtualInterfaces");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeVirtualInterfacesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<VirtualInterfaces, _>()
}
async fn disassociate_connection_from_lag(
&self,
input: DisassociateConnectionFromLagRequest,
) -> Result<Connection, RusotoError<DisassociateConnectionFromLagError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"OvertureService.DisassociateConnectionFromLag",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DisassociateConnectionFromLagError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<Connection, _>()
}
async fn list_virtual_interface_test_history(
&self,
input: ListVirtualInterfaceTestHistoryRequest,
) -> Result<
ListVirtualInterfaceTestHistoryResponse,
RusotoError<ListVirtualInterfaceTestHistoryError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"OvertureService.ListVirtualInterfaceTestHistory",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListVirtualInterfaceTestHistoryError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListVirtualInterfaceTestHistoryResponse, _>()
}
async fn start_bgp_failover_test(
&self,
input: StartBgpFailoverTestRequest,
) -> Result<StartBgpFailoverTestResponse, RusotoError<StartBgpFailoverTestError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "OvertureService.StartBgpFailoverTest");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, StartBgpFailoverTestError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<StartBgpFailoverTestResponse, _>()
}
async fn stop_bgp_failover_test(
&self,
input: StopBgpFailoverTestRequest,
) -> Result<StopBgpFailoverTestResponse, RusotoError<StopBgpFailoverTestError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "OvertureService.StopBgpFailoverTest");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, StopBgpFailoverTestError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<StopBgpFailoverTestResponse, _>()
}
async fn tag_resource(
&self,
input: TagResourceRequest,
) -> Result<TagResourceResponse, RusotoError<TagResourceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "OvertureService.TagResource");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, TagResourceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<TagResourceResponse, _>()
}
async fn untag_resource(
&self,
input: UntagResourceRequest,
) -> Result<UntagResourceResponse, RusotoError<UntagResourceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "OvertureService.UntagResource");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UntagResourceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<UntagResourceResponse, _>()
}
async fn update_direct_connect_gateway_association(
&self,
input: UpdateDirectConnectGatewayAssociationRequest,
) -> Result<
UpdateDirectConnectGatewayAssociationResult,
RusotoError<UpdateDirectConnectGatewayAssociationError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"OvertureService.UpdateDirectConnectGatewayAssociation",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
UpdateDirectConnectGatewayAssociationError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateDirectConnectGatewayAssociationResult, _>()
}
async fn update_lag(
&self,
input: UpdateLagRequest,
) -> Result<Lag, RusotoError<UpdateLagError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "OvertureService.UpdateLag");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UpdateLagError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<Lag, _>()
}
async fn update_virtual_interface_attributes(
&self,
input: UpdateVirtualInterfaceAttributesRequest,
) -> Result<VirtualInterface, RusotoError<UpdateVirtualInterfaceAttributesError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"OvertureService.UpdateVirtualInterfaceAttributes",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
UpdateVirtualInterfaceAttributesError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<VirtualInterface, _>()
}
}