use std::error::Error;
use std::fmt;
use async_trait::async_trait;
use rusoto_core::credential::ProvideAwsCredentials;
use rusoto_core::region;
use rusoto_core::request::{BufferedHttpResponse, DispatchSignedRequest};
use rusoto_core::{Client, RusotoError};
use rusoto_core::param::{Params, ServiceParams};
use rusoto_core::proto;
use rusoto_core::signature::SignedRequest;
#[allow(unused_imports)]
use serde::{Deserialize, Serialize};
use serde_json;
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AddFlowOutputsRequest {
#[serde(rename = "FlowArn")]
pub flow_arn: String,
#[serde(rename = "Outputs")]
pub outputs: Vec<AddOutputRequest>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AddFlowOutputsResponse {
#[serde(rename = "FlowArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub flow_arn: Option<String>,
#[serde(rename = "Outputs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub outputs: Option<Vec<Output>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AddFlowSourcesRequest {
#[serde(rename = "FlowArn")]
pub flow_arn: String,
#[serde(rename = "Sources")]
pub sources: Vec<SetSourceRequest>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AddFlowSourcesResponse {
#[serde(rename = "FlowArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub flow_arn: Option<String>,
#[serde(rename = "Sources")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sources: Option<Vec<Source>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AddFlowVpcInterfacesRequest {
#[serde(rename = "FlowArn")]
pub flow_arn: String,
#[serde(rename = "VpcInterfaces")]
pub vpc_interfaces: Vec<VpcInterfaceRequest>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AddFlowVpcInterfacesResponse {
#[serde(rename = "FlowArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub flow_arn: Option<String>,
#[serde(rename = "VpcInterfaces")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpc_interfaces: Option<Vec<VpcInterface>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AddOutputRequest {
#[serde(rename = "CidrAllowList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cidr_allow_list: Option<Vec<String>>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "Destination")]
#[serde(skip_serializing_if = "Option::is_none")]
pub destination: Option<String>,
#[serde(rename = "Encryption")]
#[serde(skip_serializing_if = "Option::is_none")]
pub encryption: Option<Encryption>,
#[serde(rename = "MaxLatency")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_latency: Option<i64>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "Port")]
#[serde(skip_serializing_if = "Option::is_none")]
pub port: Option<i64>,
#[serde(rename = "Protocol")]
pub protocol: String,
#[serde(rename = "RemoteId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub remote_id: Option<String>,
#[serde(rename = "SmoothingLatency")]
#[serde(skip_serializing_if = "Option::is_none")]
pub smoothing_latency: Option<i64>,
#[serde(rename = "StreamId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stream_id: Option<String>,
#[serde(rename = "VpcInterfaceAttachment")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpc_interface_attachment: Option<VpcInterfaceAttachment>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateFlowRequest {
#[serde(rename = "AvailabilityZone")]
#[serde(skip_serializing_if = "Option::is_none")]
pub availability_zone: Option<String>,
#[serde(rename = "Entitlements")]
#[serde(skip_serializing_if = "Option::is_none")]
pub entitlements: Option<Vec<GrantEntitlementRequest>>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "Outputs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub outputs: Option<Vec<AddOutputRequest>>,
#[serde(rename = "Source")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source: Option<SetSourceRequest>,
#[serde(rename = "SourceFailoverConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_failover_config: Option<FailoverConfig>,
#[serde(rename = "Sources")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sources: Option<Vec<SetSourceRequest>>,
#[serde(rename = "VpcInterfaces")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpc_interfaces: Option<Vec<VpcInterfaceRequest>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateFlowResponse {
#[serde(rename = "Flow")]
#[serde(skip_serializing_if = "Option::is_none")]
pub flow: Option<Flow>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteFlowRequest {
#[serde(rename = "FlowArn")]
pub flow_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteFlowResponse {
#[serde(rename = "FlowArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub flow_arn: Option<String>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeFlowRequest {
#[serde(rename = "FlowArn")]
pub flow_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeFlowResponse {
#[serde(rename = "Flow")]
#[serde(skip_serializing_if = "Option::is_none")]
pub flow: Option<Flow>,
#[serde(rename = "Messages")]
#[serde(skip_serializing_if = "Option::is_none")]
pub messages: Option<Messages>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct Encryption {
#[serde(rename = "Algorithm")]
pub algorithm: String,
#[serde(rename = "ConstantInitializationVector")]
#[serde(skip_serializing_if = "Option::is_none")]
pub constant_initialization_vector: Option<String>,
#[serde(rename = "DeviceId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub device_id: Option<String>,
#[serde(rename = "KeyType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub key_type: Option<String>,
#[serde(rename = "Region")]
#[serde(skip_serializing_if = "Option::is_none")]
pub region: Option<String>,
#[serde(rename = "ResourceId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_id: Option<String>,
#[serde(rename = "RoleArn")]
pub role_arn: String,
#[serde(rename = "SecretArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub secret_arn: Option<String>,
#[serde(rename = "Url")]
#[serde(skip_serializing_if = "Option::is_none")]
pub url: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Entitlement {
#[serde(rename = "DataTransferSubscriberFeePercent")]
#[serde(skip_serializing_if = "Option::is_none")]
pub data_transfer_subscriber_fee_percent: Option<i64>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "Encryption")]
#[serde(skip_serializing_if = "Option::is_none")]
pub encryption: Option<Encryption>,
#[serde(rename = "EntitlementArn")]
pub entitlement_arn: String,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "Subscribers")]
pub subscribers: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct FailoverConfig {
#[serde(rename = "RecoveryWindow")]
#[serde(skip_serializing_if = "Option::is_none")]
pub recovery_window: Option<i64>,
#[serde(rename = "State")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Flow {
#[serde(rename = "AvailabilityZone")]
pub availability_zone: String,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "EgressIp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub egress_ip: Option<String>,
#[serde(rename = "Entitlements")]
pub entitlements: Vec<Entitlement>,
#[serde(rename = "FlowArn")]
pub flow_arn: String,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "Outputs")]
pub outputs: Vec<Output>,
#[serde(rename = "Source")]
pub source: Source,
#[serde(rename = "SourceFailoverConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_failover_config: Option<FailoverConfig>,
#[serde(rename = "Sources")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sources: Option<Vec<Source>>,
#[serde(rename = "Status")]
pub status: String,
#[serde(rename = "VpcInterfaces")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpc_interfaces: Option<Vec<VpcInterface>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GrantEntitlementRequest {
#[serde(rename = "DataTransferSubscriberFeePercent")]
#[serde(skip_serializing_if = "Option::is_none")]
pub data_transfer_subscriber_fee_percent: Option<i64>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "Encryption")]
#[serde(skip_serializing_if = "Option::is_none")]
pub encryption: Option<Encryption>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "Subscribers")]
pub subscribers: Vec<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GrantFlowEntitlementsRequest {
#[serde(rename = "Entitlements")]
pub entitlements: Vec<GrantEntitlementRequest>,
#[serde(rename = "FlowArn")]
pub flow_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GrantFlowEntitlementsResponse {
#[serde(rename = "Entitlements")]
#[serde(skip_serializing_if = "Option::is_none")]
pub entitlements: Option<Vec<Entitlement>>,
#[serde(rename = "FlowArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub flow_arn: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListEntitlementsRequest {
#[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 ListEntitlementsResponse {
#[serde(rename = "Entitlements")]
#[serde(skip_serializing_if = "Option::is_none")]
pub entitlements: Option<Vec<ListedEntitlement>>,
#[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 ListFlowsRequest {
#[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 ListFlowsResponse {
#[serde(rename = "Flows")]
#[serde(skip_serializing_if = "Option::is_none")]
pub flows: Option<Vec<ListedFlow>>,
#[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 ListTagsForResourceRequest {
#[serde(rename = "ResourceArn")]
pub resource_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListTagsForResourceResponse {
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListedEntitlement {
#[serde(rename = "DataTransferSubscriberFeePercent")]
#[serde(skip_serializing_if = "Option::is_none")]
pub data_transfer_subscriber_fee_percent: Option<i64>,
#[serde(rename = "EntitlementArn")]
pub entitlement_arn: String,
#[serde(rename = "EntitlementName")]
pub entitlement_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListedFlow {
#[serde(rename = "AvailabilityZone")]
pub availability_zone: String,
#[serde(rename = "Description")]
pub description: String,
#[serde(rename = "FlowArn")]
pub flow_arn: String,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "SourceType")]
pub source_type: String,
#[serde(rename = "Status")]
pub status: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Messages {
#[serde(rename = "Errors")]
pub errors: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Output {
#[serde(rename = "DataTransferSubscriberFeePercent")]
#[serde(skip_serializing_if = "Option::is_none")]
pub data_transfer_subscriber_fee_percent: Option<i64>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "Destination")]
#[serde(skip_serializing_if = "Option::is_none")]
pub destination: Option<String>,
#[serde(rename = "Encryption")]
#[serde(skip_serializing_if = "Option::is_none")]
pub encryption: Option<Encryption>,
#[serde(rename = "EntitlementArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub entitlement_arn: Option<String>,
#[serde(rename = "MediaLiveInputArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub media_live_input_arn: Option<String>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "OutputArn")]
pub output_arn: String,
#[serde(rename = "Port")]
#[serde(skip_serializing_if = "Option::is_none")]
pub port: Option<i64>,
#[serde(rename = "Transport")]
#[serde(skip_serializing_if = "Option::is_none")]
pub transport: Option<Transport>,
#[serde(rename = "VpcInterfaceAttachment")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpc_interface_attachment: Option<VpcInterfaceAttachment>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct RemoveFlowOutputRequest {
#[serde(rename = "FlowArn")]
pub flow_arn: String,
#[serde(rename = "OutputArn")]
pub output_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RemoveFlowOutputResponse {
#[serde(rename = "FlowArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub flow_arn: Option<String>,
#[serde(rename = "OutputArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub output_arn: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct RemoveFlowSourceRequest {
#[serde(rename = "FlowArn")]
pub flow_arn: String,
#[serde(rename = "SourceArn")]
pub source_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RemoveFlowSourceResponse {
#[serde(rename = "FlowArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub flow_arn: Option<String>,
#[serde(rename = "SourceArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_arn: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct RemoveFlowVpcInterfaceRequest {
#[serde(rename = "FlowArn")]
pub flow_arn: String,
#[serde(rename = "VpcInterfaceName")]
pub vpc_interface_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RemoveFlowVpcInterfaceResponse {
#[serde(rename = "FlowArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub flow_arn: Option<String>,
#[serde(rename = "NonDeletedNetworkInterfaceIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub non_deleted_network_interface_ids: Option<Vec<String>>,
#[serde(rename = "VpcInterfaceName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpc_interface_name: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct RevokeFlowEntitlementRequest {
#[serde(rename = "EntitlementArn")]
pub entitlement_arn: String,
#[serde(rename = "FlowArn")]
pub flow_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RevokeFlowEntitlementResponse {
#[serde(rename = "EntitlementArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub entitlement_arn: Option<String>,
#[serde(rename = "FlowArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub flow_arn: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct SetSourceRequest {
#[serde(rename = "Decryption")]
#[serde(skip_serializing_if = "Option::is_none")]
pub decryption: Option<Encryption>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "EntitlementArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub entitlement_arn: Option<String>,
#[serde(rename = "IngestPort")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ingest_port: Option<i64>,
#[serde(rename = "MaxBitrate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_bitrate: Option<i64>,
#[serde(rename = "MaxLatency")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_latency: Option<i64>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "Protocol")]
#[serde(skip_serializing_if = "Option::is_none")]
pub protocol: Option<String>,
#[serde(rename = "StreamId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stream_id: Option<String>,
#[serde(rename = "VpcInterfaceName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpc_interface_name: Option<String>,
#[serde(rename = "WhitelistCidr")]
#[serde(skip_serializing_if = "Option::is_none")]
pub whitelist_cidr: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Source {
#[serde(rename = "DataTransferSubscriberFeePercent")]
#[serde(skip_serializing_if = "Option::is_none")]
pub data_transfer_subscriber_fee_percent: Option<i64>,
#[serde(rename = "Decryption")]
#[serde(skip_serializing_if = "Option::is_none")]
pub decryption: Option<Encryption>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "EntitlementArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub entitlement_arn: Option<String>,
#[serde(rename = "IngestIp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ingest_ip: Option<String>,
#[serde(rename = "IngestPort")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ingest_port: Option<i64>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "SourceArn")]
pub source_arn: String,
#[serde(rename = "Transport")]
#[serde(skip_serializing_if = "Option::is_none")]
pub transport: Option<Transport>,
#[serde(rename = "VpcInterfaceName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpc_interface_name: Option<String>,
#[serde(rename = "WhitelistCidr")]
#[serde(skip_serializing_if = "Option::is_none")]
pub whitelist_cidr: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StartFlowRequest {
#[serde(rename = "FlowArn")]
pub flow_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct StartFlowResponse {
#[serde(rename = "FlowArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub flow_arn: Option<String>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StopFlowRequest {
#[serde(rename = "FlowArn")]
pub flow_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct StopFlowResponse {
#[serde(rename = "FlowArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub flow_arn: Option<String>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct TagResourceRequest {
#[serde(rename = "ResourceArn")]
pub resource_arn: String,
#[serde(rename = "Tags")]
pub tags: ::std::collections::HashMap<String, String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Transport {
#[serde(rename = "CidrAllowList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cidr_allow_list: Option<Vec<String>>,
#[serde(rename = "MaxBitrate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_bitrate: Option<i64>,
#[serde(rename = "MaxLatency")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_latency: Option<i64>,
#[serde(rename = "Protocol")]
pub protocol: String,
#[serde(rename = "RemoteId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub remote_id: Option<String>,
#[serde(rename = "SmoothingLatency")]
#[serde(skip_serializing_if = "Option::is_none")]
pub smoothing_latency: Option<i64>,
#[serde(rename = "StreamId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stream_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UntagResourceRequest {
#[serde(rename = "ResourceArn")]
pub resource_arn: String,
#[serde(rename = "TagKeys")]
pub tag_keys: Vec<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateEncryption {
#[serde(rename = "Algorithm")]
#[serde(skip_serializing_if = "Option::is_none")]
pub algorithm: Option<String>,
#[serde(rename = "ConstantInitializationVector")]
#[serde(skip_serializing_if = "Option::is_none")]
pub constant_initialization_vector: Option<String>,
#[serde(rename = "DeviceId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub device_id: Option<String>,
#[serde(rename = "KeyType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub key_type: Option<String>,
#[serde(rename = "Region")]
#[serde(skip_serializing_if = "Option::is_none")]
pub region: Option<String>,
#[serde(rename = "ResourceId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_id: Option<String>,
#[serde(rename = "RoleArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub role_arn: Option<String>,
#[serde(rename = "SecretArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub secret_arn: Option<String>,
#[serde(rename = "Url")]
#[serde(skip_serializing_if = "Option::is_none")]
pub url: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateFailoverConfig {
#[serde(rename = "RecoveryWindow")]
#[serde(skip_serializing_if = "Option::is_none")]
pub recovery_window: Option<i64>,
#[serde(rename = "State")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateFlowEntitlementRequest {
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "Encryption")]
#[serde(skip_serializing_if = "Option::is_none")]
pub encryption: Option<UpdateEncryption>,
#[serde(rename = "EntitlementArn")]
pub entitlement_arn: String,
#[serde(rename = "FlowArn")]
pub flow_arn: String,
#[serde(rename = "Subscribers")]
#[serde(skip_serializing_if = "Option::is_none")]
pub subscribers: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateFlowEntitlementResponse {
#[serde(rename = "Entitlement")]
#[serde(skip_serializing_if = "Option::is_none")]
pub entitlement: Option<Entitlement>,
#[serde(rename = "FlowArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub flow_arn: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateFlowOutputRequest {
#[serde(rename = "CidrAllowList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cidr_allow_list: Option<Vec<String>>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "Destination")]
#[serde(skip_serializing_if = "Option::is_none")]
pub destination: Option<String>,
#[serde(rename = "Encryption")]
#[serde(skip_serializing_if = "Option::is_none")]
pub encryption: Option<UpdateEncryption>,
#[serde(rename = "FlowArn")]
pub flow_arn: String,
#[serde(rename = "MaxLatency")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_latency: Option<i64>,
#[serde(rename = "OutputArn")]
pub output_arn: String,
#[serde(rename = "Port")]
#[serde(skip_serializing_if = "Option::is_none")]
pub port: Option<i64>,
#[serde(rename = "Protocol")]
#[serde(skip_serializing_if = "Option::is_none")]
pub protocol: Option<String>,
#[serde(rename = "RemoteId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub remote_id: Option<String>,
#[serde(rename = "SmoothingLatency")]
#[serde(skip_serializing_if = "Option::is_none")]
pub smoothing_latency: Option<i64>,
#[serde(rename = "StreamId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stream_id: Option<String>,
#[serde(rename = "VpcInterfaceAttachment")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpc_interface_attachment: Option<VpcInterfaceAttachment>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateFlowOutputResponse {
#[serde(rename = "FlowArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub flow_arn: Option<String>,
#[serde(rename = "Output")]
#[serde(skip_serializing_if = "Option::is_none")]
pub output: Option<Output>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateFlowRequest {
#[serde(rename = "FlowArn")]
pub flow_arn: String,
#[serde(rename = "SourceFailoverConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_failover_config: Option<UpdateFailoverConfig>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateFlowResponse {
#[serde(rename = "Flow")]
#[serde(skip_serializing_if = "Option::is_none")]
pub flow: Option<Flow>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateFlowSourceRequest {
#[serde(rename = "Decryption")]
#[serde(skip_serializing_if = "Option::is_none")]
pub decryption: Option<UpdateEncryption>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "EntitlementArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub entitlement_arn: Option<String>,
#[serde(rename = "FlowArn")]
pub flow_arn: String,
#[serde(rename = "IngestPort")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ingest_port: Option<i64>,
#[serde(rename = "MaxBitrate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_bitrate: Option<i64>,
#[serde(rename = "MaxLatency")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_latency: Option<i64>,
#[serde(rename = "Protocol")]
#[serde(skip_serializing_if = "Option::is_none")]
pub protocol: Option<String>,
#[serde(rename = "SourceArn")]
pub source_arn: String,
#[serde(rename = "StreamId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stream_id: Option<String>,
#[serde(rename = "VpcInterfaceName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpc_interface_name: Option<String>,
#[serde(rename = "WhitelistCidr")]
#[serde(skip_serializing_if = "Option::is_none")]
pub whitelist_cidr: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateFlowSourceResponse {
#[serde(rename = "FlowArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub flow_arn: Option<String>,
#[serde(rename = "Source")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source: Option<Source>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct VpcInterface {
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "NetworkInterfaceIds")]
pub network_interface_ids: Vec<String>,
#[serde(rename = "RoleArn")]
pub role_arn: String,
#[serde(rename = "SecurityGroupIds")]
pub security_group_ids: Vec<String>,
#[serde(rename = "SubnetId")]
pub subnet_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct VpcInterfaceAttachment {
#[serde(rename = "VpcInterfaceName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpc_interface_name: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct VpcInterfaceRequest {
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "RoleArn")]
pub role_arn: String,
#[serde(rename = "SecurityGroupIds")]
pub security_group_ids: Vec<String>,
#[serde(rename = "SubnetId")]
pub subnet_id: String,
}
#[derive(Debug, PartialEq)]
pub enum AddFlowOutputsError {
AddFlowOutputs420(String),
BadRequest(String),
Forbidden(String),
InternalServerError(String),
NotFound(String),
ServiceUnavailable(String),
TooManyRequests(String),
}
impl AddFlowOutputsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AddFlowOutputsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AddFlowOutputs420Exception" => {
return RusotoError::Service(AddFlowOutputsError::AddFlowOutputs420(err.msg))
}
"BadRequestException" => {
return RusotoError::Service(AddFlowOutputsError::BadRequest(err.msg))
}
"ForbiddenException" => {
return RusotoError::Service(AddFlowOutputsError::Forbidden(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(AddFlowOutputsError::InternalServerError(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(AddFlowOutputsError::NotFound(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(AddFlowOutputsError::ServiceUnavailable(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(AddFlowOutputsError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AddFlowOutputsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AddFlowOutputsError::AddFlowOutputs420(ref cause) => write!(f, "{}", cause),
AddFlowOutputsError::BadRequest(ref cause) => write!(f, "{}", cause),
AddFlowOutputsError::Forbidden(ref cause) => write!(f, "{}", cause),
AddFlowOutputsError::InternalServerError(ref cause) => write!(f, "{}", cause),
AddFlowOutputsError::NotFound(ref cause) => write!(f, "{}", cause),
AddFlowOutputsError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
AddFlowOutputsError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for AddFlowOutputsError {}
#[derive(Debug, PartialEq)]
pub enum AddFlowSourcesError {
BadRequest(String),
Forbidden(String),
InternalServerError(String),
NotFound(String),
ServiceUnavailable(String),
TooManyRequests(String),
}
impl AddFlowSourcesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AddFlowSourcesError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(AddFlowSourcesError::BadRequest(err.msg))
}
"ForbiddenException" => {
return RusotoError::Service(AddFlowSourcesError::Forbidden(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(AddFlowSourcesError::InternalServerError(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(AddFlowSourcesError::NotFound(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(AddFlowSourcesError::ServiceUnavailable(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(AddFlowSourcesError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AddFlowSourcesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AddFlowSourcesError::BadRequest(ref cause) => write!(f, "{}", cause),
AddFlowSourcesError::Forbidden(ref cause) => write!(f, "{}", cause),
AddFlowSourcesError::InternalServerError(ref cause) => write!(f, "{}", cause),
AddFlowSourcesError::NotFound(ref cause) => write!(f, "{}", cause),
AddFlowSourcesError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
AddFlowSourcesError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for AddFlowSourcesError {}
#[derive(Debug, PartialEq)]
pub enum AddFlowVpcInterfacesError {
BadRequest(String),
Forbidden(String),
InternalServerError(String),
NotFound(String),
ServiceUnavailable(String),
TooManyRequests(String),
}
impl AddFlowVpcInterfacesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AddFlowVpcInterfacesError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(AddFlowVpcInterfacesError::BadRequest(err.msg))
}
"ForbiddenException" => {
return RusotoError::Service(AddFlowVpcInterfacesError::Forbidden(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(AddFlowVpcInterfacesError::InternalServerError(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(AddFlowVpcInterfacesError::NotFound(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(AddFlowVpcInterfacesError::ServiceUnavailable(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(AddFlowVpcInterfacesError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AddFlowVpcInterfacesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AddFlowVpcInterfacesError::BadRequest(ref cause) => write!(f, "{}", cause),
AddFlowVpcInterfacesError::Forbidden(ref cause) => write!(f, "{}", cause),
AddFlowVpcInterfacesError::InternalServerError(ref cause) => write!(f, "{}", cause),
AddFlowVpcInterfacesError::NotFound(ref cause) => write!(f, "{}", cause),
AddFlowVpcInterfacesError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
AddFlowVpcInterfacesError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for AddFlowVpcInterfacesError {}
#[derive(Debug, PartialEq)]
pub enum CreateFlowError {
BadRequest(String),
CreateFlow420(String),
Forbidden(String),
InternalServerError(String),
ServiceUnavailable(String),
TooManyRequests(String),
}
impl CreateFlowError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateFlowError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(CreateFlowError::BadRequest(err.msg))
}
"CreateFlow420Exception" => {
return RusotoError::Service(CreateFlowError::CreateFlow420(err.msg))
}
"ForbiddenException" => {
return RusotoError::Service(CreateFlowError::Forbidden(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(CreateFlowError::InternalServerError(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(CreateFlowError::ServiceUnavailable(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(CreateFlowError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateFlowError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateFlowError::BadRequest(ref cause) => write!(f, "{}", cause),
CreateFlowError::CreateFlow420(ref cause) => write!(f, "{}", cause),
CreateFlowError::Forbidden(ref cause) => write!(f, "{}", cause),
CreateFlowError::InternalServerError(ref cause) => write!(f, "{}", cause),
CreateFlowError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
CreateFlowError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateFlowError {}
#[derive(Debug, PartialEq)]
pub enum DeleteFlowError {
BadRequest(String),
Forbidden(String),
InternalServerError(String),
NotFound(String),
ServiceUnavailable(String),
TooManyRequests(String),
}
impl DeleteFlowError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteFlowError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(DeleteFlowError::BadRequest(err.msg))
}
"ForbiddenException" => {
return RusotoError::Service(DeleteFlowError::Forbidden(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(DeleteFlowError::InternalServerError(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(DeleteFlowError::NotFound(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(DeleteFlowError::ServiceUnavailable(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(DeleteFlowError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteFlowError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteFlowError::BadRequest(ref cause) => write!(f, "{}", cause),
DeleteFlowError::Forbidden(ref cause) => write!(f, "{}", cause),
DeleteFlowError::InternalServerError(ref cause) => write!(f, "{}", cause),
DeleteFlowError::NotFound(ref cause) => write!(f, "{}", cause),
DeleteFlowError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
DeleteFlowError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteFlowError {}
#[derive(Debug, PartialEq)]
pub enum DescribeFlowError {
BadRequest(String),
Forbidden(String),
InternalServerError(String),
NotFound(String),
ServiceUnavailable(String),
TooManyRequests(String),
}
impl DescribeFlowError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeFlowError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(DescribeFlowError::BadRequest(err.msg))
}
"ForbiddenException" => {
return RusotoError::Service(DescribeFlowError::Forbidden(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(DescribeFlowError::InternalServerError(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(DescribeFlowError::NotFound(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(DescribeFlowError::ServiceUnavailable(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(DescribeFlowError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeFlowError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeFlowError::BadRequest(ref cause) => write!(f, "{}", cause),
DescribeFlowError::Forbidden(ref cause) => write!(f, "{}", cause),
DescribeFlowError::InternalServerError(ref cause) => write!(f, "{}", cause),
DescribeFlowError::NotFound(ref cause) => write!(f, "{}", cause),
DescribeFlowError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
DescribeFlowError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeFlowError {}
#[derive(Debug, PartialEq)]
pub enum GrantFlowEntitlementsError {
BadRequest(String),
Forbidden(String),
GrantFlowEntitlements420(String),
InternalServerError(String),
NotFound(String),
ServiceUnavailable(String),
TooManyRequests(String),
}
impl GrantFlowEntitlementsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GrantFlowEntitlementsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GrantFlowEntitlementsError::BadRequest(err.msg))
}
"ForbiddenException" => {
return RusotoError::Service(GrantFlowEntitlementsError::Forbidden(err.msg))
}
"GrantFlowEntitlements420Exception" => {
return RusotoError::Service(
GrantFlowEntitlementsError::GrantFlowEntitlements420(err.msg),
)
}
"InternalServerErrorException" => {
return RusotoError::Service(GrantFlowEntitlementsError::InternalServerError(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(GrantFlowEntitlementsError::NotFound(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(GrantFlowEntitlementsError::ServiceUnavailable(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(GrantFlowEntitlementsError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GrantFlowEntitlementsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GrantFlowEntitlementsError::BadRequest(ref cause) => write!(f, "{}", cause),
GrantFlowEntitlementsError::Forbidden(ref cause) => write!(f, "{}", cause),
GrantFlowEntitlementsError::GrantFlowEntitlements420(ref cause) => {
write!(f, "{}", cause)
}
GrantFlowEntitlementsError::InternalServerError(ref cause) => write!(f, "{}", cause),
GrantFlowEntitlementsError::NotFound(ref cause) => write!(f, "{}", cause),
GrantFlowEntitlementsError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
GrantFlowEntitlementsError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GrantFlowEntitlementsError {}
#[derive(Debug, PartialEq)]
pub enum ListEntitlementsError {
BadRequest(String),
InternalServerError(String),
ServiceUnavailable(String),
TooManyRequests(String),
}
impl ListEntitlementsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListEntitlementsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(ListEntitlementsError::BadRequest(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(ListEntitlementsError::InternalServerError(
err.msg,
))
}
"ServiceUnavailableException" => {
return RusotoError::Service(ListEntitlementsError::ServiceUnavailable(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(ListEntitlementsError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListEntitlementsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListEntitlementsError::BadRequest(ref cause) => write!(f, "{}", cause),
ListEntitlementsError::InternalServerError(ref cause) => write!(f, "{}", cause),
ListEntitlementsError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
ListEntitlementsError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListEntitlementsError {}
#[derive(Debug, PartialEq)]
pub enum ListFlowsError {
BadRequest(String),
InternalServerError(String),
ServiceUnavailable(String),
TooManyRequests(String),
}
impl ListFlowsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListFlowsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(ListFlowsError::BadRequest(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(ListFlowsError::InternalServerError(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(ListFlowsError::ServiceUnavailable(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(ListFlowsError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListFlowsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListFlowsError::BadRequest(ref cause) => write!(f, "{}", cause),
ListFlowsError::InternalServerError(ref cause) => write!(f, "{}", cause),
ListFlowsError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
ListFlowsError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListFlowsError {}
#[derive(Debug, PartialEq)]
pub enum ListTagsForResourceError {
BadRequest(String),
InternalServerError(String),
NotFound(String),
}
impl ListTagsForResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListTagsForResourceError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(ListTagsForResourceError::BadRequest(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(ListTagsForResourceError::InternalServerError(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(ListTagsForResourceError::NotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListTagsForResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListTagsForResourceError::BadRequest(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::InternalServerError(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::NotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListTagsForResourceError {}
#[derive(Debug, PartialEq)]
pub enum RemoveFlowOutputError {
BadRequest(String),
Forbidden(String),
InternalServerError(String),
NotFound(String),
ServiceUnavailable(String),
TooManyRequests(String),
}
impl RemoveFlowOutputError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<RemoveFlowOutputError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(RemoveFlowOutputError::BadRequest(err.msg))
}
"ForbiddenException" => {
return RusotoError::Service(RemoveFlowOutputError::Forbidden(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(RemoveFlowOutputError::InternalServerError(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(RemoveFlowOutputError::NotFound(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(RemoveFlowOutputError::ServiceUnavailable(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(RemoveFlowOutputError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for RemoveFlowOutputError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
RemoveFlowOutputError::BadRequest(ref cause) => write!(f, "{}", cause),
RemoveFlowOutputError::Forbidden(ref cause) => write!(f, "{}", cause),
RemoveFlowOutputError::InternalServerError(ref cause) => write!(f, "{}", cause),
RemoveFlowOutputError::NotFound(ref cause) => write!(f, "{}", cause),
RemoveFlowOutputError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
RemoveFlowOutputError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for RemoveFlowOutputError {}
#[derive(Debug, PartialEq)]
pub enum RemoveFlowSourceError {
BadRequest(String),
Forbidden(String),
InternalServerError(String),
NotFound(String),
ServiceUnavailable(String),
TooManyRequests(String),
}
impl RemoveFlowSourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<RemoveFlowSourceError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(RemoveFlowSourceError::BadRequest(err.msg))
}
"ForbiddenException" => {
return RusotoError::Service(RemoveFlowSourceError::Forbidden(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(RemoveFlowSourceError::InternalServerError(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(RemoveFlowSourceError::NotFound(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(RemoveFlowSourceError::ServiceUnavailable(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(RemoveFlowSourceError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for RemoveFlowSourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
RemoveFlowSourceError::BadRequest(ref cause) => write!(f, "{}", cause),
RemoveFlowSourceError::Forbidden(ref cause) => write!(f, "{}", cause),
RemoveFlowSourceError::InternalServerError(ref cause) => write!(f, "{}", cause),
RemoveFlowSourceError::NotFound(ref cause) => write!(f, "{}", cause),
RemoveFlowSourceError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
RemoveFlowSourceError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for RemoveFlowSourceError {}
#[derive(Debug, PartialEq)]
pub enum RemoveFlowVpcInterfaceError {
BadRequest(String),
Forbidden(String),
InternalServerError(String),
NotFound(String),
ServiceUnavailable(String),
TooManyRequests(String),
}
impl RemoveFlowVpcInterfaceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<RemoveFlowVpcInterfaceError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(RemoveFlowVpcInterfaceError::BadRequest(err.msg))
}
"ForbiddenException" => {
return RusotoError::Service(RemoveFlowVpcInterfaceError::Forbidden(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(RemoveFlowVpcInterfaceError::InternalServerError(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(RemoveFlowVpcInterfaceError::NotFound(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(RemoveFlowVpcInterfaceError::ServiceUnavailable(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(RemoveFlowVpcInterfaceError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for RemoveFlowVpcInterfaceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
RemoveFlowVpcInterfaceError::BadRequest(ref cause) => write!(f, "{}", cause),
RemoveFlowVpcInterfaceError::Forbidden(ref cause) => write!(f, "{}", cause),
RemoveFlowVpcInterfaceError::InternalServerError(ref cause) => write!(f, "{}", cause),
RemoveFlowVpcInterfaceError::NotFound(ref cause) => write!(f, "{}", cause),
RemoveFlowVpcInterfaceError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
RemoveFlowVpcInterfaceError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for RemoveFlowVpcInterfaceError {}
#[derive(Debug, PartialEq)]
pub enum RevokeFlowEntitlementError {
BadRequest(String),
Forbidden(String),
InternalServerError(String),
NotFound(String),
ServiceUnavailable(String),
TooManyRequests(String),
}
impl RevokeFlowEntitlementError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<RevokeFlowEntitlementError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(RevokeFlowEntitlementError::BadRequest(err.msg))
}
"ForbiddenException" => {
return RusotoError::Service(RevokeFlowEntitlementError::Forbidden(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(RevokeFlowEntitlementError::InternalServerError(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(RevokeFlowEntitlementError::NotFound(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(RevokeFlowEntitlementError::ServiceUnavailable(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(RevokeFlowEntitlementError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for RevokeFlowEntitlementError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
RevokeFlowEntitlementError::BadRequest(ref cause) => write!(f, "{}", cause),
RevokeFlowEntitlementError::Forbidden(ref cause) => write!(f, "{}", cause),
RevokeFlowEntitlementError::InternalServerError(ref cause) => write!(f, "{}", cause),
RevokeFlowEntitlementError::NotFound(ref cause) => write!(f, "{}", cause),
RevokeFlowEntitlementError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
RevokeFlowEntitlementError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for RevokeFlowEntitlementError {}
#[derive(Debug, PartialEq)]
pub enum StartFlowError {
BadRequest(String),
Forbidden(String),
InternalServerError(String),
NotFound(String),
ServiceUnavailable(String),
TooManyRequests(String),
}
impl StartFlowError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StartFlowError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(StartFlowError::BadRequest(err.msg))
}
"ForbiddenException" => {
return RusotoError::Service(StartFlowError::Forbidden(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(StartFlowError::InternalServerError(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(StartFlowError::NotFound(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(StartFlowError::ServiceUnavailable(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(StartFlowError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for StartFlowError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
StartFlowError::BadRequest(ref cause) => write!(f, "{}", cause),
StartFlowError::Forbidden(ref cause) => write!(f, "{}", cause),
StartFlowError::InternalServerError(ref cause) => write!(f, "{}", cause),
StartFlowError::NotFound(ref cause) => write!(f, "{}", cause),
StartFlowError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
StartFlowError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for StartFlowError {}
#[derive(Debug, PartialEq)]
pub enum StopFlowError {
BadRequest(String),
Forbidden(String),
InternalServerError(String),
NotFound(String),
ServiceUnavailable(String),
TooManyRequests(String),
}
impl StopFlowError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StopFlowError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(StopFlowError::BadRequest(err.msg))
}
"ForbiddenException" => {
return RusotoError::Service(StopFlowError::Forbidden(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(StopFlowError::InternalServerError(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(StopFlowError::NotFound(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(StopFlowError::ServiceUnavailable(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(StopFlowError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for StopFlowError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
StopFlowError::BadRequest(ref cause) => write!(f, "{}", cause),
StopFlowError::Forbidden(ref cause) => write!(f, "{}", cause),
StopFlowError::InternalServerError(ref cause) => write!(f, "{}", cause),
StopFlowError::NotFound(ref cause) => write!(f, "{}", cause),
StopFlowError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
StopFlowError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for StopFlowError {}
#[derive(Debug, PartialEq)]
pub enum TagResourceError {
BadRequest(String),
InternalServerError(String),
NotFound(String),
}
impl TagResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<TagResourceError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(TagResourceError::BadRequest(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(TagResourceError::InternalServerError(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(TagResourceError::NotFound(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::BadRequest(ref cause) => write!(f, "{}", cause),
TagResourceError::InternalServerError(ref cause) => write!(f, "{}", cause),
TagResourceError::NotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for TagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UntagResourceError {
BadRequest(String),
InternalServerError(String),
NotFound(String),
}
impl UntagResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UntagResourceError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(UntagResourceError::BadRequest(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(UntagResourceError::InternalServerError(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(UntagResourceError::NotFound(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::BadRequest(ref cause) => write!(f, "{}", cause),
UntagResourceError::InternalServerError(ref cause) => write!(f, "{}", cause),
UntagResourceError::NotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UntagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UpdateFlowError {
BadRequest(String),
Forbidden(String),
InternalServerError(String),
NotFound(String),
ServiceUnavailable(String),
TooManyRequests(String),
}
impl UpdateFlowError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateFlowError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(UpdateFlowError::BadRequest(err.msg))
}
"ForbiddenException" => {
return RusotoError::Service(UpdateFlowError::Forbidden(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(UpdateFlowError::InternalServerError(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(UpdateFlowError::NotFound(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(UpdateFlowError::ServiceUnavailable(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(UpdateFlowError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateFlowError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateFlowError::BadRequest(ref cause) => write!(f, "{}", cause),
UpdateFlowError::Forbidden(ref cause) => write!(f, "{}", cause),
UpdateFlowError::InternalServerError(ref cause) => write!(f, "{}", cause),
UpdateFlowError::NotFound(ref cause) => write!(f, "{}", cause),
UpdateFlowError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
UpdateFlowError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateFlowError {}
#[derive(Debug, PartialEq)]
pub enum UpdateFlowEntitlementError {
BadRequest(String),
Forbidden(String),
InternalServerError(String),
NotFound(String),
ServiceUnavailable(String),
TooManyRequests(String),
}
impl UpdateFlowEntitlementError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateFlowEntitlementError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(UpdateFlowEntitlementError::BadRequest(err.msg))
}
"ForbiddenException" => {
return RusotoError::Service(UpdateFlowEntitlementError::Forbidden(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(UpdateFlowEntitlementError::InternalServerError(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(UpdateFlowEntitlementError::NotFound(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(UpdateFlowEntitlementError::ServiceUnavailable(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(UpdateFlowEntitlementError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateFlowEntitlementError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateFlowEntitlementError::BadRequest(ref cause) => write!(f, "{}", cause),
UpdateFlowEntitlementError::Forbidden(ref cause) => write!(f, "{}", cause),
UpdateFlowEntitlementError::InternalServerError(ref cause) => write!(f, "{}", cause),
UpdateFlowEntitlementError::NotFound(ref cause) => write!(f, "{}", cause),
UpdateFlowEntitlementError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
UpdateFlowEntitlementError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateFlowEntitlementError {}
#[derive(Debug, PartialEq)]
pub enum UpdateFlowOutputError {
BadRequest(String),
Forbidden(String),
InternalServerError(String),
NotFound(String),
ServiceUnavailable(String),
TooManyRequests(String),
}
impl UpdateFlowOutputError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateFlowOutputError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(UpdateFlowOutputError::BadRequest(err.msg))
}
"ForbiddenException" => {
return RusotoError::Service(UpdateFlowOutputError::Forbidden(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(UpdateFlowOutputError::InternalServerError(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(UpdateFlowOutputError::NotFound(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(UpdateFlowOutputError::ServiceUnavailable(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(UpdateFlowOutputError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateFlowOutputError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateFlowOutputError::BadRequest(ref cause) => write!(f, "{}", cause),
UpdateFlowOutputError::Forbidden(ref cause) => write!(f, "{}", cause),
UpdateFlowOutputError::InternalServerError(ref cause) => write!(f, "{}", cause),
UpdateFlowOutputError::NotFound(ref cause) => write!(f, "{}", cause),
UpdateFlowOutputError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
UpdateFlowOutputError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateFlowOutputError {}
#[derive(Debug, PartialEq)]
pub enum UpdateFlowSourceError {
BadRequest(String),
Forbidden(String),
InternalServerError(String),
NotFound(String),
ServiceUnavailable(String),
TooManyRequests(String),
}
impl UpdateFlowSourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateFlowSourceError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(UpdateFlowSourceError::BadRequest(err.msg))
}
"ForbiddenException" => {
return RusotoError::Service(UpdateFlowSourceError::Forbidden(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(UpdateFlowSourceError::InternalServerError(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(UpdateFlowSourceError::NotFound(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(UpdateFlowSourceError::ServiceUnavailable(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(UpdateFlowSourceError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateFlowSourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateFlowSourceError::BadRequest(ref cause) => write!(f, "{}", cause),
UpdateFlowSourceError::Forbidden(ref cause) => write!(f, "{}", cause),
UpdateFlowSourceError::InternalServerError(ref cause) => write!(f, "{}", cause),
UpdateFlowSourceError::NotFound(ref cause) => write!(f, "{}", cause),
UpdateFlowSourceError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
UpdateFlowSourceError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateFlowSourceError {}
#[async_trait]
pub trait MediaConnect {
async fn add_flow_outputs(
&self,
input: AddFlowOutputsRequest,
) -> Result<AddFlowOutputsResponse, RusotoError<AddFlowOutputsError>>;
async fn add_flow_sources(
&self,
input: AddFlowSourcesRequest,
) -> Result<AddFlowSourcesResponse, RusotoError<AddFlowSourcesError>>;
async fn add_flow_vpc_interfaces(
&self,
input: AddFlowVpcInterfacesRequest,
) -> Result<AddFlowVpcInterfacesResponse, RusotoError<AddFlowVpcInterfacesError>>;
async fn create_flow(
&self,
input: CreateFlowRequest,
) -> Result<CreateFlowResponse, RusotoError<CreateFlowError>>;
async fn delete_flow(
&self,
input: DeleteFlowRequest,
) -> Result<DeleteFlowResponse, RusotoError<DeleteFlowError>>;
async fn describe_flow(
&self,
input: DescribeFlowRequest,
) -> Result<DescribeFlowResponse, RusotoError<DescribeFlowError>>;
async fn grant_flow_entitlements(
&self,
input: GrantFlowEntitlementsRequest,
) -> Result<GrantFlowEntitlementsResponse, RusotoError<GrantFlowEntitlementsError>>;
async fn list_entitlements(
&self,
input: ListEntitlementsRequest,
) -> Result<ListEntitlementsResponse, RusotoError<ListEntitlementsError>>;
async fn list_flows(
&self,
input: ListFlowsRequest,
) -> Result<ListFlowsResponse, RusotoError<ListFlowsError>>;
async fn list_tags_for_resource(
&self,
input: ListTagsForResourceRequest,
) -> Result<ListTagsForResourceResponse, RusotoError<ListTagsForResourceError>>;
async fn remove_flow_output(
&self,
input: RemoveFlowOutputRequest,
) -> Result<RemoveFlowOutputResponse, RusotoError<RemoveFlowOutputError>>;
async fn remove_flow_source(
&self,
input: RemoveFlowSourceRequest,
) -> Result<RemoveFlowSourceResponse, RusotoError<RemoveFlowSourceError>>;
async fn remove_flow_vpc_interface(
&self,
input: RemoveFlowVpcInterfaceRequest,
) -> Result<RemoveFlowVpcInterfaceResponse, RusotoError<RemoveFlowVpcInterfaceError>>;
async fn revoke_flow_entitlement(
&self,
input: RevokeFlowEntitlementRequest,
) -> Result<RevokeFlowEntitlementResponse, RusotoError<RevokeFlowEntitlementError>>;
async fn start_flow(
&self,
input: StartFlowRequest,
) -> Result<StartFlowResponse, RusotoError<StartFlowError>>;
async fn stop_flow(
&self,
input: StopFlowRequest,
) -> Result<StopFlowResponse, RusotoError<StopFlowError>>;
async fn tag_resource(
&self,
input: TagResourceRequest,
) -> Result<(), RusotoError<TagResourceError>>;
async fn untag_resource(
&self,
input: UntagResourceRequest,
) -> Result<(), RusotoError<UntagResourceError>>;
async fn update_flow(
&self,
input: UpdateFlowRequest,
) -> Result<UpdateFlowResponse, RusotoError<UpdateFlowError>>;
async fn update_flow_entitlement(
&self,
input: UpdateFlowEntitlementRequest,
) -> Result<UpdateFlowEntitlementResponse, RusotoError<UpdateFlowEntitlementError>>;
async fn update_flow_output(
&self,
input: UpdateFlowOutputRequest,
) -> Result<UpdateFlowOutputResponse, RusotoError<UpdateFlowOutputError>>;
async fn update_flow_source(
&self,
input: UpdateFlowSourceRequest,
) -> Result<UpdateFlowSourceResponse, RusotoError<UpdateFlowSourceError>>;
}
#[derive(Clone)]
pub struct MediaConnectClient {
client: Client,
region: region::Region,
}
impl MediaConnectClient {
pub fn new(region: region::Region) -> MediaConnectClient {
MediaConnectClient {
client: Client::shared(),
region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> MediaConnectClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
D: DispatchSignedRequest + Send + Sync + 'static,
{
MediaConnectClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region,
}
}
pub fn new_with_client(client: Client, region: region::Region) -> MediaConnectClient {
MediaConnectClient { client, region }
}
}
#[async_trait]
impl MediaConnect for MediaConnectClient {
#[allow(unused_mut)]
async fn add_flow_outputs(
&self,
input: AddFlowOutputsRequest,
) -> Result<AddFlowOutputsResponse, RusotoError<AddFlowOutputsError>> {
let request_uri = format!("/v1/flows/{flow_arn}/outputs", flow_arn = input.flow_arn);
let mut request = SignedRequest::new("POST", "mediaconnect", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 201 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<AddFlowOutputsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(AddFlowOutputsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn add_flow_sources(
&self,
input: AddFlowSourcesRequest,
) -> Result<AddFlowSourcesResponse, RusotoError<AddFlowSourcesError>> {
let request_uri = format!("/v1/flows/{flow_arn}/source", flow_arn = input.flow_arn);
let mut request = SignedRequest::new("POST", "mediaconnect", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 201 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<AddFlowSourcesResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(AddFlowSourcesError::from_response(response))
}
}
#[allow(unused_mut)]
async fn add_flow_vpc_interfaces(
&self,
input: AddFlowVpcInterfacesRequest,
) -> Result<AddFlowVpcInterfacesResponse, RusotoError<AddFlowVpcInterfacesError>> {
let request_uri = format!(
"/v1/flows/{flow_arn}/vpcInterfaces",
flow_arn = input.flow_arn
);
let mut request = SignedRequest::new("POST", "mediaconnect", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 201 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<AddFlowVpcInterfacesResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(AddFlowVpcInterfacesError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_flow(
&self,
input: CreateFlowRequest,
) -> Result<CreateFlowResponse, RusotoError<CreateFlowError>> {
let request_uri = "/v1/flows";
let mut request = SignedRequest::new("POST", "mediaconnect", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 201 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateFlowResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateFlowError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_flow(
&self,
input: DeleteFlowRequest,
) -> Result<DeleteFlowResponse, RusotoError<DeleteFlowError>> {
let request_uri = format!("/v1/flows/{flow_arn}", flow_arn = input.flow_arn);
let mut request = SignedRequest::new("DELETE", "mediaconnect", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 202 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteFlowResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteFlowError::from_response(response))
}
}
#[allow(unused_mut)]
async fn describe_flow(
&self,
input: DescribeFlowRequest,
) -> Result<DescribeFlowResponse, RusotoError<DescribeFlowError>> {
let request_uri = format!("/v1/flows/{flow_arn}", flow_arn = input.flow_arn);
let mut request = SignedRequest::new("GET", "mediaconnect", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeFlowResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DescribeFlowError::from_response(response))
}
}
#[allow(unused_mut)]
async fn grant_flow_entitlements(
&self,
input: GrantFlowEntitlementsRequest,
) -> Result<GrantFlowEntitlementsResponse, RusotoError<GrantFlowEntitlementsError>> {
let request_uri = format!(
"/v1/flows/{flow_arn}/entitlements",
flow_arn = input.flow_arn
);
let mut request = SignedRequest::new("POST", "mediaconnect", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GrantFlowEntitlementsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GrantFlowEntitlementsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_entitlements(
&self,
input: ListEntitlementsRequest,
) -> Result<ListEntitlementsResponse, RusotoError<ListEntitlementsError>> {
let request_uri = "/v1/entitlements";
let mut request = SignedRequest::new("GET", "mediaconnect", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("maxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("nextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListEntitlementsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListEntitlementsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_flows(
&self,
input: ListFlowsRequest,
) -> Result<ListFlowsResponse, RusotoError<ListFlowsError>> {
let request_uri = "/v1/flows";
let mut request = SignedRequest::new("GET", "mediaconnect", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("maxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("nextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListFlowsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListFlowsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_tags_for_resource(
&self,
input: ListTagsForResourceRequest,
) -> Result<ListTagsForResourceResponse, RusotoError<ListTagsForResourceError>> {
let request_uri = format!("/tags/{resource_arn}", resource_arn = input.resource_arn);
let mut request = SignedRequest::new("GET", "mediaconnect", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListTagsForResourceResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListTagsForResourceError::from_response(response))
}
}
#[allow(unused_mut)]
async fn remove_flow_output(
&self,
input: RemoveFlowOutputRequest,
) -> Result<RemoveFlowOutputResponse, RusotoError<RemoveFlowOutputError>> {
let request_uri = format!(
"/v1/flows/{flow_arn}/outputs/{output_arn}",
flow_arn = input.flow_arn,
output_arn = input.output_arn
);
let mut request = SignedRequest::new("DELETE", "mediaconnect", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 202 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<RemoveFlowOutputResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(RemoveFlowOutputError::from_response(response))
}
}
#[allow(unused_mut)]
async fn remove_flow_source(
&self,
input: RemoveFlowSourceRequest,
) -> Result<RemoveFlowSourceResponse, RusotoError<RemoveFlowSourceError>> {
let request_uri = format!(
"/v1/flows/{flow_arn}/source/{source_arn}",
flow_arn = input.flow_arn,
source_arn = input.source_arn
);
let mut request = SignedRequest::new("DELETE", "mediaconnect", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 202 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<RemoveFlowSourceResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(RemoveFlowSourceError::from_response(response))
}
}
#[allow(unused_mut)]
async fn remove_flow_vpc_interface(
&self,
input: RemoveFlowVpcInterfaceRequest,
) -> Result<RemoveFlowVpcInterfaceResponse, RusotoError<RemoveFlowVpcInterfaceError>> {
let request_uri = format!(
"/v1/flows/{flow_arn}/vpcInterfaces/{vpc_interface_name}",
flow_arn = input.flow_arn,
vpc_interface_name = input.vpc_interface_name
);
let mut request = SignedRequest::new("DELETE", "mediaconnect", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<RemoveFlowVpcInterfaceResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(RemoveFlowVpcInterfaceError::from_response(response))
}
}
#[allow(unused_mut)]
async fn revoke_flow_entitlement(
&self,
input: RevokeFlowEntitlementRequest,
) -> Result<RevokeFlowEntitlementResponse, RusotoError<RevokeFlowEntitlementError>> {
let request_uri = format!(
"/v1/flows/{flow_arn}/entitlements/{entitlement_arn}",
entitlement_arn = input.entitlement_arn,
flow_arn = input.flow_arn
);
let mut request = SignedRequest::new("DELETE", "mediaconnect", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 202 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<RevokeFlowEntitlementResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(RevokeFlowEntitlementError::from_response(response))
}
}
#[allow(unused_mut)]
async fn start_flow(
&self,
input: StartFlowRequest,
) -> Result<StartFlowResponse, RusotoError<StartFlowError>> {
let request_uri = format!("/v1/flows/start/{flow_arn}", flow_arn = input.flow_arn);
let mut request = SignedRequest::new("POST", "mediaconnect", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 202 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<StartFlowResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(StartFlowError::from_response(response))
}
}
#[allow(unused_mut)]
async fn stop_flow(
&self,
input: StopFlowRequest,
) -> Result<StopFlowResponse, RusotoError<StopFlowError>> {
let request_uri = format!("/v1/flows/stop/{flow_arn}", flow_arn = input.flow_arn);
let mut request = SignedRequest::new("POST", "mediaconnect", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 202 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<StopFlowResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(StopFlowError::from_response(response))
}
}
#[allow(unused_mut)]
async fn tag_resource(
&self,
input: TagResourceRequest,
) -> Result<(), RusotoError<TagResourceError>> {
let request_uri = format!("/tags/{resource_arn}", resource_arn = input.resource_arn);
let mut request = SignedRequest::new("POST", "mediaconnect", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 204 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = ::std::mem::drop(response);
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(TagResourceError::from_response(response))
}
}
#[allow(unused_mut)]
async fn untag_resource(
&self,
input: UntagResourceRequest,
) -> Result<(), RusotoError<UntagResourceError>> {
let request_uri = format!("/tags/{resource_arn}", resource_arn = input.resource_arn);
let mut request = SignedRequest::new("DELETE", "mediaconnect", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
for item in input.tag_keys.iter() {
params.put("tagKeys", item);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 204 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = ::std::mem::drop(response);
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UntagResourceError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_flow(
&self,
input: UpdateFlowRequest,
) -> Result<UpdateFlowResponse, RusotoError<UpdateFlowError>> {
let request_uri = format!("/v1/flows/{flow_arn}", flow_arn = input.flow_arn);
let mut request = SignedRequest::new("PUT", "mediaconnect", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 202 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateFlowResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateFlowError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_flow_entitlement(
&self,
input: UpdateFlowEntitlementRequest,
) -> Result<UpdateFlowEntitlementResponse, RusotoError<UpdateFlowEntitlementError>> {
let request_uri = format!(
"/v1/flows/{flow_arn}/entitlements/{entitlement_arn}",
entitlement_arn = input.entitlement_arn,
flow_arn = input.flow_arn
);
let mut request = SignedRequest::new("PUT", "mediaconnect", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 202 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateFlowEntitlementResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateFlowEntitlementError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_flow_output(
&self,
input: UpdateFlowOutputRequest,
) -> Result<UpdateFlowOutputResponse, RusotoError<UpdateFlowOutputError>> {
let request_uri = format!(
"/v1/flows/{flow_arn}/outputs/{output_arn}",
flow_arn = input.flow_arn,
output_arn = input.output_arn
);
let mut request = SignedRequest::new("PUT", "mediaconnect", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 202 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateFlowOutputResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateFlowOutputError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_flow_source(
&self,
input: UpdateFlowSourceRequest,
) -> Result<UpdateFlowSourceResponse, RusotoError<UpdateFlowSourceError>> {
let request_uri = format!(
"/v1/flows/{flow_arn}/source/{source_arn}",
flow_arn = input.flow_arn,
source_arn = input.source_arn
);
let mut request = SignedRequest::new("PUT", "mediaconnect", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 202 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateFlowSourceResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateFlowSourceError::from_response(response))
}
}
}