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(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ChatMessage {
#[serde(rename = "Content")]
pub content: String,
#[serde(rename = "ContentType")]
pub content_type: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ContactFlowSummary {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "ContactFlowType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub contact_flow_type: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateUserRequest {
#[serde(rename = "DirectoryUserId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub directory_user_id: Option<String>,
#[serde(rename = "HierarchyGroupId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hierarchy_group_id: Option<String>,
#[serde(rename = "IdentityInfo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub identity_info: Option<UserIdentityInfo>,
#[serde(rename = "InstanceId")]
pub instance_id: String,
#[serde(rename = "Password")]
#[serde(skip_serializing_if = "Option::is_none")]
pub password: Option<String>,
#[serde(rename = "PhoneConfig")]
pub phone_config: UserPhoneConfig,
#[serde(rename = "RoutingProfileId")]
pub routing_profile_id: String,
#[serde(rename = "SecurityProfileIds")]
pub security_profile_ids: Vec<String>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "Username")]
pub username: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateUserResponse {
#[serde(rename = "UserArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_arn: Option<String>,
#[serde(rename = "UserId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Credentials {
#[serde(rename = "AccessToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub access_token: Option<String>,
#[serde(rename = "AccessTokenExpiration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub access_token_expiration: Option<f64>,
#[serde(rename = "RefreshToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub refresh_token: Option<String>,
#[serde(rename = "RefreshTokenExpiration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub refresh_token_expiration: Option<f64>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CurrentMetric {
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "Unit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub unit: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CurrentMetricData {
#[serde(rename = "Metric")]
#[serde(skip_serializing_if = "Option::is_none")]
pub metric: Option<CurrentMetric>,
#[serde(rename = "Value")]
#[serde(skip_serializing_if = "Option::is_none")]
pub value: Option<f64>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CurrentMetricResult {
#[serde(rename = "Collections")]
#[serde(skip_serializing_if = "Option::is_none")]
pub collections: Option<Vec<CurrentMetricData>>,
#[serde(rename = "Dimensions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dimensions: Option<Dimensions>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteUserRequest {
#[serde(rename = "InstanceId")]
pub instance_id: String,
#[serde(rename = "UserId")]
pub user_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeUserHierarchyGroupRequest {
#[serde(rename = "HierarchyGroupId")]
pub hierarchy_group_id: String,
#[serde(rename = "InstanceId")]
pub instance_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeUserHierarchyGroupResponse {
#[serde(rename = "HierarchyGroup")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hierarchy_group: Option<HierarchyGroup>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeUserHierarchyStructureRequest {
#[serde(rename = "InstanceId")]
pub instance_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeUserHierarchyStructureResponse {
#[serde(rename = "HierarchyStructure")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hierarchy_structure: Option<HierarchyStructure>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeUserRequest {
#[serde(rename = "InstanceId")]
pub instance_id: String,
#[serde(rename = "UserId")]
pub user_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeUserResponse {
#[serde(rename = "User")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user: Option<User>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Dimensions {
#[serde(rename = "Channel")]
#[serde(skip_serializing_if = "Option::is_none")]
pub channel: Option<String>,
#[serde(rename = "Queue")]
#[serde(skip_serializing_if = "Option::is_none")]
pub queue: Option<QueueReference>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct Filters {
#[serde(rename = "Channels")]
#[serde(skip_serializing_if = "Option::is_none")]
pub channels: Option<Vec<String>>,
#[serde(rename = "Queues")]
#[serde(skip_serializing_if = "Option::is_none")]
pub queues: Option<Vec<String>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetContactAttributesRequest {
#[serde(rename = "InitialContactId")]
pub initial_contact_id: String,
#[serde(rename = "InstanceId")]
pub instance_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetContactAttributesResponse {
#[serde(rename = "Attributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attributes: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetCurrentMetricDataRequest {
#[serde(rename = "CurrentMetrics")]
pub current_metrics: Vec<CurrentMetric>,
#[serde(rename = "Filters")]
pub filters: Filters,
#[serde(rename = "Groupings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub groupings: Option<Vec<String>>,
#[serde(rename = "InstanceId")]
pub instance_id: String,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetCurrentMetricDataResponse {
#[serde(rename = "DataSnapshotTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub data_snapshot_time: Option<f64>,
#[serde(rename = "MetricResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub metric_results: Option<Vec<CurrentMetricResult>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetFederationTokenRequest {
#[serde(rename = "InstanceId")]
pub instance_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetFederationTokenResponse {
#[serde(rename = "Credentials")]
#[serde(skip_serializing_if = "Option::is_none")]
pub credentials: Option<Credentials>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetMetricDataRequest {
#[serde(rename = "EndTime")]
pub end_time: f64,
#[serde(rename = "Filters")]
pub filters: Filters,
#[serde(rename = "Groupings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub groupings: Option<Vec<String>>,
#[serde(rename = "HistoricalMetrics")]
pub historical_metrics: Vec<HistoricalMetric>,
#[serde(rename = "InstanceId")]
pub instance_id: String,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "StartTime")]
pub start_time: f64,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetMetricDataResponse {
#[serde(rename = "MetricResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub metric_results: Option<Vec<HistoricalMetricResult>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct HierarchyGroup {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "HierarchyPath")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hierarchy_path: Option<HierarchyPath>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "LevelId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub level_id: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct HierarchyGroupSummary {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct HierarchyLevel {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct HierarchyPath {
#[serde(rename = "LevelFive")]
#[serde(skip_serializing_if = "Option::is_none")]
pub level_five: Option<HierarchyGroupSummary>,
#[serde(rename = "LevelFour")]
#[serde(skip_serializing_if = "Option::is_none")]
pub level_four: Option<HierarchyGroupSummary>,
#[serde(rename = "LevelOne")]
#[serde(skip_serializing_if = "Option::is_none")]
pub level_one: Option<HierarchyGroupSummary>,
#[serde(rename = "LevelThree")]
#[serde(skip_serializing_if = "Option::is_none")]
pub level_three: Option<HierarchyGroupSummary>,
#[serde(rename = "LevelTwo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub level_two: Option<HierarchyGroupSummary>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct HierarchyStructure {
#[serde(rename = "LevelFive")]
#[serde(skip_serializing_if = "Option::is_none")]
pub level_five: Option<HierarchyLevel>,
#[serde(rename = "LevelFour")]
#[serde(skip_serializing_if = "Option::is_none")]
pub level_four: Option<HierarchyLevel>,
#[serde(rename = "LevelOne")]
#[serde(skip_serializing_if = "Option::is_none")]
pub level_one: Option<HierarchyLevel>,
#[serde(rename = "LevelThree")]
#[serde(skip_serializing_if = "Option::is_none")]
pub level_three: Option<HierarchyLevel>,
#[serde(rename = "LevelTwo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub level_two: Option<HierarchyLevel>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct HistoricalMetric {
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "Statistic")]
#[serde(skip_serializing_if = "Option::is_none")]
pub statistic: Option<String>,
#[serde(rename = "Threshold")]
#[serde(skip_serializing_if = "Option::is_none")]
pub threshold: Option<Threshold>,
#[serde(rename = "Unit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub unit: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct HistoricalMetricData {
#[serde(rename = "Metric")]
#[serde(skip_serializing_if = "Option::is_none")]
pub metric: Option<HistoricalMetric>,
#[serde(rename = "Value")]
#[serde(skip_serializing_if = "Option::is_none")]
pub value: Option<f64>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct HistoricalMetricResult {
#[serde(rename = "Collections")]
#[serde(skip_serializing_if = "Option::is_none")]
pub collections: Option<Vec<HistoricalMetricData>>,
#[serde(rename = "Dimensions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dimensions: Option<Dimensions>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct HoursOfOperationSummary {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListContactFlowsRequest {
#[serde(rename = "ContactFlowTypes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub contact_flow_types: Option<Vec<String>>,
#[serde(rename = "InstanceId")]
pub instance_id: String,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListContactFlowsResponse {
#[serde(rename = "ContactFlowSummaryList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub contact_flow_summary_list: Option<Vec<ContactFlowSummary>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListHoursOfOperationsRequest {
#[serde(rename = "InstanceId")]
pub instance_id: String,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListHoursOfOperationsResponse {
#[serde(rename = "HoursOfOperationSummaryList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hours_of_operation_summary_list: Option<Vec<HoursOfOperationSummary>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListPhoneNumbersRequest {
#[serde(rename = "InstanceId")]
pub instance_id: String,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "PhoneNumberCountryCodes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub phone_number_country_codes: Option<Vec<String>>,
#[serde(rename = "PhoneNumberTypes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub phone_number_types: Option<Vec<String>>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListPhoneNumbersResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "PhoneNumberSummaryList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub phone_number_summary_list: Option<Vec<PhoneNumberSummary>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListQueuesRequest {
#[serde(rename = "InstanceId")]
pub instance_id: String,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "QueueTypes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub queue_types: Option<Vec<String>>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListQueuesResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "QueueSummaryList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub queue_summary_list: Option<Vec<QueueSummary>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListRoutingProfilesRequest {
#[serde(rename = "InstanceId")]
pub instance_id: String,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListRoutingProfilesResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "RoutingProfileSummaryList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub routing_profile_summary_list: Option<Vec<RoutingProfileSummary>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListSecurityProfilesRequest {
#[serde(rename = "InstanceId")]
pub instance_id: String,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListSecurityProfilesResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "SecurityProfileSummaryList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub security_profile_summary_list: Option<Vec<SecurityProfileSummary>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListTagsForResourceRequest {
#[serde(rename = "resourceArn")]
pub resource_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListTagsForResourceResponse {
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListUserHierarchyGroupsRequest {
#[serde(rename = "InstanceId")]
pub instance_id: String,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListUserHierarchyGroupsResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "UserHierarchyGroupSummaryList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_hierarchy_group_summary_list: Option<Vec<HierarchyGroupSummary>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListUsersRequest {
#[serde(rename = "InstanceId")]
pub instance_id: String,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListUsersResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "UserSummaryList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_summary_list: Option<Vec<UserSummary>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ParticipantDetails {
#[serde(rename = "DisplayName")]
pub display_name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PhoneNumberSummary {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "PhoneNumber")]
#[serde(skip_serializing_if = "Option::is_none")]
pub phone_number: Option<String>,
#[serde(rename = "PhoneNumberCountryCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub phone_number_country_code: Option<String>,
#[serde(rename = "PhoneNumberType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub phone_number_type: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct QueueReference {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct QueueSummary {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "QueueType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub queue_type: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RoutingProfileSummary {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct SecurityProfileSummary {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StartChatContactRequest {
#[serde(rename = "Attributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attributes: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "ClientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_token: Option<String>,
#[serde(rename = "ContactFlowId")]
pub contact_flow_id: String,
#[serde(rename = "InitialMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub initial_message: Option<ChatMessage>,
#[serde(rename = "InstanceId")]
pub instance_id: String,
#[serde(rename = "ParticipantDetails")]
pub participant_details: ParticipantDetails,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct StartChatContactResponse {
#[serde(rename = "ContactId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub contact_id: Option<String>,
#[serde(rename = "ParticipantId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub participant_id: Option<String>,
#[serde(rename = "ParticipantToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub participant_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StartOutboundVoiceContactRequest {
#[serde(rename = "Attributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attributes: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "ClientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_token: Option<String>,
#[serde(rename = "ContactFlowId")]
pub contact_flow_id: String,
#[serde(rename = "DestinationPhoneNumber")]
pub destination_phone_number: String,
#[serde(rename = "InstanceId")]
pub instance_id: String,
#[serde(rename = "QueueId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub queue_id: Option<String>,
#[serde(rename = "SourcePhoneNumber")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_phone_number: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct StartOutboundVoiceContactResponse {
#[serde(rename = "ContactId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub contact_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StopContactRequest {
#[serde(rename = "ContactId")]
pub contact_id: String,
#[serde(rename = "InstanceId")]
pub instance_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct StopContactResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct TagResourceRequest {
#[serde(rename = "resourceArn")]
pub resource_arn: String,
#[serde(rename = "tags")]
pub tags: ::std::collections::HashMap<String, String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Threshold {
#[serde(rename = "Comparison")]
#[serde(skip_serializing_if = "Option::is_none")]
pub comparison: Option<String>,
#[serde(rename = "ThresholdValue")]
#[serde(skip_serializing_if = "Option::is_none")]
pub threshold_value: Option<f64>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UntagResourceRequest {
#[serde(rename = "resourceArn")]
pub resource_arn: String,
#[serde(rename = "tagKeys")]
pub tag_keys: Vec<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateContactAttributesRequest {
#[serde(rename = "Attributes")]
pub attributes: ::std::collections::HashMap<String, String>,
#[serde(rename = "InitialContactId")]
pub initial_contact_id: String,
#[serde(rename = "InstanceId")]
pub instance_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateContactAttributesResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateUserHierarchyRequest {
#[serde(rename = "HierarchyGroupId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hierarchy_group_id: Option<String>,
#[serde(rename = "InstanceId")]
pub instance_id: String,
#[serde(rename = "UserId")]
pub user_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateUserIdentityInfoRequest {
#[serde(rename = "IdentityInfo")]
pub identity_info: UserIdentityInfo,
#[serde(rename = "InstanceId")]
pub instance_id: String,
#[serde(rename = "UserId")]
pub user_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateUserPhoneConfigRequest {
#[serde(rename = "InstanceId")]
pub instance_id: String,
#[serde(rename = "PhoneConfig")]
pub phone_config: UserPhoneConfig,
#[serde(rename = "UserId")]
pub user_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateUserRoutingProfileRequest {
#[serde(rename = "InstanceId")]
pub instance_id: String,
#[serde(rename = "RoutingProfileId")]
pub routing_profile_id: String,
#[serde(rename = "UserId")]
pub user_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateUserSecurityProfilesRequest {
#[serde(rename = "InstanceId")]
pub instance_id: String,
#[serde(rename = "SecurityProfileIds")]
pub security_profile_ids: Vec<String>,
#[serde(rename = "UserId")]
pub user_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct User {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "DirectoryUserId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub directory_user_id: Option<String>,
#[serde(rename = "HierarchyGroupId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hierarchy_group_id: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "IdentityInfo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub identity_info: Option<UserIdentityInfo>,
#[serde(rename = "PhoneConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub phone_config: Option<UserPhoneConfig>,
#[serde(rename = "RoutingProfileId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub routing_profile_id: Option<String>,
#[serde(rename = "SecurityProfileIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub security_profile_ids: Option<Vec<String>>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "Username")]
#[serde(skip_serializing_if = "Option::is_none")]
pub username: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct UserIdentityInfo {
#[serde(rename = "Email")]
#[serde(skip_serializing_if = "Option::is_none")]
pub email: Option<String>,
#[serde(rename = "FirstName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub first_name: Option<String>,
#[serde(rename = "LastName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct UserPhoneConfig {
#[serde(rename = "AfterContactWorkTimeLimit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub after_contact_work_time_limit: Option<i64>,
#[serde(rename = "AutoAccept")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_accept: Option<bool>,
#[serde(rename = "DeskPhoneNumber")]
#[serde(skip_serializing_if = "Option::is_none")]
pub desk_phone_number: Option<String>,
#[serde(rename = "PhoneType")]
pub phone_type: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UserSummary {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "Username")]
#[serde(skip_serializing_if = "Option::is_none")]
pub username: Option<String>,
}
#[derive(Debug, PartialEq)]
pub enum CreateUserError {
DuplicateResource(String),
InternalService(String),
InvalidParameter(String),
InvalidRequest(String),
LimitExceeded(String),
ResourceNotFound(String),
Throttling(String),
}
impl CreateUserError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateUserError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"DuplicateResourceException" => {
return RusotoError::Service(CreateUserError::DuplicateResource(err.msg))
}
"InternalServiceException" => {
return RusotoError::Service(CreateUserError::InternalService(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(CreateUserError::InvalidParameter(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(CreateUserError::InvalidRequest(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(CreateUserError::LimitExceeded(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(CreateUserError::ResourceNotFound(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(CreateUserError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateUserError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateUserError::DuplicateResource(ref cause) => write!(f, "{}", cause),
CreateUserError::InternalService(ref cause) => write!(f, "{}", cause),
CreateUserError::InvalidParameter(ref cause) => write!(f, "{}", cause),
CreateUserError::InvalidRequest(ref cause) => write!(f, "{}", cause),
CreateUserError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreateUserError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
CreateUserError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateUserError {}
#[derive(Debug, PartialEq)]
pub enum DeleteUserError {
InternalService(String),
InvalidParameter(String),
InvalidRequest(String),
ResourceNotFound(String),
Throttling(String),
}
impl DeleteUserError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteUserError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServiceException" => {
return RusotoError::Service(DeleteUserError::InternalService(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(DeleteUserError::InvalidParameter(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(DeleteUserError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DeleteUserError::ResourceNotFound(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(DeleteUserError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteUserError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteUserError::InternalService(ref cause) => write!(f, "{}", cause),
DeleteUserError::InvalidParameter(ref cause) => write!(f, "{}", cause),
DeleteUserError::InvalidRequest(ref cause) => write!(f, "{}", cause),
DeleteUserError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DeleteUserError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteUserError {}
#[derive(Debug, PartialEq)]
pub enum DescribeUserError {
InternalService(String),
InvalidParameter(String),
InvalidRequest(String),
ResourceNotFound(String),
Throttling(String),
}
impl DescribeUserError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeUserError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServiceException" => {
return RusotoError::Service(DescribeUserError::InternalService(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(DescribeUserError::InvalidParameter(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(DescribeUserError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeUserError::ResourceNotFound(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(DescribeUserError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeUserError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeUserError::InternalService(ref cause) => write!(f, "{}", cause),
DescribeUserError::InvalidParameter(ref cause) => write!(f, "{}", cause),
DescribeUserError::InvalidRequest(ref cause) => write!(f, "{}", cause),
DescribeUserError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DescribeUserError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeUserError {}
#[derive(Debug, PartialEq)]
pub enum DescribeUserHierarchyGroupError {
InternalService(String),
InvalidParameter(String),
InvalidRequest(String),
ResourceNotFound(String),
Throttling(String),
}
impl DescribeUserHierarchyGroupError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeUserHierarchyGroupError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServiceException" => {
return RusotoError::Service(DescribeUserHierarchyGroupError::InternalService(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(DescribeUserHierarchyGroupError::InvalidParameter(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(DescribeUserHierarchyGroupError::InvalidRequest(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeUserHierarchyGroupError::ResourceNotFound(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(DescribeUserHierarchyGroupError::Throttling(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeUserHierarchyGroupError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeUserHierarchyGroupError::InternalService(ref cause) => write!(f, "{}", cause),
DescribeUserHierarchyGroupError::InvalidParameter(ref cause) => write!(f, "{}", cause),
DescribeUserHierarchyGroupError::InvalidRequest(ref cause) => write!(f, "{}", cause),
DescribeUserHierarchyGroupError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DescribeUserHierarchyGroupError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeUserHierarchyGroupError {}
#[derive(Debug, PartialEq)]
pub enum DescribeUserHierarchyStructureError {
InternalService(String),
InvalidParameter(String),
InvalidRequest(String),
ResourceNotFound(String),
Throttling(String),
}
impl DescribeUserHierarchyStructureError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeUserHierarchyStructureError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServiceException" => {
return RusotoError::Service(
DescribeUserHierarchyStructureError::InternalService(err.msg),
)
}
"InvalidParameterException" => {
return RusotoError::Service(
DescribeUserHierarchyStructureError::InvalidParameter(err.msg),
)
}
"InvalidRequestException" => {
return RusotoError::Service(
DescribeUserHierarchyStructureError::InvalidRequest(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
DescribeUserHierarchyStructureError::ResourceNotFound(err.msg),
)
}
"ThrottlingException" => {
return RusotoError::Service(DescribeUserHierarchyStructureError::Throttling(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeUserHierarchyStructureError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeUserHierarchyStructureError::InternalService(ref cause) => {
write!(f, "{}", cause)
}
DescribeUserHierarchyStructureError::InvalidParameter(ref cause) => {
write!(f, "{}", cause)
}
DescribeUserHierarchyStructureError::InvalidRequest(ref cause) => {
write!(f, "{}", cause)
}
DescribeUserHierarchyStructureError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
DescribeUserHierarchyStructureError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeUserHierarchyStructureError {}
#[derive(Debug, PartialEq)]
pub enum GetContactAttributesError {
InternalService(String),
InvalidRequest(String),
ResourceNotFound(String),
}
impl GetContactAttributesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetContactAttributesError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServiceException" => {
return RusotoError::Service(GetContactAttributesError::InternalService(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(GetContactAttributesError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(GetContactAttributesError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetContactAttributesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetContactAttributesError::InternalService(ref cause) => write!(f, "{}", cause),
GetContactAttributesError::InvalidRequest(ref cause) => write!(f, "{}", cause),
GetContactAttributesError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetContactAttributesError {}
#[derive(Debug, PartialEq)]
pub enum GetCurrentMetricDataError {
InternalService(String),
InvalidParameter(String),
InvalidRequest(String),
ResourceNotFound(String),
Throttling(String),
}
impl GetCurrentMetricDataError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetCurrentMetricDataError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServiceException" => {
return RusotoError::Service(GetCurrentMetricDataError::InternalService(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(GetCurrentMetricDataError::InvalidParameter(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(GetCurrentMetricDataError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(GetCurrentMetricDataError::ResourceNotFound(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(GetCurrentMetricDataError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetCurrentMetricDataError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetCurrentMetricDataError::InternalService(ref cause) => write!(f, "{}", cause),
GetCurrentMetricDataError::InvalidParameter(ref cause) => write!(f, "{}", cause),
GetCurrentMetricDataError::InvalidRequest(ref cause) => write!(f, "{}", cause),
GetCurrentMetricDataError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
GetCurrentMetricDataError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetCurrentMetricDataError {}
#[derive(Debug, PartialEq)]
pub enum GetFederationTokenError {
DuplicateResource(String),
InternalService(String),
InvalidParameter(String),
InvalidRequest(String),
ResourceNotFound(String),
UserNotFound(String),
}
impl GetFederationTokenError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetFederationTokenError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"DuplicateResourceException" => {
return RusotoError::Service(GetFederationTokenError::DuplicateResource(
err.msg,
))
}
"InternalServiceException" => {
return RusotoError::Service(GetFederationTokenError::InternalService(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(GetFederationTokenError::InvalidParameter(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(GetFederationTokenError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(GetFederationTokenError::ResourceNotFound(err.msg))
}
"UserNotFoundException" => {
return RusotoError::Service(GetFederationTokenError::UserNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetFederationTokenError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetFederationTokenError::DuplicateResource(ref cause) => write!(f, "{}", cause),
GetFederationTokenError::InternalService(ref cause) => write!(f, "{}", cause),
GetFederationTokenError::InvalidParameter(ref cause) => write!(f, "{}", cause),
GetFederationTokenError::InvalidRequest(ref cause) => write!(f, "{}", cause),
GetFederationTokenError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
GetFederationTokenError::UserNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetFederationTokenError {}
#[derive(Debug, PartialEq)]
pub enum GetMetricDataError {
InternalService(String),
InvalidParameter(String),
InvalidRequest(String),
ResourceNotFound(String),
Throttling(String),
}
impl GetMetricDataError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetMetricDataError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServiceException" => {
return RusotoError::Service(GetMetricDataError::InternalService(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(GetMetricDataError::InvalidParameter(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(GetMetricDataError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(GetMetricDataError::ResourceNotFound(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(GetMetricDataError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetMetricDataError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetMetricDataError::InternalService(ref cause) => write!(f, "{}", cause),
GetMetricDataError::InvalidParameter(ref cause) => write!(f, "{}", cause),
GetMetricDataError::InvalidRequest(ref cause) => write!(f, "{}", cause),
GetMetricDataError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
GetMetricDataError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetMetricDataError {}
#[derive(Debug, PartialEq)]
pub enum ListContactFlowsError {
InternalService(String),
InvalidParameter(String),
InvalidRequest(String),
ResourceNotFound(String),
Throttling(String),
}
impl ListContactFlowsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListContactFlowsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServiceException" => {
return RusotoError::Service(ListContactFlowsError::InternalService(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(ListContactFlowsError::InvalidParameter(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(ListContactFlowsError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListContactFlowsError::ResourceNotFound(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(ListContactFlowsError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListContactFlowsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListContactFlowsError::InternalService(ref cause) => write!(f, "{}", cause),
ListContactFlowsError::InvalidParameter(ref cause) => write!(f, "{}", cause),
ListContactFlowsError::InvalidRequest(ref cause) => write!(f, "{}", cause),
ListContactFlowsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ListContactFlowsError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListContactFlowsError {}
#[derive(Debug, PartialEq)]
pub enum ListHoursOfOperationsError {
InternalService(String),
InvalidParameter(String),
InvalidRequest(String),
ResourceNotFound(String),
Throttling(String),
}
impl ListHoursOfOperationsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListHoursOfOperationsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServiceException" => {
return RusotoError::Service(ListHoursOfOperationsError::InternalService(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(ListHoursOfOperationsError::InvalidParameter(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(ListHoursOfOperationsError::InvalidRequest(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListHoursOfOperationsError::ResourceNotFound(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(ListHoursOfOperationsError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListHoursOfOperationsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListHoursOfOperationsError::InternalService(ref cause) => write!(f, "{}", cause),
ListHoursOfOperationsError::InvalidParameter(ref cause) => write!(f, "{}", cause),
ListHoursOfOperationsError::InvalidRequest(ref cause) => write!(f, "{}", cause),
ListHoursOfOperationsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ListHoursOfOperationsError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListHoursOfOperationsError {}
#[derive(Debug, PartialEq)]
pub enum ListPhoneNumbersError {
InternalService(String),
InvalidParameter(String),
InvalidRequest(String),
ResourceNotFound(String),
Throttling(String),
}
impl ListPhoneNumbersError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListPhoneNumbersError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServiceException" => {
return RusotoError::Service(ListPhoneNumbersError::InternalService(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(ListPhoneNumbersError::InvalidParameter(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(ListPhoneNumbersError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListPhoneNumbersError::ResourceNotFound(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(ListPhoneNumbersError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListPhoneNumbersError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListPhoneNumbersError::InternalService(ref cause) => write!(f, "{}", cause),
ListPhoneNumbersError::InvalidParameter(ref cause) => write!(f, "{}", cause),
ListPhoneNumbersError::InvalidRequest(ref cause) => write!(f, "{}", cause),
ListPhoneNumbersError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ListPhoneNumbersError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListPhoneNumbersError {}
#[derive(Debug, PartialEq)]
pub enum ListQueuesError {
InternalService(String),
InvalidParameter(String),
InvalidRequest(String),
ResourceNotFound(String),
Throttling(String),
}
impl ListQueuesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListQueuesError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServiceException" => {
return RusotoError::Service(ListQueuesError::InternalService(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(ListQueuesError::InvalidParameter(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(ListQueuesError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListQueuesError::ResourceNotFound(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(ListQueuesError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListQueuesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListQueuesError::InternalService(ref cause) => write!(f, "{}", cause),
ListQueuesError::InvalidParameter(ref cause) => write!(f, "{}", cause),
ListQueuesError::InvalidRequest(ref cause) => write!(f, "{}", cause),
ListQueuesError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ListQueuesError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListQueuesError {}
#[derive(Debug, PartialEq)]
pub enum ListRoutingProfilesError {
InternalService(String),
InvalidParameter(String),
InvalidRequest(String),
ResourceNotFound(String),
Throttling(String),
}
impl ListRoutingProfilesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListRoutingProfilesError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServiceException" => {
return RusotoError::Service(ListRoutingProfilesError::InternalService(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(ListRoutingProfilesError::InvalidParameter(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(ListRoutingProfilesError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListRoutingProfilesError::ResourceNotFound(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(ListRoutingProfilesError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListRoutingProfilesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListRoutingProfilesError::InternalService(ref cause) => write!(f, "{}", cause),
ListRoutingProfilesError::InvalidParameter(ref cause) => write!(f, "{}", cause),
ListRoutingProfilesError::InvalidRequest(ref cause) => write!(f, "{}", cause),
ListRoutingProfilesError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ListRoutingProfilesError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListRoutingProfilesError {}
#[derive(Debug, PartialEq)]
pub enum ListSecurityProfilesError {
InternalService(String),
InvalidParameter(String),
InvalidRequest(String),
ResourceNotFound(String),
Throttling(String),
}
impl ListSecurityProfilesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListSecurityProfilesError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServiceException" => {
return RusotoError::Service(ListSecurityProfilesError::InternalService(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(ListSecurityProfilesError::InvalidParameter(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(ListSecurityProfilesError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListSecurityProfilesError::ResourceNotFound(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(ListSecurityProfilesError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListSecurityProfilesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListSecurityProfilesError::InternalService(ref cause) => write!(f, "{}", cause),
ListSecurityProfilesError::InvalidParameter(ref cause) => write!(f, "{}", cause),
ListSecurityProfilesError::InvalidRequest(ref cause) => write!(f, "{}", cause),
ListSecurityProfilesError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ListSecurityProfilesError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListSecurityProfilesError {}
#[derive(Debug, PartialEq)]
pub enum ListTagsForResourceError {
InternalService(String),
InvalidParameter(String),
InvalidRequest(String),
ResourceNotFound(String),
Throttling(String),
}
impl ListTagsForResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListTagsForResourceError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServiceException" => {
return RusotoError::Service(ListTagsForResourceError::InternalService(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(ListTagsForResourceError::InvalidParameter(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(ListTagsForResourceError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListTagsForResourceError::ResourceNotFound(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(ListTagsForResourceError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListTagsForResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListTagsForResourceError::InternalService(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::InvalidParameter(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::InvalidRequest(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListTagsForResourceError {}
#[derive(Debug, PartialEq)]
pub enum ListUserHierarchyGroupsError {
InternalService(String),
InvalidParameter(String),
InvalidRequest(String),
ResourceNotFound(String),
Throttling(String),
}
impl ListUserHierarchyGroupsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListUserHierarchyGroupsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServiceException" => {
return RusotoError::Service(ListUserHierarchyGroupsError::InternalService(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(ListUserHierarchyGroupsError::InvalidParameter(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(ListUserHierarchyGroupsError::InvalidRequest(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListUserHierarchyGroupsError::ResourceNotFound(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(ListUserHierarchyGroupsError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListUserHierarchyGroupsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListUserHierarchyGroupsError::InternalService(ref cause) => write!(f, "{}", cause),
ListUserHierarchyGroupsError::InvalidParameter(ref cause) => write!(f, "{}", cause),
ListUserHierarchyGroupsError::InvalidRequest(ref cause) => write!(f, "{}", cause),
ListUserHierarchyGroupsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ListUserHierarchyGroupsError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListUserHierarchyGroupsError {}
#[derive(Debug, PartialEq)]
pub enum ListUsersError {
InternalService(String),
InvalidParameter(String),
InvalidRequest(String),
ResourceNotFound(String),
Throttling(String),
}
impl ListUsersError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListUsersError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServiceException" => {
return RusotoError::Service(ListUsersError::InternalService(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(ListUsersError::InvalidParameter(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(ListUsersError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListUsersError::ResourceNotFound(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(ListUsersError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListUsersError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListUsersError::InternalService(ref cause) => write!(f, "{}", cause),
ListUsersError::InvalidParameter(ref cause) => write!(f, "{}", cause),
ListUsersError::InvalidRequest(ref cause) => write!(f, "{}", cause),
ListUsersError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ListUsersError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListUsersError {}
#[derive(Debug, PartialEq)]
pub enum StartChatContactError {
InternalService(String),
InvalidParameter(String),
InvalidRequest(String),
LimitExceeded(String),
ResourceNotFound(String),
}
impl StartChatContactError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StartChatContactError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServiceException" => {
return RusotoError::Service(StartChatContactError::InternalService(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(StartChatContactError::InvalidParameter(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(StartChatContactError::InvalidRequest(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(StartChatContactError::LimitExceeded(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(StartChatContactError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for StartChatContactError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
StartChatContactError::InternalService(ref cause) => write!(f, "{}", cause),
StartChatContactError::InvalidParameter(ref cause) => write!(f, "{}", cause),
StartChatContactError::InvalidRequest(ref cause) => write!(f, "{}", cause),
StartChatContactError::LimitExceeded(ref cause) => write!(f, "{}", cause),
StartChatContactError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for StartChatContactError {}
#[derive(Debug, PartialEq)]
pub enum StartOutboundVoiceContactError {
DestinationNotAllowed(String),
InternalService(String),
InvalidParameter(String),
InvalidRequest(String),
LimitExceeded(String),
OutboundContactNotPermitted(String),
ResourceNotFound(String),
}
impl StartOutboundVoiceContactError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StartOutboundVoiceContactError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"DestinationNotAllowedException" => {
return RusotoError::Service(
StartOutboundVoiceContactError::DestinationNotAllowed(err.msg),
)
}
"InternalServiceException" => {
return RusotoError::Service(StartOutboundVoiceContactError::InternalService(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(StartOutboundVoiceContactError::InvalidParameter(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(StartOutboundVoiceContactError::InvalidRequest(
err.msg,
))
}
"LimitExceededException" => {
return RusotoError::Service(StartOutboundVoiceContactError::LimitExceeded(
err.msg,
))
}
"OutboundContactNotPermittedException" => {
return RusotoError::Service(
StartOutboundVoiceContactError::OutboundContactNotPermitted(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(StartOutboundVoiceContactError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for StartOutboundVoiceContactError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
StartOutboundVoiceContactError::DestinationNotAllowed(ref cause) => {
write!(f, "{}", cause)
}
StartOutboundVoiceContactError::InternalService(ref cause) => write!(f, "{}", cause),
StartOutboundVoiceContactError::InvalidParameter(ref cause) => write!(f, "{}", cause),
StartOutboundVoiceContactError::InvalidRequest(ref cause) => write!(f, "{}", cause),
StartOutboundVoiceContactError::LimitExceeded(ref cause) => write!(f, "{}", cause),
StartOutboundVoiceContactError::OutboundContactNotPermitted(ref cause) => {
write!(f, "{}", cause)
}
StartOutboundVoiceContactError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for StartOutboundVoiceContactError {}
#[derive(Debug, PartialEq)]
pub enum StopContactError {
ContactNotFound(String),
InternalService(String),
InvalidParameter(String),
InvalidRequest(String),
ResourceNotFound(String),
}
impl StopContactError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StopContactError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"ContactNotFoundException" => {
return RusotoError::Service(StopContactError::ContactNotFound(err.msg))
}
"InternalServiceException" => {
return RusotoError::Service(StopContactError::InternalService(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(StopContactError::InvalidParameter(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(StopContactError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(StopContactError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for StopContactError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
StopContactError::ContactNotFound(ref cause) => write!(f, "{}", cause),
StopContactError::InternalService(ref cause) => write!(f, "{}", cause),
StopContactError::InvalidParameter(ref cause) => write!(f, "{}", cause),
StopContactError::InvalidRequest(ref cause) => write!(f, "{}", cause),
StopContactError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for StopContactError {}
#[derive(Debug, PartialEq)]
pub enum TagResourceError {
InternalService(String),
InvalidParameter(String),
InvalidRequest(String),
ResourceNotFound(String),
Throttling(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() {
"InternalServiceException" => {
return RusotoError::Service(TagResourceError::InternalService(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(TagResourceError::InvalidParameter(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(TagResourceError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(TagResourceError::ResourceNotFound(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(TagResourceError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for TagResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
TagResourceError::InternalService(ref cause) => write!(f, "{}", cause),
TagResourceError::InvalidParameter(ref cause) => write!(f, "{}", cause),
TagResourceError::InvalidRequest(ref cause) => write!(f, "{}", cause),
TagResourceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
TagResourceError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for TagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UntagResourceError {
InternalService(String),
InvalidParameter(String),
InvalidRequest(String),
ResourceNotFound(String),
Throttling(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() {
"InternalServiceException" => {
return RusotoError::Service(UntagResourceError::InternalService(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(UntagResourceError::InvalidParameter(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(UntagResourceError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UntagResourceError::ResourceNotFound(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(UntagResourceError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UntagResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UntagResourceError::InternalService(ref cause) => write!(f, "{}", cause),
UntagResourceError::InvalidParameter(ref cause) => write!(f, "{}", cause),
UntagResourceError::InvalidRequest(ref cause) => write!(f, "{}", cause),
UntagResourceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
UntagResourceError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UntagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UpdateContactAttributesError {
InternalService(String),
InvalidParameter(String),
InvalidRequest(String),
ResourceNotFound(String),
}
impl UpdateContactAttributesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateContactAttributesError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServiceException" => {
return RusotoError::Service(UpdateContactAttributesError::InternalService(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(UpdateContactAttributesError::InvalidParameter(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(UpdateContactAttributesError::InvalidRequest(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UpdateContactAttributesError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateContactAttributesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateContactAttributesError::InternalService(ref cause) => write!(f, "{}", cause),
UpdateContactAttributesError::InvalidParameter(ref cause) => write!(f, "{}", cause),
UpdateContactAttributesError::InvalidRequest(ref cause) => write!(f, "{}", cause),
UpdateContactAttributesError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateContactAttributesError {}
#[derive(Debug, PartialEq)]
pub enum UpdateUserHierarchyError {
InternalService(String),
InvalidParameter(String),
InvalidRequest(String),
ResourceNotFound(String),
Throttling(String),
}
impl UpdateUserHierarchyError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateUserHierarchyError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServiceException" => {
return RusotoError::Service(UpdateUserHierarchyError::InternalService(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(UpdateUserHierarchyError::InvalidParameter(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(UpdateUserHierarchyError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UpdateUserHierarchyError::ResourceNotFound(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(UpdateUserHierarchyError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateUserHierarchyError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateUserHierarchyError::InternalService(ref cause) => write!(f, "{}", cause),
UpdateUserHierarchyError::InvalidParameter(ref cause) => write!(f, "{}", cause),
UpdateUserHierarchyError::InvalidRequest(ref cause) => write!(f, "{}", cause),
UpdateUserHierarchyError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
UpdateUserHierarchyError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateUserHierarchyError {}
#[derive(Debug, PartialEq)]
pub enum UpdateUserIdentityInfoError {
InternalService(String),
InvalidParameter(String),
InvalidRequest(String),
ResourceNotFound(String),
Throttling(String),
}
impl UpdateUserIdentityInfoError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateUserIdentityInfoError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServiceException" => {
return RusotoError::Service(UpdateUserIdentityInfoError::InternalService(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(UpdateUserIdentityInfoError::InvalidParameter(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(UpdateUserIdentityInfoError::InvalidRequest(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UpdateUserIdentityInfoError::ResourceNotFound(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(UpdateUserIdentityInfoError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateUserIdentityInfoError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateUserIdentityInfoError::InternalService(ref cause) => write!(f, "{}", cause),
UpdateUserIdentityInfoError::InvalidParameter(ref cause) => write!(f, "{}", cause),
UpdateUserIdentityInfoError::InvalidRequest(ref cause) => write!(f, "{}", cause),
UpdateUserIdentityInfoError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
UpdateUserIdentityInfoError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateUserIdentityInfoError {}
#[derive(Debug, PartialEq)]
pub enum UpdateUserPhoneConfigError {
InternalService(String),
InvalidParameter(String),
InvalidRequest(String),
ResourceNotFound(String),
Throttling(String),
}
impl UpdateUserPhoneConfigError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateUserPhoneConfigError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServiceException" => {
return RusotoError::Service(UpdateUserPhoneConfigError::InternalService(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(UpdateUserPhoneConfigError::InvalidParameter(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(UpdateUserPhoneConfigError::InvalidRequest(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UpdateUserPhoneConfigError::ResourceNotFound(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(UpdateUserPhoneConfigError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateUserPhoneConfigError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateUserPhoneConfigError::InternalService(ref cause) => write!(f, "{}", cause),
UpdateUserPhoneConfigError::InvalidParameter(ref cause) => write!(f, "{}", cause),
UpdateUserPhoneConfigError::InvalidRequest(ref cause) => write!(f, "{}", cause),
UpdateUserPhoneConfigError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
UpdateUserPhoneConfigError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateUserPhoneConfigError {}
#[derive(Debug, PartialEq)]
pub enum UpdateUserRoutingProfileError {
InternalService(String),
InvalidParameter(String),
InvalidRequest(String),
ResourceNotFound(String),
Throttling(String),
}
impl UpdateUserRoutingProfileError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateUserRoutingProfileError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServiceException" => {
return RusotoError::Service(UpdateUserRoutingProfileError::InternalService(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(UpdateUserRoutingProfileError::InvalidParameter(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(UpdateUserRoutingProfileError::InvalidRequest(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UpdateUserRoutingProfileError::ResourceNotFound(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(UpdateUserRoutingProfileError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateUserRoutingProfileError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateUserRoutingProfileError::InternalService(ref cause) => write!(f, "{}", cause),
UpdateUserRoutingProfileError::InvalidParameter(ref cause) => write!(f, "{}", cause),
UpdateUserRoutingProfileError::InvalidRequest(ref cause) => write!(f, "{}", cause),
UpdateUserRoutingProfileError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
UpdateUserRoutingProfileError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateUserRoutingProfileError {}
#[derive(Debug, PartialEq)]
pub enum UpdateUserSecurityProfilesError {
InternalService(String),
InvalidParameter(String),
InvalidRequest(String),
ResourceNotFound(String),
Throttling(String),
}
impl UpdateUserSecurityProfilesError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<UpdateUserSecurityProfilesError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServiceException" => {
return RusotoError::Service(UpdateUserSecurityProfilesError::InternalService(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(UpdateUserSecurityProfilesError::InvalidParameter(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(UpdateUserSecurityProfilesError::InvalidRequest(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UpdateUserSecurityProfilesError::ResourceNotFound(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(UpdateUserSecurityProfilesError::Throttling(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateUserSecurityProfilesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateUserSecurityProfilesError::InternalService(ref cause) => write!(f, "{}", cause),
UpdateUserSecurityProfilesError::InvalidParameter(ref cause) => write!(f, "{}", cause),
UpdateUserSecurityProfilesError::InvalidRequest(ref cause) => write!(f, "{}", cause),
UpdateUserSecurityProfilesError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
UpdateUserSecurityProfilesError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateUserSecurityProfilesError {}
#[async_trait]
pub trait Connect {
async fn create_user(
&self,
input: CreateUserRequest,
) -> Result<CreateUserResponse, RusotoError<CreateUserError>>;
async fn delete_user(
&self,
input: DeleteUserRequest,
) -> Result<(), RusotoError<DeleteUserError>>;
async fn describe_user(
&self,
input: DescribeUserRequest,
) -> Result<DescribeUserResponse, RusotoError<DescribeUserError>>;
async fn describe_user_hierarchy_group(
&self,
input: DescribeUserHierarchyGroupRequest,
) -> Result<DescribeUserHierarchyGroupResponse, RusotoError<DescribeUserHierarchyGroupError>>;
async fn describe_user_hierarchy_structure(
&self,
input: DescribeUserHierarchyStructureRequest,
) -> Result<
DescribeUserHierarchyStructureResponse,
RusotoError<DescribeUserHierarchyStructureError>,
>;
async fn get_contact_attributes(
&self,
input: GetContactAttributesRequest,
) -> Result<GetContactAttributesResponse, RusotoError<GetContactAttributesError>>;
async fn get_current_metric_data(
&self,
input: GetCurrentMetricDataRequest,
) -> Result<GetCurrentMetricDataResponse, RusotoError<GetCurrentMetricDataError>>;
async fn get_federation_token(
&self,
input: GetFederationTokenRequest,
) -> Result<GetFederationTokenResponse, RusotoError<GetFederationTokenError>>;
async fn get_metric_data(
&self,
input: GetMetricDataRequest,
) -> Result<GetMetricDataResponse, RusotoError<GetMetricDataError>>;
async fn list_contact_flows(
&self,
input: ListContactFlowsRequest,
) -> Result<ListContactFlowsResponse, RusotoError<ListContactFlowsError>>;
async fn list_hours_of_operations(
&self,
input: ListHoursOfOperationsRequest,
) -> Result<ListHoursOfOperationsResponse, RusotoError<ListHoursOfOperationsError>>;
async fn list_phone_numbers(
&self,
input: ListPhoneNumbersRequest,
) -> Result<ListPhoneNumbersResponse, RusotoError<ListPhoneNumbersError>>;
async fn list_queues(
&self,
input: ListQueuesRequest,
) -> Result<ListQueuesResponse, RusotoError<ListQueuesError>>;
async fn list_routing_profiles(
&self,
input: ListRoutingProfilesRequest,
) -> Result<ListRoutingProfilesResponse, RusotoError<ListRoutingProfilesError>>;
async fn list_security_profiles(
&self,
input: ListSecurityProfilesRequest,
) -> Result<ListSecurityProfilesResponse, RusotoError<ListSecurityProfilesError>>;
async fn list_tags_for_resource(
&self,
input: ListTagsForResourceRequest,
) -> Result<ListTagsForResourceResponse, RusotoError<ListTagsForResourceError>>;
async fn list_user_hierarchy_groups(
&self,
input: ListUserHierarchyGroupsRequest,
) -> Result<ListUserHierarchyGroupsResponse, RusotoError<ListUserHierarchyGroupsError>>;
async fn list_users(
&self,
input: ListUsersRequest,
) -> Result<ListUsersResponse, RusotoError<ListUsersError>>;
async fn start_chat_contact(
&self,
input: StartChatContactRequest,
) -> Result<StartChatContactResponse, RusotoError<StartChatContactError>>;
async fn start_outbound_voice_contact(
&self,
input: StartOutboundVoiceContactRequest,
) -> Result<StartOutboundVoiceContactResponse, RusotoError<StartOutboundVoiceContactError>>;
async fn stop_contact(
&self,
input: StopContactRequest,
) -> Result<StopContactResponse, RusotoError<StopContactError>>;
async fn tag_resource(
&self,
input: TagResourceRequest,
) -> Result<(), RusotoError<TagResourceError>>;
async fn untag_resource(
&self,
input: UntagResourceRequest,
) -> Result<(), RusotoError<UntagResourceError>>;
async fn update_contact_attributes(
&self,
input: UpdateContactAttributesRequest,
) -> Result<UpdateContactAttributesResponse, RusotoError<UpdateContactAttributesError>>;
async fn update_user_hierarchy(
&self,
input: UpdateUserHierarchyRequest,
) -> Result<(), RusotoError<UpdateUserHierarchyError>>;
async fn update_user_identity_info(
&self,
input: UpdateUserIdentityInfoRequest,
) -> Result<(), RusotoError<UpdateUserIdentityInfoError>>;
async fn update_user_phone_config(
&self,
input: UpdateUserPhoneConfigRequest,
) -> Result<(), RusotoError<UpdateUserPhoneConfigError>>;
async fn update_user_routing_profile(
&self,
input: UpdateUserRoutingProfileRequest,
) -> Result<(), RusotoError<UpdateUserRoutingProfileError>>;
async fn update_user_security_profiles(
&self,
input: UpdateUserSecurityProfilesRequest,
) -> Result<(), RusotoError<UpdateUserSecurityProfilesError>>;
}
#[derive(Clone)]
pub struct ConnectClient {
client: Client,
region: region::Region,
}
impl ConnectClient {
pub fn new(region: region::Region) -> ConnectClient {
ConnectClient {
client: Client::shared(),
region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> ConnectClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
D: DispatchSignedRequest + Send + Sync + 'static,
{
ConnectClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region,
}
}
pub fn new_with_client(client: Client, region: region::Region) -> ConnectClient {
ConnectClient { client, region }
}
}
#[async_trait]
impl Connect for ConnectClient {
async fn create_user(
&self,
input: CreateUserRequest,
) -> Result<CreateUserResponse, RusotoError<CreateUserError>> {
let request_uri = format!("/users/{instance_id}", instance_id = input.instance_id);
let mut request = SignedRequest::new("PUT", "connect", &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.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateUserResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateUserError::from_response(response))
}
}
async fn delete_user(
&self,
input: DeleteUserRequest,
) -> Result<(), RusotoError<DeleteUserError>> {
let request_uri = format!(
"/users/{instance_id}/{user_id}",
instance_id = input.instance_id,
user_id = input.user_id
);
let mut request = SignedRequest::new("DELETE", "connect", &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.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = ::std::mem::drop(response);
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteUserError::from_response(response))
}
}
async fn describe_user(
&self,
input: DescribeUserRequest,
) -> Result<DescribeUserResponse, RusotoError<DescribeUserError>> {
let request_uri = format!(
"/users/{instance_id}/{user_id}",
instance_id = input.instance_id,
user_id = input.user_id
);
let mut request = SignedRequest::new("GET", "connect", &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.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeUserResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DescribeUserError::from_response(response))
}
}
async fn describe_user_hierarchy_group(
&self,
input: DescribeUserHierarchyGroupRequest,
) -> Result<DescribeUserHierarchyGroupResponse, RusotoError<DescribeUserHierarchyGroupError>>
{
let request_uri = format!(
"/user-hierarchy-groups/{instance_id}/{hierarchy_group_id}",
hierarchy_group_id = input.hierarchy_group_id,
instance_id = input.instance_id
);
let mut request = SignedRequest::new("GET", "connect", &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.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeUserHierarchyGroupResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DescribeUserHierarchyGroupError::from_response(response))
}
}
async fn describe_user_hierarchy_structure(
&self,
input: DescribeUserHierarchyStructureRequest,
) -> Result<
DescribeUserHierarchyStructureResponse,
RusotoError<DescribeUserHierarchyStructureError>,
> {
let request_uri = format!(
"/user-hierarchy-structure/{instance_id}",
instance_id = input.instance_id
);
let mut request = SignedRequest::new("GET", "connect", &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.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeUserHierarchyStructureResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DescribeUserHierarchyStructureError::from_response(response))
}
}
async fn get_contact_attributes(
&self,
input: GetContactAttributesRequest,
) -> Result<GetContactAttributesResponse, RusotoError<GetContactAttributesError>> {
let request_uri = format!(
"/contact/attributes/{instance_id}/{initial_contact_id}",
initial_contact_id = input.initial_contact_id,
instance_id = input.instance_id
);
let mut request = SignedRequest::new("GET", "connect", &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.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetContactAttributesResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetContactAttributesError::from_response(response))
}
}
async fn get_current_metric_data(
&self,
input: GetCurrentMetricDataRequest,
) -> Result<GetCurrentMetricDataResponse, RusotoError<GetCurrentMetricDataError>> {
let request_uri = format!(
"/metrics/current/{instance_id}",
instance_id = input.instance_id
);
let mut request = SignedRequest::new("POST", "connect", &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.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetCurrentMetricDataResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetCurrentMetricDataError::from_response(response))
}
}
async fn get_federation_token(
&self,
input: GetFederationTokenRequest,
) -> Result<GetFederationTokenResponse, RusotoError<GetFederationTokenError>> {
let request_uri = format!(
"/user/federate/{instance_id}",
instance_id = input.instance_id
);
let mut request = SignedRequest::new("GET", "connect", &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.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetFederationTokenResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetFederationTokenError::from_response(response))
}
}
async fn get_metric_data(
&self,
input: GetMetricDataRequest,
) -> Result<GetMetricDataResponse, RusotoError<GetMetricDataError>> {
let request_uri = format!(
"/metrics/historical/{instance_id}",
instance_id = input.instance_id
);
let mut request = SignedRequest::new("POST", "connect", &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.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetMetricDataResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetMetricDataError::from_response(response))
}
}
async fn list_contact_flows(
&self,
input: ListContactFlowsRequest,
) -> Result<ListContactFlowsResponse, RusotoError<ListContactFlowsError>> {
let request_uri = format!(
"/contact-flows-summary/{instance_id}",
instance_id = input.instance_id
);
let mut request = SignedRequest::new("GET", "connect", &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.contact_flow_types {
for item in x.iter() {
params.put("contactFlowTypes", item);
}
}
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.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListContactFlowsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListContactFlowsError::from_response(response))
}
}
async fn list_hours_of_operations(
&self,
input: ListHoursOfOperationsRequest,
) -> Result<ListHoursOfOperationsResponse, RusotoError<ListHoursOfOperationsError>> {
let request_uri = format!(
"/hours-of-operations-summary/{instance_id}",
instance_id = input.instance_id
);
let mut request = SignedRequest::new("GET", "connect", &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.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListHoursOfOperationsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListHoursOfOperationsError::from_response(response))
}
}
async fn list_phone_numbers(
&self,
input: ListPhoneNumbersRequest,
) -> Result<ListPhoneNumbersResponse, RusotoError<ListPhoneNumbersError>> {
let request_uri = format!(
"/phone-numbers-summary/{instance_id}",
instance_id = input.instance_id
);
let mut request = SignedRequest::new("GET", "connect", &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.phone_number_country_codes {
for item in x.iter() {
params.put("phoneNumberCountryCodes", item);
}
}
if let Some(ref x) = input.phone_number_types {
for item in x.iter() {
params.put("phoneNumberTypes", item);
}
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListPhoneNumbersResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListPhoneNumbersError::from_response(response))
}
}
async fn list_queues(
&self,
input: ListQueuesRequest,
) -> Result<ListQueuesResponse, RusotoError<ListQueuesError>> {
let request_uri = format!(
"/queues-summary/{instance_id}",
instance_id = input.instance_id
);
let mut request = SignedRequest::new("GET", "connect", &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.queue_types {
for item in x.iter() {
params.put("queueTypes", item);
}
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListQueuesResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListQueuesError::from_response(response))
}
}
async fn list_routing_profiles(
&self,
input: ListRoutingProfilesRequest,
) -> Result<ListRoutingProfilesResponse, RusotoError<ListRoutingProfilesError>> {
let request_uri = format!(
"/routing-profiles-summary/{instance_id}",
instance_id = input.instance_id
);
let mut request = SignedRequest::new("GET", "connect", &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.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListRoutingProfilesResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListRoutingProfilesError::from_response(response))
}
}
async fn list_security_profiles(
&self,
input: ListSecurityProfilesRequest,
) -> Result<ListSecurityProfilesResponse, RusotoError<ListSecurityProfilesError>> {
let request_uri = format!(
"/security-profiles-summary/{instance_id}",
instance_id = input.instance_id
);
let mut request = SignedRequest::new("GET", "connect", &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.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListSecurityProfilesResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListSecurityProfilesError::from_response(response))
}
}
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", "connect", &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.is_success() {
let 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))
}
}
async fn list_user_hierarchy_groups(
&self,
input: ListUserHierarchyGroupsRequest,
) -> Result<ListUserHierarchyGroupsResponse, RusotoError<ListUserHierarchyGroupsError>> {
let request_uri = format!(
"/user-hierarchy-groups-summary/{instance_id}",
instance_id = input.instance_id
);
let mut request = SignedRequest::new("GET", "connect", &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.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListUserHierarchyGroupsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListUserHierarchyGroupsError::from_response(response))
}
}
async fn list_users(
&self,
input: ListUsersRequest,
) -> Result<ListUsersResponse, RusotoError<ListUsersError>> {
let request_uri = format!(
"/users-summary/{instance_id}",
instance_id = input.instance_id
);
let mut request = SignedRequest::new("GET", "connect", &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.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListUsersResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListUsersError::from_response(response))
}
}
async fn start_chat_contact(
&self,
input: StartChatContactRequest,
) -> Result<StartChatContactResponse, RusotoError<StartChatContactError>> {
let request_uri = "/contact/chat";
let mut request = SignedRequest::new("PUT", "connect", &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.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<StartChatContactResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(StartChatContactError::from_response(response))
}
}
async fn start_outbound_voice_contact(
&self,
input: StartOutboundVoiceContactRequest,
) -> Result<StartOutboundVoiceContactResponse, RusotoError<StartOutboundVoiceContactError>>
{
let request_uri = "/contact/outbound-voice";
let mut request = SignedRequest::new("PUT", "connect", &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.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<StartOutboundVoiceContactResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(StartOutboundVoiceContactError::from_response(response))
}
}
async fn stop_contact(
&self,
input: StopContactRequest,
) -> Result<StopContactResponse, RusotoError<StopContactError>> {
let request_uri = "/contact/stop";
let mut request = SignedRequest::new("POST", "connect", &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.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<StopContactResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(StopContactError::from_response(response))
}
}
async fn tag_resource(
&self,
input: TagResourceRequest,
) -> Result<(), RusotoError<TagResourceError>> {
let request_uri = format!("/tags/{resource_arn}", resource_arn = input.resource_arn);
let mut request = SignedRequest::new("POST", "connect", &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.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = ::std::mem::drop(response);
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(TagResourceError::from_response(response))
}
}
async fn untag_resource(
&self,
input: UntagResourceRequest,
) -> Result<(), RusotoError<UntagResourceError>> {
let request_uri = format!("/tags/{resource_arn}", resource_arn = input.resource_arn);
let mut request = SignedRequest::new("DELETE", "connect", &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.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = ::std::mem::drop(response);
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UntagResourceError::from_response(response))
}
}
async fn update_contact_attributes(
&self,
input: UpdateContactAttributesRequest,
) -> Result<UpdateContactAttributesResponse, RusotoError<UpdateContactAttributesError>> {
let request_uri = "/contact/attributes";
let mut request = SignedRequest::new("POST", "connect", &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.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateContactAttributesResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateContactAttributesError::from_response(response))
}
}
async fn update_user_hierarchy(
&self,
input: UpdateUserHierarchyRequest,
) -> Result<(), RusotoError<UpdateUserHierarchyError>> {
let request_uri = format!(
"/users/{instance_id}/{user_id}/hierarchy",
instance_id = input.instance_id,
user_id = input.user_id
);
let mut request = SignedRequest::new("POST", "connect", &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.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = ::std::mem::drop(response);
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateUserHierarchyError::from_response(response))
}
}
async fn update_user_identity_info(
&self,
input: UpdateUserIdentityInfoRequest,
) -> Result<(), RusotoError<UpdateUserIdentityInfoError>> {
let request_uri = format!(
"/users/{instance_id}/{user_id}/identity-info",
instance_id = input.instance_id,
user_id = input.user_id
);
let mut request = SignedRequest::new("POST", "connect", &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.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = ::std::mem::drop(response);
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateUserIdentityInfoError::from_response(response))
}
}
async fn update_user_phone_config(
&self,
input: UpdateUserPhoneConfigRequest,
) -> Result<(), RusotoError<UpdateUserPhoneConfigError>> {
let request_uri = format!(
"/users/{instance_id}/{user_id}/phone-config",
instance_id = input.instance_id,
user_id = input.user_id
);
let mut request = SignedRequest::new("POST", "connect", &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.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = ::std::mem::drop(response);
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateUserPhoneConfigError::from_response(response))
}
}
async fn update_user_routing_profile(
&self,
input: UpdateUserRoutingProfileRequest,
) -> Result<(), RusotoError<UpdateUserRoutingProfileError>> {
let request_uri = format!(
"/users/{instance_id}/{user_id}/routing-profile",
instance_id = input.instance_id,
user_id = input.user_id
);
let mut request = SignedRequest::new("POST", "connect", &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.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = ::std::mem::drop(response);
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateUserRoutingProfileError::from_response(response))
}
}
async fn update_user_security_profiles(
&self,
input: UpdateUserSecurityProfilesRequest,
) -> Result<(), RusotoError<UpdateUserSecurityProfilesError>> {
let request_uri = format!(
"/users/{instance_id}/{user_id}/security-profiles",
instance_id = input.instance_id,
user_id = input.user_id
);
let mut request = SignedRequest::new("POST", "connect", &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.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = ::std::mem::drop(response);
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateUserSecurityProfilesError::from_response(response))
}
}
}