use std::error::Error;
use std::fmt;
use async_trait::async_trait;
use rusoto_core::credential::ProvideAwsCredentials;
use rusoto_core::region;
use rusoto_core::request::{BufferedHttpResponse, DispatchSignedRequest};
use rusoto_core::{Client, RusotoError};
use rusoto_core::param::{Params, ServiceParams};
use rusoto_core::proto;
use rusoto_core::signature::SignedRequest;
#[allow(unused_imports)]
use serde::{Deserialize, Serialize};
use serde_json;
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AntennaDemodDecodeDetails {
#[serde(rename = "outputNode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub output_node: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct AntennaDownlinkConfig {
#[serde(rename = "spectrumConfig")]
pub spectrum_config: SpectrumConfig,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct AntennaDownlinkDemodDecodeConfig {
#[serde(rename = "decodeConfig")]
pub decode_config: DecodeConfig,
#[serde(rename = "demodulationConfig")]
pub demodulation_config: DemodulationConfig,
#[serde(rename = "spectrumConfig")]
pub spectrum_config: SpectrumConfig,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct AntennaUplinkConfig {
#[serde(rename = "spectrumConfig")]
pub spectrum_config: UplinkSpectrumConfig,
#[serde(rename = "targetEirp")]
pub target_eirp: Eirp,
#[serde(rename = "transmitDisabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub transmit_disabled: Option<bool>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CancelContactRequest {
#[serde(rename = "contactId")]
pub contact_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ConfigDetails {
#[serde(rename = "antennaDemodDecodeDetails")]
#[serde(skip_serializing_if = "Option::is_none")]
pub antenna_demod_decode_details: Option<AntennaDemodDecodeDetails>,
#[serde(rename = "endpointDetails")]
#[serde(skip_serializing_if = "Option::is_none")]
pub endpoint_details: Option<EndpointDetails>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ConfigIdResponse {
#[serde(rename = "configArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub config_arn: Option<String>,
#[serde(rename = "configId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub config_id: Option<String>,
#[serde(rename = "configType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub config_type: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ConfigListItem {
#[serde(rename = "configArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub config_arn: Option<String>,
#[serde(rename = "configId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub config_id: Option<String>,
#[serde(rename = "configType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub config_type: Option<String>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ConfigTypeData {
#[serde(rename = "antennaDownlinkConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub antenna_downlink_config: Option<AntennaDownlinkConfig>,
#[serde(rename = "antennaDownlinkDemodDecodeConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub antenna_downlink_demod_decode_config: Option<AntennaDownlinkDemodDecodeConfig>,
#[serde(rename = "antennaUplinkConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub antenna_uplink_config: Option<AntennaUplinkConfig>,
#[serde(rename = "dataflowEndpointConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dataflow_endpoint_config: Option<DataflowEndpointConfig>,
#[serde(rename = "trackingConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tracking_config: Option<TrackingConfig>,
#[serde(rename = "uplinkEchoConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub uplink_echo_config: Option<UplinkEchoConfig>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ContactData {
#[serde(rename = "contactId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub contact_id: Option<String>,
#[serde(rename = "contactStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub contact_status: Option<String>,
#[serde(rename = "endTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub end_time: Option<f64>,
#[serde(rename = "errorMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_message: Option<String>,
#[serde(rename = "groundStation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ground_station: Option<String>,
#[serde(rename = "maximumElevation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub maximum_elevation: Option<Elevation>,
#[serde(rename = "missionProfileArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub mission_profile_arn: Option<String>,
#[serde(rename = "postPassEndTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub post_pass_end_time: Option<f64>,
#[serde(rename = "prePassStartTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pre_pass_start_time: Option<f64>,
#[serde(rename = "region")]
#[serde(skip_serializing_if = "Option::is_none")]
pub region: Option<String>,
#[serde(rename = "satelliteArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub satellite_arn: Option<String>,
#[serde(rename = "startTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub start_time: Option<f64>,
#[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 ContactIdResponse {
#[serde(rename = "contactId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub contact_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateConfigRequest {
#[serde(rename = "configData")]
pub config_data: ConfigTypeData,
#[serde(rename = "name")]
pub name: String,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateDataflowEndpointGroupRequest {
#[serde(rename = "endpointDetails")]
pub endpoint_details: Vec<EndpointDetails>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateMissionProfileRequest {
#[serde(rename = "contactPostPassDurationSeconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub contact_post_pass_duration_seconds: Option<i64>,
#[serde(rename = "contactPrePassDurationSeconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub contact_pre_pass_duration_seconds: Option<i64>,
#[serde(rename = "dataflowEdges")]
pub dataflow_edges: Vec<Vec<String>>,
#[serde(rename = "minimumViableContactDurationSeconds")]
pub minimum_viable_contact_duration_seconds: i64,
#[serde(rename = "name")]
pub name: String,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "trackingConfigArn")]
pub tracking_config_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DataflowDetail {
#[serde(rename = "destination")]
#[serde(skip_serializing_if = "Option::is_none")]
pub destination: Option<Destination>,
#[serde(rename = "errorMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_message: Option<String>,
#[serde(rename = "source")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source: Option<Source>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct DataflowEndpoint {
#[serde(rename = "address")]
#[serde(skip_serializing_if = "Option::is_none")]
pub address: Option<SocketAddress>,
#[serde(rename = "mtu")]
#[serde(skip_serializing_if = "Option::is_none")]
pub mtu: Option<i64>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct DataflowEndpointConfig {
#[serde(rename = "dataflowEndpointName")]
pub dataflow_endpoint_name: String,
#[serde(rename = "dataflowEndpointRegion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dataflow_endpoint_region: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DataflowEndpointGroupIdResponse {
#[serde(rename = "dataflowEndpointGroupId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dataflow_endpoint_group_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DataflowEndpointListItem {
#[serde(rename = "dataflowEndpointGroupArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dataflow_endpoint_group_arn: Option<String>,
#[serde(rename = "dataflowEndpointGroupId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dataflow_endpoint_group_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct DecodeConfig {
#[serde(rename = "unvalidatedJSON")]
pub unvalidated_json: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteConfigRequest {
#[serde(rename = "configId")]
pub config_id: String,
#[serde(rename = "configType")]
pub config_type: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteDataflowEndpointGroupRequest {
#[serde(rename = "dataflowEndpointGroupId")]
pub dataflow_endpoint_group_id: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteMissionProfileRequest {
#[serde(rename = "missionProfileId")]
pub mission_profile_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct DemodulationConfig {
#[serde(rename = "unvalidatedJSON")]
pub unvalidated_json: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeContactRequest {
#[serde(rename = "contactId")]
pub contact_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeContactResponse {
#[serde(rename = "contactId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub contact_id: Option<String>,
#[serde(rename = "contactStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub contact_status: Option<String>,
#[serde(rename = "dataflowList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dataflow_list: Option<Vec<DataflowDetail>>,
#[serde(rename = "endTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub end_time: Option<f64>,
#[serde(rename = "errorMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_message: Option<String>,
#[serde(rename = "groundStation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ground_station: Option<String>,
#[serde(rename = "maximumElevation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub maximum_elevation: Option<Elevation>,
#[serde(rename = "missionProfileArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub mission_profile_arn: Option<String>,
#[serde(rename = "postPassEndTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub post_pass_end_time: Option<f64>,
#[serde(rename = "prePassStartTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pre_pass_start_time: Option<f64>,
#[serde(rename = "region")]
#[serde(skip_serializing_if = "Option::is_none")]
pub region: Option<String>,
#[serde(rename = "satelliteArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub satellite_arn: Option<String>,
#[serde(rename = "startTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub start_time: Option<f64>,
#[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 Destination {
#[serde(rename = "configDetails")]
#[serde(skip_serializing_if = "Option::is_none")]
pub config_details: Option<ConfigDetails>,
#[serde(rename = "configId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub config_id: Option<String>,
#[serde(rename = "configType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub config_type: Option<String>,
#[serde(rename = "dataflowDestinationRegion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dataflow_destination_region: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct Eirp {
#[serde(rename = "units")]
pub units: String,
#[serde(rename = "value")]
pub value: f64,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Elevation {
#[serde(rename = "unit")]
pub unit: String,
#[serde(rename = "value")]
pub value: f64,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct EndpointDetails {
#[serde(rename = "endpoint")]
#[serde(skip_serializing_if = "Option::is_none")]
pub endpoint: Option<DataflowEndpoint>,
#[serde(rename = "securityDetails")]
#[serde(skip_serializing_if = "Option::is_none")]
pub security_details: Option<SecurityDetails>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct Frequency {
#[serde(rename = "units")]
pub units: String,
#[serde(rename = "value")]
pub value: f64,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct FrequencyBandwidth {
#[serde(rename = "units")]
pub units: String,
#[serde(rename = "value")]
pub value: f64,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetConfigRequest {
#[serde(rename = "configId")]
pub config_id: String,
#[serde(rename = "configType")]
pub config_type: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetConfigResponse {
#[serde(rename = "configArn")]
pub config_arn: String,
#[serde(rename = "configData")]
pub config_data: ConfigTypeData,
#[serde(rename = "configId")]
pub config_id: String,
#[serde(rename = "configType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub config_type: Option<String>,
#[serde(rename = "name")]
pub name: String,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetDataflowEndpointGroupRequest {
#[serde(rename = "dataflowEndpointGroupId")]
pub dataflow_endpoint_group_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetDataflowEndpointGroupResponse {
#[serde(rename = "dataflowEndpointGroupArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dataflow_endpoint_group_arn: Option<String>,
#[serde(rename = "dataflowEndpointGroupId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dataflow_endpoint_group_id: Option<String>,
#[serde(rename = "endpointsDetails")]
#[serde(skip_serializing_if = "Option::is_none")]
pub endpoints_details: Option<Vec<EndpointDetails>>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetMinuteUsageRequest {
#[serde(rename = "month")]
pub month: i64,
#[serde(rename = "year")]
pub year: i64,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetMinuteUsageResponse {
#[serde(rename = "estimatedMinutesRemaining")]
#[serde(skip_serializing_if = "Option::is_none")]
pub estimated_minutes_remaining: Option<i64>,
#[serde(rename = "isReservedMinutesCustomer")]
#[serde(skip_serializing_if = "Option::is_none")]
pub is_reserved_minutes_customer: Option<bool>,
#[serde(rename = "totalReservedMinuteAllocation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub total_reserved_minute_allocation: Option<i64>,
#[serde(rename = "totalScheduledMinutes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub total_scheduled_minutes: Option<i64>,
#[serde(rename = "upcomingMinutesScheduled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub upcoming_minutes_scheduled: Option<i64>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetMissionProfileRequest {
#[serde(rename = "missionProfileId")]
pub mission_profile_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetMissionProfileResponse {
#[serde(rename = "contactPostPassDurationSeconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub contact_post_pass_duration_seconds: Option<i64>,
#[serde(rename = "contactPrePassDurationSeconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub contact_pre_pass_duration_seconds: Option<i64>,
#[serde(rename = "dataflowEdges")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dataflow_edges: Option<Vec<Vec<String>>>,
#[serde(rename = "minimumViableContactDurationSeconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub minimum_viable_contact_duration_seconds: Option<i64>,
#[serde(rename = "missionProfileArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub mission_profile_arn: Option<String>,
#[serde(rename = "missionProfileId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub mission_profile_id: Option<String>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "region")]
#[serde(skip_serializing_if = "Option::is_none")]
pub region: Option<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "trackingConfigArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tracking_config_arn: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetSatelliteRequest {
#[serde(rename = "satelliteId")]
pub satellite_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetSatelliteResponse {
#[serde(rename = "groundStations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ground_stations: Option<Vec<String>>,
#[serde(rename = "noradSatelliteID")]
#[serde(skip_serializing_if = "Option::is_none")]
pub norad_satellite_id: Option<i64>,
#[serde(rename = "satelliteArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub satellite_arn: Option<String>,
#[serde(rename = "satelliteId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub satellite_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GroundStationData {
#[serde(rename = "groundStationId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ground_station_id: Option<String>,
#[serde(rename = "groundStationName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ground_station_name: Option<String>,
#[serde(rename = "region")]
#[serde(skip_serializing_if = "Option::is_none")]
pub region: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListConfigsRequest {
#[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 ListConfigsResponse {
#[serde(rename = "configList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub config_list: Option<Vec<ConfigListItem>>,
#[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 ListContactsRequest {
#[serde(rename = "endTime")]
pub end_time: f64,
#[serde(rename = "groundStation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ground_station: Option<String>,
#[serde(rename = "maxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "missionProfileArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub mission_profile_arn: Option<String>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "satelliteArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub satellite_arn: Option<String>,
#[serde(rename = "startTime")]
pub start_time: f64,
#[serde(rename = "statusList")]
pub status_list: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListContactsResponse {
#[serde(rename = "contactList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub contact_list: Option<Vec<ContactData>>,
#[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 ListDataflowEndpointGroupsRequest {
#[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 ListDataflowEndpointGroupsResponse {
#[serde(rename = "dataflowEndpointGroupList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dataflow_endpoint_group_list: Option<Vec<DataflowEndpointListItem>>,
#[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 ListGroundStationsRequest {
#[serde(rename = "maxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "satelliteId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub satellite_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListGroundStationsResponse {
#[serde(rename = "groundStationList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ground_station_list: Option<Vec<GroundStationData>>,
#[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 ListMissionProfilesRequest {
#[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 ListMissionProfilesResponse {
#[serde(rename = "missionProfileList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub mission_profile_list: Option<Vec<MissionProfileListItem>>,
#[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 ListSatellitesRequest {
#[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 ListSatellitesResponse {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "satellites")]
#[serde(skip_serializing_if = "Option::is_none")]
pub satellites: Option<Vec<SatelliteListItem>>,
}
#[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 MissionProfileIdResponse {
#[serde(rename = "missionProfileId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub mission_profile_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct MissionProfileListItem {
#[serde(rename = "missionProfileArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub mission_profile_arn: Option<String>,
#[serde(rename = "missionProfileId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub mission_profile_id: Option<String>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "region")]
#[serde(skip_serializing_if = "Option::is_none")]
pub region: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ReserveContactRequest {
#[serde(rename = "endTime")]
pub end_time: f64,
#[serde(rename = "groundStation")]
pub ground_station: String,
#[serde(rename = "missionProfileArn")]
pub mission_profile_arn: String,
#[serde(rename = "satelliteArn")]
pub satellite_arn: String,
#[serde(rename = "startTime")]
pub start_time: f64,
#[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 SatelliteListItem {
#[serde(rename = "groundStations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ground_stations: Option<Vec<String>>,
#[serde(rename = "noradSatelliteID")]
#[serde(skip_serializing_if = "Option::is_none")]
pub norad_satellite_id: Option<i64>,
#[serde(rename = "satelliteArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub satellite_arn: Option<String>,
#[serde(rename = "satelliteId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub satellite_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct SecurityDetails {
#[serde(rename = "roleArn")]
pub role_arn: String,
#[serde(rename = "securityGroupIds")]
pub security_group_ids: Vec<String>,
#[serde(rename = "subnetIds")]
pub subnet_ids: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct SocketAddress {
#[serde(rename = "name")]
pub name: String,
#[serde(rename = "port")]
pub port: i64,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Source {
#[serde(rename = "configDetails")]
#[serde(skip_serializing_if = "Option::is_none")]
pub config_details: Option<ConfigDetails>,
#[serde(rename = "configId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub config_id: Option<String>,
#[serde(rename = "configType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub config_type: Option<String>,
#[serde(rename = "dataflowSourceRegion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dataflow_source_region: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct SpectrumConfig {
#[serde(rename = "bandwidth")]
pub bandwidth: FrequencyBandwidth,
#[serde(rename = "centerFrequency")]
pub center_frequency: Frequency,
#[serde(rename = "polarization")]
#[serde(skip_serializing_if = "Option::is_none")]
pub polarization: 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 TagResourceResponse {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct TrackingConfig {
#[serde(rename = "autotrack")]
pub autotrack: 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, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UntagResourceResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateConfigRequest {
#[serde(rename = "configData")]
pub config_data: ConfigTypeData,
#[serde(rename = "configId")]
pub config_id: String,
#[serde(rename = "configType")]
pub config_type: String,
#[serde(rename = "name")]
pub name: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateMissionProfileRequest {
#[serde(rename = "contactPostPassDurationSeconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub contact_post_pass_duration_seconds: Option<i64>,
#[serde(rename = "contactPrePassDurationSeconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub contact_pre_pass_duration_seconds: Option<i64>,
#[serde(rename = "dataflowEdges")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dataflow_edges: Option<Vec<Vec<String>>>,
#[serde(rename = "minimumViableContactDurationSeconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub minimum_viable_contact_duration_seconds: Option<i64>,
#[serde(rename = "missionProfileId")]
pub mission_profile_id: String,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "trackingConfigArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tracking_config_arn: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct UplinkEchoConfig {
#[serde(rename = "antennaUplinkConfigArn")]
pub antenna_uplink_config_arn: String,
#[serde(rename = "enabled")]
pub enabled: bool,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct UplinkSpectrumConfig {
#[serde(rename = "centerFrequency")]
pub center_frequency: Frequency,
#[serde(rename = "polarization")]
#[serde(skip_serializing_if = "Option::is_none")]
pub polarization: Option<String>,
}
#[derive(Debug, PartialEq)]
pub enum CancelContactError {
Dependency(String),
InvalidParameter(String),
ResourceNotFound(String),
}
impl CancelContactError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CancelContactError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"DependencyException" => {
return RusotoError::Service(CancelContactError::Dependency(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(CancelContactError::InvalidParameter(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(CancelContactError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CancelContactError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CancelContactError::Dependency(ref cause) => write!(f, "{}", cause),
CancelContactError::InvalidParameter(ref cause) => write!(f, "{}", cause),
CancelContactError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CancelContactError {}
#[derive(Debug, PartialEq)]
pub enum CreateConfigError {
Dependency(String),
InvalidParameter(String),
ResourceLimitExceeded(String),
ResourceNotFound(String),
}
impl CreateConfigError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateConfigError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"DependencyException" => {
return RusotoError::Service(CreateConfigError::Dependency(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(CreateConfigError::InvalidParameter(err.msg))
}
"ResourceLimitExceededException" => {
return RusotoError::Service(CreateConfigError::ResourceLimitExceeded(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(CreateConfigError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateConfigError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateConfigError::Dependency(ref cause) => write!(f, "{}", cause),
CreateConfigError::InvalidParameter(ref cause) => write!(f, "{}", cause),
CreateConfigError::ResourceLimitExceeded(ref cause) => write!(f, "{}", cause),
CreateConfigError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateConfigError {}
#[derive(Debug, PartialEq)]
pub enum CreateDataflowEndpointGroupError {
Dependency(String),
InvalidParameter(String),
ResourceNotFound(String),
}
impl CreateDataflowEndpointGroupError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<CreateDataflowEndpointGroupError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"DependencyException" => {
return RusotoError::Service(CreateDataflowEndpointGroupError::Dependency(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(
CreateDataflowEndpointGroupError::InvalidParameter(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
CreateDataflowEndpointGroupError::ResourceNotFound(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateDataflowEndpointGroupError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateDataflowEndpointGroupError::Dependency(ref cause) => write!(f, "{}", cause),
CreateDataflowEndpointGroupError::InvalidParameter(ref cause) => write!(f, "{}", cause),
CreateDataflowEndpointGroupError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateDataflowEndpointGroupError {}
#[derive(Debug, PartialEq)]
pub enum CreateMissionProfileError {
Dependency(String),
InvalidParameter(String),
ResourceNotFound(String),
}
impl CreateMissionProfileError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateMissionProfileError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"DependencyException" => {
return RusotoError::Service(CreateMissionProfileError::Dependency(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(CreateMissionProfileError::InvalidParameter(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(CreateMissionProfileError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateMissionProfileError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateMissionProfileError::Dependency(ref cause) => write!(f, "{}", cause),
CreateMissionProfileError::InvalidParameter(ref cause) => write!(f, "{}", cause),
CreateMissionProfileError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateMissionProfileError {}
#[derive(Debug, PartialEq)]
pub enum DeleteConfigError {
Dependency(String),
InvalidParameter(String),
ResourceNotFound(String),
}
impl DeleteConfigError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteConfigError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"DependencyException" => {
return RusotoError::Service(DeleteConfigError::Dependency(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(DeleteConfigError::InvalidParameter(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DeleteConfigError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteConfigError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteConfigError::Dependency(ref cause) => write!(f, "{}", cause),
DeleteConfigError::InvalidParameter(ref cause) => write!(f, "{}", cause),
DeleteConfigError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteConfigError {}
#[derive(Debug, PartialEq)]
pub enum DeleteDataflowEndpointGroupError {
Dependency(String),
InvalidParameter(String),
ResourceNotFound(String),
}
impl DeleteDataflowEndpointGroupError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DeleteDataflowEndpointGroupError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"DependencyException" => {
return RusotoError::Service(DeleteDataflowEndpointGroupError::Dependency(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(
DeleteDataflowEndpointGroupError::InvalidParameter(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
DeleteDataflowEndpointGroupError::ResourceNotFound(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteDataflowEndpointGroupError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteDataflowEndpointGroupError::Dependency(ref cause) => write!(f, "{}", cause),
DeleteDataflowEndpointGroupError::InvalidParameter(ref cause) => write!(f, "{}", cause),
DeleteDataflowEndpointGroupError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteDataflowEndpointGroupError {}
#[derive(Debug, PartialEq)]
pub enum DeleteMissionProfileError {
Dependency(String),
InvalidParameter(String),
ResourceNotFound(String),
}
impl DeleteMissionProfileError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteMissionProfileError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"DependencyException" => {
return RusotoError::Service(DeleteMissionProfileError::Dependency(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(DeleteMissionProfileError::InvalidParameter(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DeleteMissionProfileError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteMissionProfileError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteMissionProfileError::Dependency(ref cause) => write!(f, "{}", cause),
DeleteMissionProfileError::InvalidParameter(ref cause) => write!(f, "{}", cause),
DeleteMissionProfileError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteMissionProfileError {}
#[derive(Debug, PartialEq)]
pub enum DescribeContactError {
Dependency(String),
InvalidParameter(String),
ResourceNotFound(String),
}
impl DescribeContactError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeContactError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"DependencyException" => {
return RusotoError::Service(DescribeContactError::Dependency(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(DescribeContactError::InvalidParameter(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeContactError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeContactError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeContactError::Dependency(ref cause) => write!(f, "{}", cause),
DescribeContactError::InvalidParameter(ref cause) => write!(f, "{}", cause),
DescribeContactError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeContactError {}
#[derive(Debug, PartialEq)]
pub enum GetConfigError {
Dependency(String),
InvalidParameter(String),
ResourceNotFound(String),
}
impl GetConfigError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetConfigError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"DependencyException" => {
return RusotoError::Service(GetConfigError::Dependency(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(GetConfigError::InvalidParameter(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(GetConfigError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetConfigError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetConfigError::Dependency(ref cause) => write!(f, "{}", cause),
GetConfigError::InvalidParameter(ref cause) => write!(f, "{}", cause),
GetConfigError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetConfigError {}
#[derive(Debug, PartialEq)]
pub enum GetDataflowEndpointGroupError {
Dependency(String),
InvalidParameter(String),
ResourceNotFound(String),
}
impl GetDataflowEndpointGroupError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetDataflowEndpointGroupError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"DependencyException" => {
return RusotoError::Service(GetDataflowEndpointGroupError::Dependency(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(GetDataflowEndpointGroupError::InvalidParameter(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(GetDataflowEndpointGroupError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetDataflowEndpointGroupError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetDataflowEndpointGroupError::Dependency(ref cause) => write!(f, "{}", cause),
GetDataflowEndpointGroupError::InvalidParameter(ref cause) => write!(f, "{}", cause),
GetDataflowEndpointGroupError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetDataflowEndpointGroupError {}
#[derive(Debug, PartialEq)]
pub enum GetMinuteUsageError {
Dependency(String),
InvalidParameter(String),
ResourceNotFound(String),
}
impl GetMinuteUsageError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetMinuteUsageError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"DependencyException" => {
return RusotoError::Service(GetMinuteUsageError::Dependency(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(GetMinuteUsageError::InvalidParameter(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(GetMinuteUsageError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetMinuteUsageError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetMinuteUsageError::Dependency(ref cause) => write!(f, "{}", cause),
GetMinuteUsageError::InvalidParameter(ref cause) => write!(f, "{}", cause),
GetMinuteUsageError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetMinuteUsageError {}
#[derive(Debug, PartialEq)]
pub enum GetMissionProfileError {
Dependency(String),
InvalidParameter(String),
ResourceNotFound(String),
}
impl GetMissionProfileError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetMissionProfileError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"DependencyException" => {
return RusotoError::Service(GetMissionProfileError::Dependency(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(GetMissionProfileError::InvalidParameter(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(GetMissionProfileError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetMissionProfileError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetMissionProfileError::Dependency(ref cause) => write!(f, "{}", cause),
GetMissionProfileError::InvalidParameter(ref cause) => write!(f, "{}", cause),
GetMissionProfileError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetMissionProfileError {}
#[derive(Debug, PartialEq)]
pub enum GetSatelliteError {
Dependency(String),
InvalidParameter(String),
ResourceNotFound(String),
}
impl GetSatelliteError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetSatelliteError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"DependencyException" => {
return RusotoError::Service(GetSatelliteError::Dependency(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(GetSatelliteError::InvalidParameter(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(GetSatelliteError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetSatelliteError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetSatelliteError::Dependency(ref cause) => write!(f, "{}", cause),
GetSatelliteError::InvalidParameter(ref cause) => write!(f, "{}", cause),
GetSatelliteError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetSatelliteError {}
#[derive(Debug, PartialEq)]
pub enum ListConfigsError {
Dependency(String),
InvalidParameter(String),
ResourceNotFound(String),
}
impl ListConfigsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListConfigsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"DependencyException" => {
return RusotoError::Service(ListConfigsError::Dependency(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(ListConfigsError::InvalidParameter(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListConfigsError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListConfigsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListConfigsError::Dependency(ref cause) => write!(f, "{}", cause),
ListConfigsError::InvalidParameter(ref cause) => write!(f, "{}", cause),
ListConfigsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListConfigsError {}
#[derive(Debug, PartialEq)]
pub enum ListContactsError {
Dependency(String),
InvalidParameter(String),
ResourceNotFound(String),
}
impl ListContactsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListContactsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"DependencyException" => {
return RusotoError::Service(ListContactsError::Dependency(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(ListContactsError::InvalidParameter(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListContactsError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListContactsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListContactsError::Dependency(ref cause) => write!(f, "{}", cause),
ListContactsError::InvalidParameter(ref cause) => write!(f, "{}", cause),
ListContactsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListContactsError {}
#[derive(Debug, PartialEq)]
pub enum ListDataflowEndpointGroupsError {
Dependency(String),
InvalidParameter(String),
ResourceNotFound(String),
}
impl ListDataflowEndpointGroupsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListDataflowEndpointGroupsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"DependencyException" => {
return RusotoError::Service(ListDataflowEndpointGroupsError::Dependency(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(ListDataflowEndpointGroupsError::InvalidParameter(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListDataflowEndpointGroupsError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListDataflowEndpointGroupsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListDataflowEndpointGroupsError::Dependency(ref cause) => write!(f, "{}", cause),
ListDataflowEndpointGroupsError::InvalidParameter(ref cause) => write!(f, "{}", cause),
ListDataflowEndpointGroupsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListDataflowEndpointGroupsError {}
#[derive(Debug, PartialEq)]
pub enum ListGroundStationsError {
Dependency(String),
InvalidParameter(String),
ResourceNotFound(String),
}
impl ListGroundStationsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListGroundStationsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"DependencyException" => {
return RusotoError::Service(ListGroundStationsError::Dependency(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(ListGroundStationsError::InvalidParameter(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListGroundStationsError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListGroundStationsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListGroundStationsError::Dependency(ref cause) => write!(f, "{}", cause),
ListGroundStationsError::InvalidParameter(ref cause) => write!(f, "{}", cause),
ListGroundStationsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListGroundStationsError {}
#[derive(Debug, PartialEq)]
pub enum ListMissionProfilesError {
Dependency(String),
InvalidParameter(String),
ResourceNotFound(String),
}
impl ListMissionProfilesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListMissionProfilesError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"DependencyException" => {
return RusotoError::Service(ListMissionProfilesError::Dependency(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(ListMissionProfilesError::InvalidParameter(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListMissionProfilesError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListMissionProfilesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListMissionProfilesError::Dependency(ref cause) => write!(f, "{}", cause),
ListMissionProfilesError::InvalidParameter(ref cause) => write!(f, "{}", cause),
ListMissionProfilesError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListMissionProfilesError {}
#[derive(Debug, PartialEq)]
pub enum ListSatellitesError {
Dependency(String),
InvalidParameter(String),
ResourceNotFound(String),
}
impl ListSatellitesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListSatellitesError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"DependencyException" => {
return RusotoError::Service(ListSatellitesError::Dependency(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(ListSatellitesError::InvalidParameter(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListSatellitesError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListSatellitesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListSatellitesError::Dependency(ref cause) => write!(f, "{}", cause),
ListSatellitesError::InvalidParameter(ref cause) => write!(f, "{}", cause),
ListSatellitesError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListSatellitesError {}
#[derive(Debug, PartialEq)]
pub enum ListTagsForResourceError {
Dependency(String),
InvalidParameter(String),
ResourceNotFound(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() {
"DependencyException" => {
return RusotoError::Service(ListTagsForResourceError::Dependency(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(ListTagsForResourceError::InvalidParameter(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListTagsForResourceError::ResourceNotFound(
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::Dependency(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::InvalidParameter(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListTagsForResourceError {}
#[derive(Debug, PartialEq)]
pub enum ReserveContactError {
Dependency(String),
InvalidParameter(String),
ResourceNotFound(String),
}
impl ReserveContactError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ReserveContactError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"DependencyException" => {
return RusotoError::Service(ReserveContactError::Dependency(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(ReserveContactError::InvalidParameter(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ReserveContactError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ReserveContactError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ReserveContactError::Dependency(ref cause) => write!(f, "{}", cause),
ReserveContactError::InvalidParameter(ref cause) => write!(f, "{}", cause),
ReserveContactError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ReserveContactError {}
#[derive(Debug, PartialEq)]
pub enum TagResourceError {
Dependency(String),
InvalidParameter(String),
ResourceNotFound(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() {
"DependencyException" => {
return RusotoError::Service(TagResourceError::Dependency(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(TagResourceError::InvalidParameter(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(TagResourceError::ResourceNotFound(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::Dependency(ref cause) => write!(f, "{}", cause),
TagResourceError::InvalidParameter(ref cause) => write!(f, "{}", cause),
TagResourceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for TagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UntagResourceError {
Dependency(String),
InvalidParameter(String),
ResourceNotFound(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() {
"DependencyException" => {
return RusotoError::Service(UntagResourceError::Dependency(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(UntagResourceError::InvalidParameter(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UntagResourceError::ResourceNotFound(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::Dependency(ref cause) => write!(f, "{}", cause),
UntagResourceError::InvalidParameter(ref cause) => write!(f, "{}", cause),
UntagResourceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UntagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UpdateConfigError {
Dependency(String),
InvalidParameter(String),
ResourceNotFound(String),
}
impl UpdateConfigError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateConfigError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"DependencyException" => {
return RusotoError::Service(UpdateConfigError::Dependency(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(UpdateConfigError::InvalidParameter(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UpdateConfigError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateConfigError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateConfigError::Dependency(ref cause) => write!(f, "{}", cause),
UpdateConfigError::InvalidParameter(ref cause) => write!(f, "{}", cause),
UpdateConfigError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateConfigError {}
#[derive(Debug, PartialEq)]
pub enum UpdateMissionProfileError {
Dependency(String),
InvalidParameter(String),
ResourceNotFound(String),
}
impl UpdateMissionProfileError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateMissionProfileError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"DependencyException" => {
return RusotoError::Service(UpdateMissionProfileError::Dependency(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(UpdateMissionProfileError::InvalidParameter(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UpdateMissionProfileError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateMissionProfileError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateMissionProfileError::Dependency(ref cause) => write!(f, "{}", cause),
UpdateMissionProfileError::InvalidParameter(ref cause) => write!(f, "{}", cause),
UpdateMissionProfileError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateMissionProfileError {}
#[async_trait]
pub trait GroundStation {
async fn cancel_contact(
&self,
input: CancelContactRequest,
) -> Result<ContactIdResponse, RusotoError<CancelContactError>>;
async fn create_config(
&self,
input: CreateConfigRequest,
) -> Result<ConfigIdResponse, RusotoError<CreateConfigError>>;
async fn create_dataflow_endpoint_group(
&self,
input: CreateDataflowEndpointGroupRequest,
) -> Result<DataflowEndpointGroupIdResponse, RusotoError<CreateDataflowEndpointGroupError>>;
async fn create_mission_profile(
&self,
input: CreateMissionProfileRequest,
) -> Result<MissionProfileIdResponse, RusotoError<CreateMissionProfileError>>;
async fn delete_config(
&self,
input: DeleteConfigRequest,
) -> Result<ConfigIdResponse, RusotoError<DeleteConfigError>>;
async fn delete_dataflow_endpoint_group(
&self,
input: DeleteDataflowEndpointGroupRequest,
) -> Result<DataflowEndpointGroupIdResponse, RusotoError<DeleteDataflowEndpointGroupError>>;
async fn delete_mission_profile(
&self,
input: DeleteMissionProfileRequest,
) -> Result<MissionProfileIdResponse, RusotoError<DeleteMissionProfileError>>;
async fn describe_contact(
&self,
input: DescribeContactRequest,
) -> Result<DescribeContactResponse, RusotoError<DescribeContactError>>;
async fn get_config(
&self,
input: GetConfigRequest,
) -> Result<GetConfigResponse, RusotoError<GetConfigError>>;
async fn get_dataflow_endpoint_group(
&self,
input: GetDataflowEndpointGroupRequest,
) -> Result<GetDataflowEndpointGroupResponse, RusotoError<GetDataflowEndpointGroupError>>;
async fn get_minute_usage(
&self,
input: GetMinuteUsageRequest,
) -> Result<GetMinuteUsageResponse, RusotoError<GetMinuteUsageError>>;
async fn get_mission_profile(
&self,
input: GetMissionProfileRequest,
) -> Result<GetMissionProfileResponse, RusotoError<GetMissionProfileError>>;
async fn get_satellite(
&self,
input: GetSatelliteRequest,
) -> Result<GetSatelliteResponse, RusotoError<GetSatelliteError>>;
async fn list_configs(
&self,
input: ListConfigsRequest,
) -> Result<ListConfigsResponse, RusotoError<ListConfigsError>>;
async fn list_contacts(
&self,
input: ListContactsRequest,
) -> Result<ListContactsResponse, RusotoError<ListContactsError>>;
async fn list_dataflow_endpoint_groups(
&self,
input: ListDataflowEndpointGroupsRequest,
) -> Result<ListDataflowEndpointGroupsResponse, RusotoError<ListDataflowEndpointGroupsError>>;
async fn list_ground_stations(
&self,
input: ListGroundStationsRequest,
) -> Result<ListGroundStationsResponse, RusotoError<ListGroundStationsError>>;
async fn list_mission_profiles(
&self,
input: ListMissionProfilesRequest,
) -> Result<ListMissionProfilesResponse, RusotoError<ListMissionProfilesError>>;
async fn list_satellites(
&self,
input: ListSatellitesRequest,
) -> Result<ListSatellitesResponse, RusotoError<ListSatellitesError>>;
async fn list_tags_for_resource(
&self,
input: ListTagsForResourceRequest,
) -> Result<ListTagsForResourceResponse, RusotoError<ListTagsForResourceError>>;
async fn reserve_contact(
&self,
input: ReserveContactRequest,
) -> Result<ContactIdResponse, RusotoError<ReserveContactError>>;
async fn tag_resource(
&self,
input: TagResourceRequest,
) -> Result<TagResourceResponse, RusotoError<TagResourceError>>;
async fn untag_resource(
&self,
input: UntagResourceRequest,
) -> Result<UntagResourceResponse, RusotoError<UntagResourceError>>;
async fn update_config(
&self,
input: UpdateConfigRequest,
) -> Result<ConfigIdResponse, RusotoError<UpdateConfigError>>;
async fn update_mission_profile(
&self,
input: UpdateMissionProfileRequest,
) -> Result<MissionProfileIdResponse, RusotoError<UpdateMissionProfileError>>;
}
#[derive(Clone)]
pub struct GroundStationClient {
client: Client,
region: region::Region,
}
impl GroundStationClient {
pub fn new(region: region::Region) -> GroundStationClient {
GroundStationClient {
client: Client::shared(),
region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> GroundStationClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
D: DispatchSignedRequest + Send + Sync + 'static,
{
GroundStationClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region,
}
}
pub fn new_with_client(client: Client, region: region::Region) -> GroundStationClient {
GroundStationClient { client, region }
}
}
#[async_trait]
impl GroundStation for GroundStationClient {
#[allow(unused_mut)]
async fn cancel_contact(
&self,
input: CancelContactRequest,
) -> Result<ContactIdResponse, RusotoError<CancelContactError>> {
let request_uri = format!("/contact/{contact_id}", contact_id = input.contact_id);
let mut request = SignedRequest::new("DELETE", "groundstation", &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::<ContactIdResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CancelContactError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_config(
&self,
input: CreateConfigRequest,
) -> Result<ConfigIdResponse, RusotoError<CreateConfigError>> {
let request_uri = "/config";
let mut request = SignedRequest::new("POST", "groundstation", &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::<ConfigIdResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateConfigError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_dataflow_endpoint_group(
&self,
input: CreateDataflowEndpointGroupRequest,
) -> Result<DataflowEndpointGroupIdResponse, RusotoError<CreateDataflowEndpointGroupError>>
{
let request_uri = "/dataflowEndpointGroup";
let mut request = SignedRequest::new("POST", "groundstation", &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::<DataflowEndpointGroupIdResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateDataflowEndpointGroupError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_mission_profile(
&self,
input: CreateMissionProfileRequest,
) -> Result<MissionProfileIdResponse, RusotoError<CreateMissionProfileError>> {
let request_uri = "/missionprofile";
let mut request = SignedRequest::new("POST", "groundstation", &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::<MissionProfileIdResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateMissionProfileError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_config(
&self,
input: DeleteConfigRequest,
) -> Result<ConfigIdResponse, RusotoError<DeleteConfigError>> {
let request_uri = format!(
"/config/{config_type}/{config_id}",
config_id = input.config_id,
config_type = input.config_type
);
let mut request = SignedRequest::new("DELETE", "groundstation", &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::<ConfigIdResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteConfigError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_dataflow_endpoint_group(
&self,
input: DeleteDataflowEndpointGroupRequest,
) -> Result<DataflowEndpointGroupIdResponse, RusotoError<DeleteDataflowEndpointGroupError>>
{
let request_uri = format!(
"/dataflowEndpointGroup/{dataflow_endpoint_group_id}",
dataflow_endpoint_group_id = input.dataflow_endpoint_group_id
);
let mut request = SignedRequest::new("DELETE", "groundstation", &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::<DataflowEndpointGroupIdResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteDataflowEndpointGroupError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_mission_profile(
&self,
input: DeleteMissionProfileRequest,
) -> Result<MissionProfileIdResponse, RusotoError<DeleteMissionProfileError>> {
let request_uri = format!(
"/missionprofile/{mission_profile_id}",
mission_profile_id = input.mission_profile_id
);
let mut request = SignedRequest::new("DELETE", "groundstation", &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::<MissionProfileIdResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteMissionProfileError::from_response(response))
}
}
#[allow(unused_mut)]
async fn describe_contact(
&self,
input: DescribeContactRequest,
) -> Result<DescribeContactResponse, RusotoError<DescribeContactError>> {
let request_uri = format!("/contact/{contact_id}", contact_id = input.contact_id);
let mut request = SignedRequest::new("GET", "groundstation", &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::<DescribeContactResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DescribeContactError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_config(
&self,
input: GetConfigRequest,
) -> Result<GetConfigResponse, RusotoError<GetConfigError>> {
let request_uri = format!(
"/config/{config_type}/{config_id}",
config_id = input.config_id,
config_type = input.config_type
);
let mut request = SignedRequest::new("GET", "groundstation", &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::<GetConfigResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetConfigError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_dataflow_endpoint_group(
&self,
input: GetDataflowEndpointGroupRequest,
) -> Result<GetDataflowEndpointGroupResponse, RusotoError<GetDataflowEndpointGroupError>> {
let request_uri = format!(
"/dataflowEndpointGroup/{dataflow_endpoint_group_id}",
dataflow_endpoint_group_id = input.dataflow_endpoint_group_id
);
let mut request = SignedRequest::new("GET", "groundstation", &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::<GetDataflowEndpointGroupResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetDataflowEndpointGroupError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_minute_usage(
&self,
input: GetMinuteUsageRequest,
) -> Result<GetMinuteUsageResponse, RusotoError<GetMinuteUsageError>> {
let request_uri = "/minute-usage";
let mut request = SignedRequest::new("POST", "groundstation", &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::<GetMinuteUsageResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetMinuteUsageError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_mission_profile(
&self,
input: GetMissionProfileRequest,
) -> Result<GetMissionProfileResponse, RusotoError<GetMissionProfileError>> {
let request_uri = format!(
"/missionprofile/{mission_profile_id}",
mission_profile_id = input.mission_profile_id
);
let mut request = SignedRequest::new("GET", "groundstation", &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::<GetMissionProfileResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetMissionProfileError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_satellite(
&self,
input: GetSatelliteRequest,
) -> Result<GetSatelliteResponse, RusotoError<GetSatelliteError>> {
let request_uri = format!(
"/satellite/{satellite_id}",
satellite_id = input.satellite_id
);
let mut request = SignedRequest::new("GET", "groundstation", &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::<GetSatelliteResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetSatelliteError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_configs(
&self,
input: ListConfigsRequest,
) -> Result<ListConfigsResponse, RusotoError<ListConfigsError>> {
let request_uri = "/config";
let mut request = SignedRequest::new("GET", "groundstation", &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::<ListConfigsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListConfigsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_contacts(
&self,
input: ListContactsRequest,
) -> Result<ListContactsResponse, RusotoError<ListContactsError>> {
let request_uri = "/contacts";
let mut request = SignedRequest::new("POST", "groundstation", &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::<ListContactsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListContactsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_dataflow_endpoint_groups(
&self,
input: ListDataflowEndpointGroupsRequest,
) -> Result<ListDataflowEndpointGroupsResponse, RusotoError<ListDataflowEndpointGroupsError>>
{
let request_uri = "/dataflowEndpointGroup";
let mut request = SignedRequest::new("GET", "groundstation", &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::<ListDataflowEndpointGroupsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListDataflowEndpointGroupsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_ground_stations(
&self,
input: ListGroundStationsRequest,
) -> Result<ListGroundStationsResponse, RusotoError<ListGroundStationsError>> {
let request_uri = "/groundstation";
let mut request = SignedRequest::new("GET", "groundstation", &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);
}
if let Some(ref x) = input.satellite_id {
params.put("satelliteId", 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::<ListGroundStationsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListGroundStationsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_mission_profiles(
&self,
input: ListMissionProfilesRequest,
) -> Result<ListMissionProfilesResponse, RusotoError<ListMissionProfilesError>> {
let request_uri = "/missionprofile";
let mut request = SignedRequest::new("GET", "groundstation", &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::<ListMissionProfilesResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListMissionProfilesError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_satellites(
&self,
input: ListSatellitesRequest,
) -> Result<ListSatellitesResponse, RusotoError<ListSatellitesError>> {
let request_uri = "/satellite";
let mut request = SignedRequest::new("GET", "groundstation", &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::<ListSatellitesResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListSatellitesError::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", "groundstation", &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 reserve_contact(
&self,
input: ReserveContactRequest,
) -> Result<ContactIdResponse, RusotoError<ReserveContactError>> {
let request_uri = "/contact";
let mut request = SignedRequest::new("POST", "groundstation", &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::<ContactIdResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ReserveContactError::from_response(response))
}
}
#[allow(unused_mut)]
async fn tag_resource(
&self,
input: TagResourceRequest,
) -> Result<TagResourceResponse, RusotoError<TagResourceError>> {
let request_uri = format!("/tags/{resource_arn}", resource_arn = input.resource_arn);
let mut request = SignedRequest::new("POST", "groundstation", &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::<TagResourceResponse, _>()?;
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<UntagResourceResponse, RusotoError<UntagResourceError>> {
let request_uri = format!("/tags/{resource_arn}", resource_arn = input.resource_arn);
let mut request = SignedRequest::new("DELETE", "groundstation", &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() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UntagResourceResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UntagResourceError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_config(
&self,
input: UpdateConfigRequest,
) -> Result<ConfigIdResponse, RusotoError<UpdateConfigError>> {
let request_uri = format!(
"/config/{config_type}/{config_id}",
config_id = input.config_id,
config_type = input.config_type
);
let mut request = SignedRequest::new("PUT", "groundstation", &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::<ConfigIdResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateConfigError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_mission_profile(
&self,
input: UpdateMissionProfileRequest,
) -> Result<MissionProfileIdResponse, RusotoError<UpdateMissionProfileError>> {
let request_uri = format!(
"/missionprofile/{mission_profile_id}",
mission_profile_id = input.mission_profile_id
);
let mut request = SignedRequest::new("PUT", "groundstation", &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::<MissionProfileIdResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateMissionProfileError::from_response(response))
}
}
}