use std::error::Error;
use std::fmt;
use std::io;
#[allow(warnings)]
use futures::future;
use futures::Future;
use rusoto_core::region;
use rusoto_core::request::{BufferedHttpResponse, DispatchSignedRequest};
use rusoto_core::{Client, RusotoFuture};
use rusoto_core::credential::{CredentialsError, ProvideAwsCredentials};
use rusoto_core::request::HttpDispatchError;
use rusoto_core::signature::SignedRequest;
use serde_json;
use serde_json::from_slice;
use serde_json::Value as SerdeJsonValue;
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct AssociateDelegateToResourceRequest {
#[serde(rename = "EntityId")]
pub entity_id: String,
#[serde(rename = "OrganizationId")]
pub organization_id: String,
#[serde(rename = "ResourceId")]
pub resource_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct AssociateDelegateToResourceResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct AssociateMemberToGroupRequest {
#[serde(rename = "GroupId")]
pub group_id: String,
#[serde(rename = "MemberId")]
pub member_id: String,
#[serde(rename = "OrganizationId")]
pub organization_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct AssociateMemberToGroupResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct BookingOptions {
#[serde(rename = "AutoAcceptRequests")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_accept_requests: Option<bool>,
#[serde(rename = "AutoDeclineConflictingRequests")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_decline_conflicting_requests: Option<bool>,
#[serde(rename = "AutoDeclineRecurringRequests")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_decline_recurring_requests: Option<bool>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CreateAliasRequest {
#[serde(rename = "Alias")]
pub alias: String,
#[serde(rename = "EntityId")]
pub entity_id: String,
#[serde(rename = "OrganizationId")]
pub organization_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CreateAliasResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CreateGroupRequest {
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "OrganizationId")]
pub organization_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CreateGroupResponse {
#[serde(rename = "GroupId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub group_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CreateResourceRequest {
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "OrganizationId")]
pub organization_id: String,
#[serde(rename = "Type")]
pub type_: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CreateResourceResponse {
#[serde(rename = "ResourceId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct CreateUserRequest {
#[serde(rename = "DisplayName")]
pub display_name: String,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "OrganizationId")]
pub organization_id: String,
#[serde(rename = "Password")]
pub password: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct CreateUserResponse {
#[serde(rename = "UserId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct Delegate {
#[serde(rename = "Id")]
pub id: String,
#[serde(rename = "Type")]
pub type_: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DeleteAliasRequest {
#[serde(rename = "Alias")]
pub alias: String,
#[serde(rename = "EntityId")]
pub entity_id: String,
#[serde(rename = "OrganizationId")]
pub organization_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DeleteAliasResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DeleteGroupRequest {
#[serde(rename = "GroupId")]
pub group_id: String,
#[serde(rename = "OrganizationId")]
pub organization_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DeleteGroupResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DeleteMailboxPermissionsRequest {
#[serde(rename = "EntityId")]
pub entity_id: String,
#[serde(rename = "GranteeId")]
pub grantee_id: String,
#[serde(rename = "OrganizationId")]
pub organization_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DeleteMailboxPermissionsResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DeleteResourceRequest {
#[serde(rename = "OrganizationId")]
pub organization_id: String,
#[serde(rename = "ResourceId")]
pub resource_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DeleteResourceResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DeleteUserRequest {
#[serde(rename = "OrganizationId")]
pub organization_id: String,
#[serde(rename = "UserId")]
pub user_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DeleteUserResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DeregisterFromWorkMailRequest {
#[serde(rename = "EntityId")]
pub entity_id: String,
#[serde(rename = "OrganizationId")]
pub organization_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DeregisterFromWorkMailResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DescribeGroupRequest {
#[serde(rename = "GroupId")]
pub group_id: String,
#[serde(rename = "OrganizationId")]
pub organization_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DescribeGroupResponse {
#[serde(rename = "DisabledDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub disabled_date: Option<f64>,
#[serde(rename = "Email")]
#[serde(skip_serializing_if = "Option::is_none")]
pub email: Option<String>,
#[serde(rename = "EnabledDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enabled_date: Option<f64>,
#[serde(rename = "GroupId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub group_id: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "State")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DescribeOrganizationRequest {
#[serde(rename = "OrganizationId")]
pub organization_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DescribeOrganizationResponse {
#[serde(rename = "Alias")]
#[serde(skip_serializing_if = "Option::is_none")]
pub alias: Option<String>,
#[serde(rename = "CompletedDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub completed_date: Option<f64>,
#[serde(rename = "DefaultMailDomain")]
#[serde(skip_serializing_if = "Option::is_none")]
pub default_mail_domain: Option<String>,
#[serde(rename = "DirectoryId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub directory_id: Option<String>,
#[serde(rename = "DirectoryType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub directory_type: Option<String>,
#[serde(rename = "ErrorMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_message: Option<String>,
#[serde(rename = "OrganizationId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub organization_id: Option<String>,
#[serde(rename = "State")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DescribeResourceRequest {
#[serde(rename = "OrganizationId")]
pub organization_id: String,
#[serde(rename = "ResourceId")]
pub resource_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DescribeResourceResponse {
#[serde(rename = "BookingOptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub booking_options: Option<BookingOptions>,
#[serde(rename = "DisabledDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub disabled_date: Option<f64>,
#[serde(rename = "Email")]
#[serde(skip_serializing_if = "Option::is_none")]
pub email: Option<String>,
#[serde(rename = "EnabledDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enabled_date: Option<f64>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "ResourceId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_id: Option<String>,
#[serde(rename = "State")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state: Option<String>,
#[serde(rename = "Type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DescribeUserRequest {
#[serde(rename = "OrganizationId")]
pub organization_id: String,
#[serde(rename = "UserId")]
pub user_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DescribeUserResponse {
#[serde(rename = "DisabledDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub disabled_date: Option<f64>,
#[serde(rename = "DisplayName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub display_name: Option<String>,
#[serde(rename = "Email")]
#[serde(skip_serializing_if = "Option::is_none")]
pub email: Option<String>,
#[serde(rename = "EnabledDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enabled_date: Option<f64>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "State")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state: Option<String>,
#[serde(rename = "UserId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_id: Option<String>,
#[serde(rename = "UserRole")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_role: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DisassociateDelegateFromResourceRequest {
#[serde(rename = "EntityId")]
pub entity_id: String,
#[serde(rename = "OrganizationId")]
pub organization_id: String,
#[serde(rename = "ResourceId")]
pub resource_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DisassociateDelegateFromResourceResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct DisassociateMemberFromGroupRequest {
#[serde(rename = "GroupId")]
pub group_id: String,
#[serde(rename = "MemberId")]
pub member_id: String,
#[serde(rename = "OrganizationId")]
pub organization_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct DisassociateMemberFromGroupResponse {}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct Group {
#[serde(rename = "DisabledDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub disabled_date: Option<f64>,
#[serde(rename = "Email")]
#[serde(skip_serializing_if = "Option::is_none")]
pub email: Option<String>,
#[serde(rename = "EnabledDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enabled_date: Option<f64>,
#[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 = "State")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ListAliasesRequest {
#[serde(rename = "EntityId")]
pub entity_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 = "OrganizationId")]
pub organization_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ListAliasesResponse {
#[serde(rename = "Aliases")]
#[serde(skip_serializing_if = "Option::is_none")]
pub aliases: Option<Vec<String>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ListGroupMembersRequest {
#[serde(rename = "GroupId")]
pub group_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 = "OrganizationId")]
pub organization_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ListGroupMembersResponse {
#[serde(rename = "Members")]
#[serde(skip_serializing_if = "Option::is_none")]
pub members: Option<Vec<Member>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ListGroupsRequest {
#[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 = "OrganizationId")]
pub organization_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ListGroupsResponse {
#[serde(rename = "Groups")]
#[serde(skip_serializing_if = "Option::is_none")]
pub groups: Option<Vec<Group>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ListMailboxPermissionsRequest {
#[serde(rename = "EntityId")]
pub entity_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 = "OrganizationId")]
pub organization_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ListMailboxPermissionsResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Permissions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub permissions: Option<Vec<Permission>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ListOrganizationsRequest {
#[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(test, derive(Serialize))]
pub struct ListOrganizationsResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "OrganizationSummaries")]
#[serde(skip_serializing_if = "Option::is_none")]
pub organization_summaries: Option<Vec<OrganizationSummary>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ListResourceDelegatesRequest {
#[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 = "OrganizationId")]
pub organization_id: String,
#[serde(rename = "ResourceId")]
pub resource_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ListResourceDelegatesResponse {
#[serde(rename = "Delegates")]
#[serde(skip_serializing_if = "Option::is_none")]
pub delegates: Option<Vec<Delegate>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ListResourcesRequest {
#[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 = "OrganizationId")]
pub organization_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ListResourcesResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Resources")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resources: Option<Vec<Resource>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ListUsersRequest {
#[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 = "OrganizationId")]
pub organization_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ListUsersResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Users")]
#[serde(skip_serializing_if = "Option::is_none")]
pub users: Option<Vec<User>>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct Member {
#[serde(rename = "DisabledDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub disabled_date: Option<f64>,
#[serde(rename = "EnabledDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enabled_date: Option<f64>,
#[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 = "State")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state: Option<String>,
#[serde(rename = "Type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct OrganizationSummary {
#[serde(rename = "Alias")]
#[serde(skip_serializing_if = "Option::is_none")]
pub alias: Option<String>,
#[serde(rename = "ErrorMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_message: Option<String>,
#[serde(rename = "OrganizationId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub organization_id: Option<String>,
#[serde(rename = "State")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct Permission {
#[serde(rename = "GranteeId")]
pub grantee_id: String,
#[serde(rename = "GranteeType")]
pub grantee_type: String,
#[serde(rename = "PermissionValues")]
pub permission_values: Vec<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct PutMailboxPermissionsRequest {
#[serde(rename = "EntityId")]
pub entity_id: String,
#[serde(rename = "GranteeId")]
pub grantee_id: String,
#[serde(rename = "OrganizationId")]
pub organization_id: String,
#[serde(rename = "PermissionValues")]
pub permission_values: Vec<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct PutMailboxPermissionsResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct RegisterToWorkMailRequest {
#[serde(rename = "Email")]
pub email: String,
#[serde(rename = "EntityId")]
pub entity_id: String,
#[serde(rename = "OrganizationId")]
pub organization_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct RegisterToWorkMailResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct ResetPasswordRequest {
#[serde(rename = "OrganizationId")]
pub organization_id: String,
#[serde(rename = "Password")]
pub password: String,
#[serde(rename = "UserId")]
pub user_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct ResetPasswordResponse {}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct Resource {
#[serde(rename = "DisabledDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub disabled_date: Option<f64>,
#[serde(rename = "Email")]
#[serde(skip_serializing_if = "Option::is_none")]
pub email: Option<String>,
#[serde(rename = "EnabledDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enabled_date: Option<f64>,
#[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 = "State")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state: Option<String>,
#[serde(rename = "Type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct UpdatePrimaryEmailAddressRequest {
#[serde(rename = "Email")]
pub email: String,
#[serde(rename = "EntityId")]
pub entity_id: String,
#[serde(rename = "OrganizationId")]
pub organization_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct UpdatePrimaryEmailAddressResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
pub struct UpdateResourceRequest {
#[serde(rename = "BookingOptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub booking_options: Option<BookingOptions>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "OrganizationId")]
pub organization_id: String,
#[serde(rename = "ResourceId")]
pub resource_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct UpdateResourceResponse {}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(test, derive(Serialize))]
pub struct User {
#[serde(rename = "DisabledDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub disabled_date: Option<f64>,
#[serde(rename = "DisplayName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub display_name: Option<String>,
#[serde(rename = "Email")]
#[serde(skip_serializing_if = "Option::is_none")]
pub email: Option<String>,
#[serde(rename = "EnabledDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enabled_date: Option<f64>,
#[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 = "State")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state: Option<String>,
#[serde(rename = "UserRole")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_role: Option<String>,
}
#[derive(Debug, PartialEq)]
pub enum AssociateDelegateToResourceError {
EntityNotFound(String),
EntityState(String),
InvalidParameter(String),
OrganizationNotFound(String),
OrganizationState(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl AssociateDelegateToResourceError {
pub fn from_response(res: BufferedHttpResponse) -> AssociateDelegateToResourceError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"EntityNotFoundException" => {
return AssociateDelegateToResourceError::EntityNotFound(String::from(
error_message,
));
}
"EntityStateException" => {
return AssociateDelegateToResourceError::EntityState(String::from(
error_message,
));
}
"InvalidParameterException" => {
return AssociateDelegateToResourceError::InvalidParameter(String::from(
error_message,
));
}
"OrganizationNotFoundException" => {
return AssociateDelegateToResourceError::OrganizationNotFound(String::from(
error_message,
));
}
"OrganizationStateException" => {
return AssociateDelegateToResourceError::OrganizationState(String::from(
error_message,
));
}
"ValidationException" => {
return AssociateDelegateToResourceError::Validation(error_message.to_string());
}
_ => {}
}
}
return AssociateDelegateToResourceError::Unknown(res);
}
}
impl From<serde_json::error::Error> for AssociateDelegateToResourceError {
fn from(err: serde_json::error::Error) -> AssociateDelegateToResourceError {
AssociateDelegateToResourceError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for AssociateDelegateToResourceError {
fn from(err: CredentialsError) -> AssociateDelegateToResourceError {
AssociateDelegateToResourceError::Credentials(err)
}
}
impl From<HttpDispatchError> for AssociateDelegateToResourceError {
fn from(err: HttpDispatchError) -> AssociateDelegateToResourceError {
AssociateDelegateToResourceError::HttpDispatch(err)
}
}
impl From<io::Error> for AssociateDelegateToResourceError {
fn from(err: io::Error) -> AssociateDelegateToResourceError {
AssociateDelegateToResourceError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for AssociateDelegateToResourceError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for AssociateDelegateToResourceError {
fn description(&self) -> &str {
match *self {
AssociateDelegateToResourceError::EntityNotFound(ref cause) => cause,
AssociateDelegateToResourceError::EntityState(ref cause) => cause,
AssociateDelegateToResourceError::InvalidParameter(ref cause) => cause,
AssociateDelegateToResourceError::OrganizationNotFound(ref cause) => cause,
AssociateDelegateToResourceError::OrganizationState(ref cause) => cause,
AssociateDelegateToResourceError::Validation(ref cause) => cause,
AssociateDelegateToResourceError::Credentials(ref err) => err.description(),
AssociateDelegateToResourceError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
AssociateDelegateToResourceError::ParseError(ref cause) => cause,
AssociateDelegateToResourceError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum AssociateMemberToGroupError {
DirectoryServiceAuthenticationFailed(String),
DirectoryUnavailable(String),
EntityNotFound(String),
EntityState(String),
InvalidParameter(String),
OrganizationNotFound(String),
OrganizationState(String),
UnsupportedOperation(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl AssociateMemberToGroupError {
pub fn from_response(res: BufferedHttpResponse) -> AssociateMemberToGroupError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"DirectoryServiceAuthenticationFailedException" => {
return AssociateMemberToGroupError::DirectoryServiceAuthenticationFailed(
String::from(error_message),
);
}
"DirectoryUnavailableException" => {
return AssociateMemberToGroupError::DirectoryUnavailable(String::from(
error_message,
));
}
"EntityNotFoundException" => {
return AssociateMemberToGroupError::EntityNotFound(String::from(error_message));
}
"EntityStateException" => {
return AssociateMemberToGroupError::EntityState(String::from(error_message));
}
"InvalidParameterException" => {
return AssociateMemberToGroupError::InvalidParameter(String::from(
error_message,
));
}
"OrganizationNotFoundException" => {
return AssociateMemberToGroupError::OrganizationNotFound(String::from(
error_message,
));
}
"OrganizationStateException" => {
return AssociateMemberToGroupError::OrganizationState(String::from(
error_message,
));
}
"UnsupportedOperationException" => {
return AssociateMemberToGroupError::UnsupportedOperation(String::from(
error_message,
));
}
"ValidationException" => {
return AssociateMemberToGroupError::Validation(error_message.to_string());
}
_ => {}
}
}
return AssociateMemberToGroupError::Unknown(res);
}
}
impl From<serde_json::error::Error> for AssociateMemberToGroupError {
fn from(err: serde_json::error::Error) -> AssociateMemberToGroupError {
AssociateMemberToGroupError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for AssociateMemberToGroupError {
fn from(err: CredentialsError) -> AssociateMemberToGroupError {
AssociateMemberToGroupError::Credentials(err)
}
}
impl From<HttpDispatchError> for AssociateMemberToGroupError {
fn from(err: HttpDispatchError) -> AssociateMemberToGroupError {
AssociateMemberToGroupError::HttpDispatch(err)
}
}
impl From<io::Error> for AssociateMemberToGroupError {
fn from(err: io::Error) -> AssociateMemberToGroupError {
AssociateMemberToGroupError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for AssociateMemberToGroupError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for AssociateMemberToGroupError {
fn description(&self) -> &str {
match *self {
AssociateMemberToGroupError::DirectoryServiceAuthenticationFailed(ref cause) => cause,
AssociateMemberToGroupError::DirectoryUnavailable(ref cause) => cause,
AssociateMemberToGroupError::EntityNotFound(ref cause) => cause,
AssociateMemberToGroupError::EntityState(ref cause) => cause,
AssociateMemberToGroupError::InvalidParameter(ref cause) => cause,
AssociateMemberToGroupError::OrganizationNotFound(ref cause) => cause,
AssociateMemberToGroupError::OrganizationState(ref cause) => cause,
AssociateMemberToGroupError::UnsupportedOperation(ref cause) => cause,
AssociateMemberToGroupError::Validation(ref cause) => cause,
AssociateMemberToGroupError::Credentials(ref err) => err.description(),
AssociateMemberToGroupError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
AssociateMemberToGroupError::ParseError(ref cause) => cause,
AssociateMemberToGroupError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateAliasError {
EmailAddressInUse(String),
EntityNotFound(String),
EntityState(String),
InvalidParameter(String),
MailDomainNotFound(String),
MailDomainState(String),
OrganizationNotFound(String),
OrganizationState(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateAliasError {
pub fn from_response(res: BufferedHttpResponse) -> CreateAliasError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"EmailAddressInUseException" => {
return CreateAliasError::EmailAddressInUse(String::from(error_message));
}
"EntityNotFoundException" => {
return CreateAliasError::EntityNotFound(String::from(error_message));
}
"EntityStateException" => {
return CreateAliasError::EntityState(String::from(error_message));
}
"InvalidParameterException" => {
return CreateAliasError::InvalidParameter(String::from(error_message));
}
"MailDomainNotFoundException" => {
return CreateAliasError::MailDomainNotFound(String::from(error_message));
}
"MailDomainStateException" => {
return CreateAliasError::MailDomainState(String::from(error_message));
}
"OrganizationNotFoundException" => {
return CreateAliasError::OrganizationNotFound(String::from(error_message));
}
"OrganizationStateException" => {
return CreateAliasError::OrganizationState(String::from(error_message));
}
"ValidationException" => {
return CreateAliasError::Validation(error_message.to_string());
}
_ => {}
}
}
return CreateAliasError::Unknown(res);
}
}
impl From<serde_json::error::Error> for CreateAliasError {
fn from(err: serde_json::error::Error) -> CreateAliasError {
CreateAliasError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for CreateAliasError {
fn from(err: CredentialsError) -> CreateAliasError {
CreateAliasError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateAliasError {
fn from(err: HttpDispatchError) -> CreateAliasError {
CreateAliasError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateAliasError {
fn from(err: io::Error) -> CreateAliasError {
CreateAliasError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateAliasError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateAliasError {
fn description(&self) -> &str {
match *self {
CreateAliasError::EmailAddressInUse(ref cause) => cause,
CreateAliasError::EntityNotFound(ref cause) => cause,
CreateAliasError::EntityState(ref cause) => cause,
CreateAliasError::InvalidParameter(ref cause) => cause,
CreateAliasError::MailDomainNotFound(ref cause) => cause,
CreateAliasError::MailDomainState(ref cause) => cause,
CreateAliasError::OrganizationNotFound(ref cause) => cause,
CreateAliasError::OrganizationState(ref cause) => cause,
CreateAliasError::Validation(ref cause) => cause,
CreateAliasError::Credentials(ref err) => err.description(),
CreateAliasError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
CreateAliasError::ParseError(ref cause) => cause,
CreateAliasError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateGroupError {
DirectoryServiceAuthenticationFailed(String),
DirectoryUnavailable(String),
InvalidParameter(String),
NameAvailability(String),
OrganizationNotFound(String),
OrganizationState(String),
ReservedName(String),
UnsupportedOperation(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateGroupError {
pub fn from_response(res: BufferedHttpResponse) -> CreateGroupError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"DirectoryServiceAuthenticationFailedException" => {
return CreateGroupError::DirectoryServiceAuthenticationFailed(String::from(
error_message,
));
}
"DirectoryUnavailableException" => {
return CreateGroupError::DirectoryUnavailable(String::from(error_message));
}
"InvalidParameterException" => {
return CreateGroupError::InvalidParameter(String::from(error_message));
}
"NameAvailabilityException" => {
return CreateGroupError::NameAvailability(String::from(error_message));
}
"OrganizationNotFoundException" => {
return CreateGroupError::OrganizationNotFound(String::from(error_message));
}
"OrganizationStateException" => {
return CreateGroupError::OrganizationState(String::from(error_message));
}
"ReservedNameException" => {
return CreateGroupError::ReservedName(String::from(error_message));
}
"UnsupportedOperationException" => {
return CreateGroupError::UnsupportedOperation(String::from(error_message));
}
"ValidationException" => {
return CreateGroupError::Validation(error_message.to_string());
}
_ => {}
}
}
return CreateGroupError::Unknown(res);
}
}
impl From<serde_json::error::Error> for CreateGroupError {
fn from(err: serde_json::error::Error) -> CreateGroupError {
CreateGroupError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for CreateGroupError {
fn from(err: CredentialsError) -> CreateGroupError {
CreateGroupError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateGroupError {
fn from(err: HttpDispatchError) -> CreateGroupError {
CreateGroupError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateGroupError {
fn from(err: io::Error) -> CreateGroupError {
CreateGroupError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateGroupError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateGroupError {
fn description(&self) -> &str {
match *self {
CreateGroupError::DirectoryServiceAuthenticationFailed(ref cause) => cause,
CreateGroupError::DirectoryUnavailable(ref cause) => cause,
CreateGroupError::InvalidParameter(ref cause) => cause,
CreateGroupError::NameAvailability(ref cause) => cause,
CreateGroupError::OrganizationNotFound(ref cause) => cause,
CreateGroupError::OrganizationState(ref cause) => cause,
CreateGroupError::ReservedName(ref cause) => cause,
CreateGroupError::UnsupportedOperation(ref cause) => cause,
CreateGroupError::Validation(ref cause) => cause,
CreateGroupError::Credentials(ref err) => err.description(),
CreateGroupError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
CreateGroupError::ParseError(ref cause) => cause,
CreateGroupError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateResourceError {
DirectoryServiceAuthenticationFailed(String),
DirectoryUnavailable(String),
InvalidParameter(String),
NameAvailability(String),
OrganizationNotFound(String),
OrganizationState(String),
ReservedName(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateResourceError {
pub fn from_response(res: BufferedHttpResponse) -> CreateResourceError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"DirectoryServiceAuthenticationFailedException" => {
return CreateResourceError::DirectoryServiceAuthenticationFailed(String::from(
error_message,
));
}
"DirectoryUnavailableException" => {
return CreateResourceError::DirectoryUnavailable(String::from(error_message));
}
"InvalidParameterException" => {
return CreateResourceError::InvalidParameter(String::from(error_message));
}
"NameAvailabilityException" => {
return CreateResourceError::NameAvailability(String::from(error_message));
}
"OrganizationNotFoundException" => {
return CreateResourceError::OrganizationNotFound(String::from(error_message));
}
"OrganizationStateException" => {
return CreateResourceError::OrganizationState(String::from(error_message));
}
"ReservedNameException" => {
return CreateResourceError::ReservedName(String::from(error_message));
}
"ValidationException" => {
return CreateResourceError::Validation(error_message.to_string());
}
_ => {}
}
}
return CreateResourceError::Unknown(res);
}
}
impl From<serde_json::error::Error> for CreateResourceError {
fn from(err: serde_json::error::Error) -> CreateResourceError {
CreateResourceError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for CreateResourceError {
fn from(err: CredentialsError) -> CreateResourceError {
CreateResourceError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateResourceError {
fn from(err: HttpDispatchError) -> CreateResourceError {
CreateResourceError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateResourceError {
fn from(err: io::Error) -> CreateResourceError {
CreateResourceError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateResourceError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateResourceError {
fn description(&self) -> &str {
match *self {
CreateResourceError::DirectoryServiceAuthenticationFailed(ref cause) => cause,
CreateResourceError::DirectoryUnavailable(ref cause) => cause,
CreateResourceError::InvalidParameter(ref cause) => cause,
CreateResourceError::NameAvailability(ref cause) => cause,
CreateResourceError::OrganizationNotFound(ref cause) => cause,
CreateResourceError::OrganizationState(ref cause) => cause,
CreateResourceError::ReservedName(ref cause) => cause,
CreateResourceError::Validation(ref cause) => cause,
CreateResourceError::Credentials(ref err) => err.description(),
CreateResourceError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
CreateResourceError::ParseError(ref cause) => cause,
CreateResourceError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum CreateUserError {
DirectoryServiceAuthenticationFailed(String),
DirectoryUnavailable(String),
InvalidParameter(String),
InvalidPassword(String),
NameAvailability(String),
OrganizationNotFound(String),
OrganizationState(String),
ReservedName(String),
UnsupportedOperation(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl CreateUserError {
pub fn from_response(res: BufferedHttpResponse) -> CreateUserError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"DirectoryServiceAuthenticationFailedException" => {
return CreateUserError::DirectoryServiceAuthenticationFailed(String::from(
error_message,
));
}
"DirectoryUnavailableException" => {
return CreateUserError::DirectoryUnavailable(String::from(error_message));
}
"InvalidParameterException" => {
return CreateUserError::InvalidParameter(String::from(error_message));
}
"InvalidPasswordException" => {
return CreateUserError::InvalidPassword(String::from(error_message));
}
"NameAvailabilityException" => {
return CreateUserError::NameAvailability(String::from(error_message));
}
"OrganizationNotFoundException" => {
return CreateUserError::OrganizationNotFound(String::from(error_message));
}
"OrganizationStateException" => {
return CreateUserError::OrganizationState(String::from(error_message));
}
"ReservedNameException" => {
return CreateUserError::ReservedName(String::from(error_message));
}
"UnsupportedOperationException" => {
return CreateUserError::UnsupportedOperation(String::from(error_message));
}
"ValidationException" => {
return CreateUserError::Validation(error_message.to_string());
}
_ => {}
}
}
return CreateUserError::Unknown(res);
}
}
impl From<serde_json::error::Error> for CreateUserError {
fn from(err: serde_json::error::Error) -> CreateUserError {
CreateUserError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for CreateUserError {
fn from(err: CredentialsError) -> CreateUserError {
CreateUserError::Credentials(err)
}
}
impl From<HttpDispatchError> for CreateUserError {
fn from(err: HttpDispatchError) -> CreateUserError {
CreateUserError::HttpDispatch(err)
}
}
impl From<io::Error> for CreateUserError {
fn from(err: io::Error) -> CreateUserError {
CreateUserError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for CreateUserError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for CreateUserError {
fn description(&self) -> &str {
match *self {
CreateUserError::DirectoryServiceAuthenticationFailed(ref cause) => cause,
CreateUserError::DirectoryUnavailable(ref cause) => cause,
CreateUserError::InvalidParameter(ref cause) => cause,
CreateUserError::InvalidPassword(ref cause) => cause,
CreateUserError::NameAvailability(ref cause) => cause,
CreateUserError::OrganizationNotFound(ref cause) => cause,
CreateUserError::OrganizationState(ref cause) => cause,
CreateUserError::ReservedName(ref cause) => cause,
CreateUserError::UnsupportedOperation(ref cause) => cause,
CreateUserError::Validation(ref cause) => cause,
CreateUserError::Credentials(ref err) => err.description(),
CreateUserError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
CreateUserError::ParseError(ref cause) => cause,
CreateUserError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteAliasError {
EntityNotFound(String),
EntityState(String),
InvalidParameter(String),
OrganizationNotFound(String),
OrganizationState(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteAliasError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteAliasError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"EntityNotFoundException" => {
return DeleteAliasError::EntityNotFound(String::from(error_message));
}
"EntityStateException" => {
return DeleteAliasError::EntityState(String::from(error_message));
}
"InvalidParameterException" => {
return DeleteAliasError::InvalidParameter(String::from(error_message));
}
"OrganizationNotFoundException" => {
return DeleteAliasError::OrganizationNotFound(String::from(error_message));
}
"OrganizationStateException" => {
return DeleteAliasError::OrganizationState(String::from(error_message));
}
"ValidationException" => {
return DeleteAliasError::Validation(error_message.to_string());
}
_ => {}
}
}
return DeleteAliasError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DeleteAliasError {
fn from(err: serde_json::error::Error) -> DeleteAliasError {
DeleteAliasError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DeleteAliasError {
fn from(err: CredentialsError) -> DeleteAliasError {
DeleteAliasError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteAliasError {
fn from(err: HttpDispatchError) -> DeleteAliasError {
DeleteAliasError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteAliasError {
fn from(err: io::Error) -> DeleteAliasError {
DeleteAliasError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteAliasError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteAliasError {
fn description(&self) -> &str {
match *self {
DeleteAliasError::EntityNotFound(ref cause) => cause,
DeleteAliasError::EntityState(ref cause) => cause,
DeleteAliasError::InvalidParameter(ref cause) => cause,
DeleteAliasError::OrganizationNotFound(ref cause) => cause,
DeleteAliasError::OrganizationState(ref cause) => cause,
DeleteAliasError::Validation(ref cause) => cause,
DeleteAliasError::Credentials(ref err) => err.description(),
DeleteAliasError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
DeleteAliasError::ParseError(ref cause) => cause,
DeleteAliasError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteGroupError {
DirectoryServiceAuthenticationFailed(String),
DirectoryUnavailable(String),
EntityState(String),
InvalidParameter(String),
OrganizationNotFound(String),
OrganizationState(String),
UnsupportedOperation(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteGroupError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteGroupError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"DirectoryServiceAuthenticationFailedException" => {
return DeleteGroupError::DirectoryServiceAuthenticationFailed(String::from(
error_message,
));
}
"DirectoryUnavailableException" => {
return DeleteGroupError::DirectoryUnavailable(String::from(error_message));
}
"EntityStateException" => {
return DeleteGroupError::EntityState(String::from(error_message));
}
"InvalidParameterException" => {
return DeleteGroupError::InvalidParameter(String::from(error_message));
}
"OrganizationNotFoundException" => {
return DeleteGroupError::OrganizationNotFound(String::from(error_message));
}
"OrganizationStateException" => {
return DeleteGroupError::OrganizationState(String::from(error_message));
}
"UnsupportedOperationException" => {
return DeleteGroupError::UnsupportedOperation(String::from(error_message));
}
"ValidationException" => {
return DeleteGroupError::Validation(error_message.to_string());
}
_ => {}
}
}
return DeleteGroupError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DeleteGroupError {
fn from(err: serde_json::error::Error) -> DeleteGroupError {
DeleteGroupError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DeleteGroupError {
fn from(err: CredentialsError) -> DeleteGroupError {
DeleteGroupError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteGroupError {
fn from(err: HttpDispatchError) -> DeleteGroupError {
DeleteGroupError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteGroupError {
fn from(err: io::Error) -> DeleteGroupError {
DeleteGroupError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteGroupError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteGroupError {
fn description(&self) -> &str {
match *self {
DeleteGroupError::DirectoryServiceAuthenticationFailed(ref cause) => cause,
DeleteGroupError::DirectoryUnavailable(ref cause) => cause,
DeleteGroupError::EntityState(ref cause) => cause,
DeleteGroupError::InvalidParameter(ref cause) => cause,
DeleteGroupError::OrganizationNotFound(ref cause) => cause,
DeleteGroupError::OrganizationState(ref cause) => cause,
DeleteGroupError::UnsupportedOperation(ref cause) => cause,
DeleteGroupError::Validation(ref cause) => cause,
DeleteGroupError::Credentials(ref err) => err.description(),
DeleteGroupError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
DeleteGroupError::ParseError(ref cause) => cause,
DeleteGroupError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteMailboxPermissionsError {
EntityNotFound(String),
EntityState(String),
InvalidParameter(String),
OrganizationNotFound(String),
OrganizationState(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteMailboxPermissionsError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteMailboxPermissionsError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"EntityNotFoundException" => {
return DeleteMailboxPermissionsError::EntityNotFound(String::from(
error_message,
));
}
"EntityStateException" => {
return DeleteMailboxPermissionsError::EntityState(String::from(error_message));
}
"InvalidParameterException" => {
return DeleteMailboxPermissionsError::InvalidParameter(String::from(
error_message,
));
}
"OrganizationNotFoundException" => {
return DeleteMailboxPermissionsError::OrganizationNotFound(String::from(
error_message,
));
}
"OrganizationStateException" => {
return DeleteMailboxPermissionsError::OrganizationState(String::from(
error_message,
));
}
"ValidationException" => {
return DeleteMailboxPermissionsError::Validation(error_message.to_string());
}
_ => {}
}
}
return DeleteMailboxPermissionsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DeleteMailboxPermissionsError {
fn from(err: serde_json::error::Error) -> DeleteMailboxPermissionsError {
DeleteMailboxPermissionsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DeleteMailboxPermissionsError {
fn from(err: CredentialsError) -> DeleteMailboxPermissionsError {
DeleteMailboxPermissionsError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteMailboxPermissionsError {
fn from(err: HttpDispatchError) -> DeleteMailboxPermissionsError {
DeleteMailboxPermissionsError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteMailboxPermissionsError {
fn from(err: io::Error) -> DeleteMailboxPermissionsError {
DeleteMailboxPermissionsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteMailboxPermissionsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteMailboxPermissionsError {
fn description(&self) -> &str {
match *self {
DeleteMailboxPermissionsError::EntityNotFound(ref cause) => cause,
DeleteMailboxPermissionsError::EntityState(ref cause) => cause,
DeleteMailboxPermissionsError::InvalidParameter(ref cause) => cause,
DeleteMailboxPermissionsError::OrganizationNotFound(ref cause) => cause,
DeleteMailboxPermissionsError::OrganizationState(ref cause) => cause,
DeleteMailboxPermissionsError::Validation(ref cause) => cause,
DeleteMailboxPermissionsError::Credentials(ref err) => err.description(),
DeleteMailboxPermissionsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DeleteMailboxPermissionsError::ParseError(ref cause) => cause,
DeleteMailboxPermissionsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteResourceError {
EntityState(String),
InvalidParameter(String),
OrganizationNotFound(String),
OrganizationState(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteResourceError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteResourceError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"EntityStateException" => {
return DeleteResourceError::EntityState(String::from(error_message));
}
"InvalidParameterException" => {
return DeleteResourceError::InvalidParameter(String::from(error_message));
}
"OrganizationNotFoundException" => {
return DeleteResourceError::OrganizationNotFound(String::from(error_message));
}
"OrganizationStateException" => {
return DeleteResourceError::OrganizationState(String::from(error_message));
}
"ValidationException" => {
return DeleteResourceError::Validation(error_message.to_string());
}
_ => {}
}
}
return DeleteResourceError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DeleteResourceError {
fn from(err: serde_json::error::Error) -> DeleteResourceError {
DeleteResourceError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DeleteResourceError {
fn from(err: CredentialsError) -> DeleteResourceError {
DeleteResourceError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteResourceError {
fn from(err: HttpDispatchError) -> DeleteResourceError {
DeleteResourceError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteResourceError {
fn from(err: io::Error) -> DeleteResourceError {
DeleteResourceError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteResourceError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteResourceError {
fn description(&self) -> &str {
match *self {
DeleteResourceError::EntityState(ref cause) => cause,
DeleteResourceError::InvalidParameter(ref cause) => cause,
DeleteResourceError::OrganizationNotFound(ref cause) => cause,
DeleteResourceError::OrganizationState(ref cause) => cause,
DeleteResourceError::Validation(ref cause) => cause,
DeleteResourceError::Credentials(ref err) => err.description(),
DeleteResourceError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
DeleteResourceError::ParseError(ref cause) => cause,
DeleteResourceError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeleteUserError {
DirectoryServiceAuthenticationFailed(String),
DirectoryUnavailable(String),
EntityState(String),
InvalidParameter(String),
OrganizationNotFound(String),
OrganizationState(String),
UnsupportedOperation(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeleteUserError {
pub fn from_response(res: BufferedHttpResponse) -> DeleteUserError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"DirectoryServiceAuthenticationFailedException" => {
return DeleteUserError::DirectoryServiceAuthenticationFailed(String::from(
error_message,
));
}
"DirectoryUnavailableException" => {
return DeleteUserError::DirectoryUnavailable(String::from(error_message));
}
"EntityStateException" => {
return DeleteUserError::EntityState(String::from(error_message));
}
"InvalidParameterException" => {
return DeleteUserError::InvalidParameter(String::from(error_message));
}
"OrganizationNotFoundException" => {
return DeleteUserError::OrganizationNotFound(String::from(error_message));
}
"OrganizationStateException" => {
return DeleteUserError::OrganizationState(String::from(error_message));
}
"UnsupportedOperationException" => {
return DeleteUserError::UnsupportedOperation(String::from(error_message));
}
"ValidationException" => {
return DeleteUserError::Validation(error_message.to_string());
}
_ => {}
}
}
return DeleteUserError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DeleteUserError {
fn from(err: serde_json::error::Error) -> DeleteUserError {
DeleteUserError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DeleteUserError {
fn from(err: CredentialsError) -> DeleteUserError {
DeleteUserError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeleteUserError {
fn from(err: HttpDispatchError) -> DeleteUserError {
DeleteUserError::HttpDispatch(err)
}
}
impl From<io::Error> for DeleteUserError {
fn from(err: io::Error) -> DeleteUserError {
DeleteUserError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeleteUserError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeleteUserError {
fn description(&self) -> &str {
match *self {
DeleteUserError::DirectoryServiceAuthenticationFailed(ref cause) => cause,
DeleteUserError::DirectoryUnavailable(ref cause) => cause,
DeleteUserError::EntityState(ref cause) => cause,
DeleteUserError::InvalidParameter(ref cause) => cause,
DeleteUserError::OrganizationNotFound(ref cause) => cause,
DeleteUserError::OrganizationState(ref cause) => cause,
DeleteUserError::UnsupportedOperation(ref cause) => cause,
DeleteUserError::Validation(ref cause) => cause,
DeleteUserError::Credentials(ref err) => err.description(),
DeleteUserError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
DeleteUserError::ParseError(ref cause) => cause,
DeleteUserError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DeregisterFromWorkMailError {
EntityNotFound(String),
EntityState(String),
InvalidParameter(String),
OrganizationNotFound(String),
OrganizationState(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DeregisterFromWorkMailError {
pub fn from_response(res: BufferedHttpResponse) -> DeregisterFromWorkMailError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"EntityNotFoundException" => {
return DeregisterFromWorkMailError::EntityNotFound(String::from(error_message));
}
"EntityStateException" => {
return DeregisterFromWorkMailError::EntityState(String::from(error_message));
}
"InvalidParameterException" => {
return DeregisterFromWorkMailError::InvalidParameter(String::from(
error_message,
));
}
"OrganizationNotFoundException" => {
return DeregisterFromWorkMailError::OrganizationNotFound(String::from(
error_message,
));
}
"OrganizationStateException" => {
return DeregisterFromWorkMailError::OrganizationState(String::from(
error_message,
));
}
"ValidationException" => {
return DeregisterFromWorkMailError::Validation(error_message.to_string());
}
_ => {}
}
}
return DeregisterFromWorkMailError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DeregisterFromWorkMailError {
fn from(err: serde_json::error::Error) -> DeregisterFromWorkMailError {
DeregisterFromWorkMailError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DeregisterFromWorkMailError {
fn from(err: CredentialsError) -> DeregisterFromWorkMailError {
DeregisterFromWorkMailError::Credentials(err)
}
}
impl From<HttpDispatchError> for DeregisterFromWorkMailError {
fn from(err: HttpDispatchError) -> DeregisterFromWorkMailError {
DeregisterFromWorkMailError::HttpDispatch(err)
}
}
impl From<io::Error> for DeregisterFromWorkMailError {
fn from(err: io::Error) -> DeregisterFromWorkMailError {
DeregisterFromWorkMailError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DeregisterFromWorkMailError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DeregisterFromWorkMailError {
fn description(&self) -> &str {
match *self {
DeregisterFromWorkMailError::EntityNotFound(ref cause) => cause,
DeregisterFromWorkMailError::EntityState(ref cause) => cause,
DeregisterFromWorkMailError::InvalidParameter(ref cause) => cause,
DeregisterFromWorkMailError::OrganizationNotFound(ref cause) => cause,
DeregisterFromWorkMailError::OrganizationState(ref cause) => cause,
DeregisterFromWorkMailError::Validation(ref cause) => cause,
DeregisterFromWorkMailError::Credentials(ref err) => err.description(),
DeregisterFromWorkMailError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DeregisterFromWorkMailError::ParseError(ref cause) => cause,
DeregisterFromWorkMailError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeGroupError {
EntityNotFound(String),
InvalidParameter(String),
OrganizationNotFound(String),
OrganizationState(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeGroupError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeGroupError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"EntityNotFoundException" => {
return DescribeGroupError::EntityNotFound(String::from(error_message));
}
"InvalidParameterException" => {
return DescribeGroupError::InvalidParameter(String::from(error_message));
}
"OrganizationNotFoundException" => {
return DescribeGroupError::OrganizationNotFound(String::from(error_message));
}
"OrganizationStateException" => {
return DescribeGroupError::OrganizationState(String::from(error_message));
}
"ValidationException" => {
return DescribeGroupError::Validation(error_message.to_string());
}
_ => {}
}
}
return DescribeGroupError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DescribeGroupError {
fn from(err: serde_json::error::Error) -> DescribeGroupError {
DescribeGroupError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DescribeGroupError {
fn from(err: CredentialsError) -> DescribeGroupError {
DescribeGroupError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeGroupError {
fn from(err: HttpDispatchError) -> DescribeGroupError {
DescribeGroupError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeGroupError {
fn from(err: io::Error) -> DescribeGroupError {
DescribeGroupError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeGroupError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeGroupError {
fn description(&self) -> &str {
match *self {
DescribeGroupError::EntityNotFound(ref cause) => cause,
DescribeGroupError::InvalidParameter(ref cause) => cause,
DescribeGroupError::OrganizationNotFound(ref cause) => cause,
DescribeGroupError::OrganizationState(ref cause) => cause,
DescribeGroupError::Validation(ref cause) => cause,
DescribeGroupError::Credentials(ref err) => err.description(),
DescribeGroupError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
DescribeGroupError::ParseError(ref cause) => cause,
DescribeGroupError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeOrganizationError {
InvalidParameter(String),
OrganizationNotFound(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeOrganizationError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeOrganizationError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"InvalidParameterException" => {
return DescribeOrganizationError::InvalidParameter(String::from(error_message));
}
"OrganizationNotFoundException" => {
return DescribeOrganizationError::OrganizationNotFound(String::from(
error_message,
));
}
"ValidationException" => {
return DescribeOrganizationError::Validation(error_message.to_string());
}
_ => {}
}
}
return DescribeOrganizationError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DescribeOrganizationError {
fn from(err: serde_json::error::Error) -> DescribeOrganizationError {
DescribeOrganizationError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DescribeOrganizationError {
fn from(err: CredentialsError) -> DescribeOrganizationError {
DescribeOrganizationError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeOrganizationError {
fn from(err: HttpDispatchError) -> DescribeOrganizationError {
DescribeOrganizationError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeOrganizationError {
fn from(err: io::Error) -> DescribeOrganizationError {
DescribeOrganizationError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeOrganizationError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeOrganizationError {
fn description(&self) -> &str {
match *self {
DescribeOrganizationError::InvalidParameter(ref cause) => cause,
DescribeOrganizationError::OrganizationNotFound(ref cause) => cause,
DescribeOrganizationError::Validation(ref cause) => cause,
DescribeOrganizationError::Credentials(ref err) => err.description(),
DescribeOrganizationError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DescribeOrganizationError::ParseError(ref cause) => cause,
DescribeOrganizationError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeResourceError {
EntityNotFound(String),
InvalidParameter(String),
OrganizationNotFound(String),
OrganizationState(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeResourceError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeResourceError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"EntityNotFoundException" => {
return DescribeResourceError::EntityNotFound(String::from(error_message));
}
"InvalidParameterException" => {
return DescribeResourceError::InvalidParameter(String::from(error_message));
}
"OrganizationNotFoundException" => {
return DescribeResourceError::OrganizationNotFound(String::from(error_message));
}
"OrganizationStateException" => {
return DescribeResourceError::OrganizationState(String::from(error_message));
}
"ValidationException" => {
return DescribeResourceError::Validation(error_message.to_string());
}
_ => {}
}
}
return DescribeResourceError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DescribeResourceError {
fn from(err: serde_json::error::Error) -> DescribeResourceError {
DescribeResourceError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DescribeResourceError {
fn from(err: CredentialsError) -> DescribeResourceError {
DescribeResourceError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeResourceError {
fn from(err: HttpDispatchError) -> DescribeResourceError {
DescribeResourceError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeResourceError {
fn from(err: io::Error) -> DescribeResourceError {
DescribeResourceError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeResourceError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeResourceError {
fn description(&self) -> &str {
match *self {
DescribeResourceError::EntityNotFound(ref cause) => cause,
DescribeResourceError::InvalidParameter(ref cause) => cause,
DescribeResourceError::OrganizationNotFound(ref cause) => cause,
DescribeResourceError::OrganizationState(ref cause) => cause,
DescribeResourceError::Validation(ref cause) => cause,
DescribeResourceError::Credentials(ref err) => err.description(),
DescribeResourceError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
DescribeResourceError::ParseError(ref cause) => cause,
DescribeResourceError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DescribeUserError {
EntityNotFound(String),
InvalidParameter(String),
OrganizationNotFound(String),
OrganizationState(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DescribeUserError {
pub fn from_response(res: BufferedHttpResponse) -> DescribeUserError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"EntityNotFoundException" => {
return DescribeUserError::EntityNotFound(String::from(error_message));
}
"InvalidParameterException" => {
return DescribeUserError::InvalidParameter(String::from(error_message));
}
"OrganizationNotFoundException" => {
return DescribeUserError::OrganizationNotFound(String::from(error_message));
}
"OrganizationStateException" => {
return DescribeUserError::OrganizationState(String::from(error_message));
}
"ValidationException" => {
return DescribeUserError::Validation(error_message.to_string());
}
_ => {}
}
}
return DescribeUserError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DescribeUserError {
fn from(err: serde_json::error::Error) -> DescribeUserError {
DescribeUserError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DescribeUserError {
fn from(err: CredentialsError) -> DescribeUserError {
DescribeUserError::Credentials(err)
}
}
impl From<HttpDispatchError> for DescribeUserError {
fn from(err: HttpDispatchError) -> DescribeUserError {
DescribeUserError::HttpDispatch(err)
}
}
impl From<io::Error> for DescribeUserError {
fn from(err: io::Error) -> DescribeUserError {
DescribeUserError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DescribeUserError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DescribeUserError {
fn description(&self) -> &str {
match *self {
DescribeUserError::EntityNotFound(ref cause) => cause,
DescribeUserError::InvalidParameter(ref cause) => cause,
DescribeUserError::OrganizationNotFound(ref cause) => cause,
DescribeUserError::OrganizationState(ref cause) => cause,
DescribeUserError::Validation(ref cause) => cause,
DescribeUserError::Credentials(ref err) => err.description(),
DescribeUserError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
DescribeUserError::ParseError(ref cause) => cause,
DescribeUserError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DisassociateDelegateFromResourceError {
EntityNotFound(String),
EntityState(String),
InvalidParameter(String),
OrganizationNotFound(String),
OrganizationState(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DisassociateDelegateFromResourceError {
pub fn from_response(res: BufferedHttpResponse) -> DisassociateDelegateFromResourceError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"EntityNotFoundException" => {
return DisassociateDelegateFromResourceError::EntityNotFound(String::from(
error_message,
));
}
"EntityStateException" => {
return DisassociateDelegateFromResourceError::EntityState(String::from(
error_message,
));
}
"InvalidParameterException" => {
return DisassociateDelegateFromResourceError::InvalidParameter(String::from(
error_message,
));
}
"OrganizationNotFoundException" => {
return DisassociateDelegateFromResourceError::OrganizationNotFound(
String::from(error_message),
);
}
"OrganizationStateException" => {
return DisassociateDelegateFromResourceError::OrganizationState(String::from(
error_message,
));
}
"ValidationException" => {
return DisassociateDelegateFromResourceError::Validation(
error_message.to_string(),
);
}
_ => {}
}
}
return DisassociateDelegateFromResourceError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DisassociateDelegateFromResourceError {
fn from(err: serde_json::error::Error) -> DisassociateDelegateFromResourceError {
DisassociateDelegateFromResourceError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DisassociateDelegateFromResourceError {
fn from(err: CredentialsError) -> DisassociateDelegateFromResourceError {
DisassociateDelegateFromResourceError::Credentials(err)
}
}
impl From<HttpDispatchError> for DisassociateDelegateFromResourceError {
fn from(err: HttpDispatchError) -> DisassociateDelegateFromResourceError {
DisassociateDelegateFromResourceError::HttpDispatch(err)
}
}
impl From<io::Error> for DisassociateDelegateFromResourceError {
fn from(err: io::Error) -> DisassociateDelegateFromResourceError {
DisassociateDelegateFromResourceError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DisassociateDelegateFromResourceError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DisassociateDelegateFromResourceError {
fn description(&self) -> &str {
match *self {
DisassociateDelegateFromResourceError::EntityNotFound(ref cause) => cause,
DisassociateDelegateFromResourceError::EntityState(ref cause) => cause,
DisassociateDelegateFromResourceError::InvalidParameter(ref cause) => cause,
DisassociateDelegateFromResourceError::OrganizationNotFound(ref cause) => cause,
DisassociateDelegateFromResourceError::OrganizationState(ref cause) => cause,
DisassociateDelegateFromResourceError::Validation(ref cause) => cause,
DisassociateDelegateFromResourceError::Credentials(ref err) => err.description(),
DisassociateDelegateFromResourceError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DisassociateDelegateFromResourceError::ParseError(ref cause) => cause,
DisassociateDelegateFromResourceError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum DisassociateMemberFromGroupError {
DirectoryServiceAuthenticationFailed(String),
DirectoryUnavailable(String),
EntityNotFound(String),
EntityState(String),
InvalidParameter(String),
OrganizationNotFound(String),
OrganizationState(String),
UnsupportedOperation(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl DisassociateMemberFromGroupError {
pub fn from_response(res: BufferedHttpResponse) -> DisassociateMemberFromGroupError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"DirectoryServiceAuthenticationFailedException" => {
return DisassociateMemberFromGroupError::DirectoryServiceAuthenticationFailed(
String::from(error_message),
);
}
"DirectoryUnavailableException" => {
return DisassociateMemberFromGroupError::DirectoryUnavailable(String::from(
error_message,
));
}
"EntityNotFoundException" => {
return DisassociateMemberFromGroupError::EntityNotFound(String::from(
error_message,
));
}
"EntityStateException" => {
return DisassociateMemberFromGroupError::EntityState(String::from(
error_message,
));
}
"InvalidParameterException" => {
return DisassociateMemberFromGroupError::InvalidParameter(String::from(
error_message,
));
}
"OrganizationNotFoundException" => {
return DisassociateMemberFromGroupError::OrganizationNotFound(String::from(
error_message,
));
}
"OrganizationStateException" => {
return DisassociateMemberFromGroupError::OrganizationState(String::from(
error_message,
));
}
"UnsupportedOperationException" => {
return DisassociateMemberFromGroupError::UnsupportedOperation(String::from(
error_message,
));
}
"ValidationException" => {
return DisassociateMemberFromGroupError::Validation(error_message.to_string());
}
_ => {}
}
}
return DisassociateMemberFromGroupError::Unknown(res);
}
}
impl From<serde_json::error::Error> for DisassociateMemberFromGroupError {
fn from(err: serde_json::error::Error) -> DisassociateMemberFromGroupError {
DisassociateMemberFromGroupError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for DisassociateMemberFromGroupError {
fn from(err: CredentialsError) -> DisassociateMemberFromGroupError {
DisassociateMemberFromGroupError::Credentials(err)
}
}
impl From<HttpDispatchError> for DisassociateMemberFromGroupError {
fn from(err: HttpDispatchError) -> DisassociateMemberFromGroupError {
DisassociateMemberFromGroupError::HttpDispatch(err)
}
}
impl From<io::Error> for DisassociateMemberFromGroupError {
fn from(err: io::Error) -> DisassociateMemberFromGroupError {
DisassociateMemberFromGroupError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for DisassociateMemberFromGroupError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for DisassociateMemberFromGroupError {
fn description(&self) -> &str {
match *self {
DisassociateMemberFromGroupError::DirectoryServiceAuthenticationFailed(ref cause) => {
cause
}
DisassociateMemberFromGroupError::DirectoryUnavailable(ref cause) => cause,
DisassociateMemberFromGroupError::EntityNotFound(ref cause) => cause,
DisassociateMemberFromGroupError::EntityState(ref cause) => cause,
DisassociateMemberFromGroupError::InvalidParameter(ref cause) => cause,
DisassociateMemberFromGroupError::OrganizationNotFound(ref cause) => cause,
DisassociateMemberFromGroupError::OrganizationState(ref cause) => cause,
DisassociateMemberFromGroupError::UnsupportedOperation(ref cause) => cause,
DisassociateMemberFromGroupError::Validation(ref cause) => cause,
DisassociateMemberFromGroupError::Credentials(ref err) => err.description(),
DisassociateMemberFromGroupError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
DisassociateMemberFromGroupError::ParseError(ref cause) => cause,
DisassociateMemberFromGroupError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListAliasesError {
EntityNotFound(String),
EntityState(String),
InvalidParameter(String),
OrganizationNotFound(String),
OrganizationState(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListAliasesError {
pub fn from_response(res: BufferedHttpResponse) -> ListAliasesError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"EntityNotFoundException" => {
return ListAliasesError::EntityNotFound(String::from(error_message));
}
"EntityStateException" => {
return ListAliasesError::EntityState(String::from(error_message));
}
"InvalidParameterException" => {
return ListAliasesError::InvalidParameter(String::from(error_message));
}
"OrganizationNotFoundException" => {
return ListAliasesError::OrganizationNotFound(String::from(error_message));
}
"OrganizationStateException" => {
return ListAliasesError::OrganizationState(String::from(error_message));
}
"ValidationException" => {
return ListAliasesError::Validation(error_message.to_string());
}
_ => {}
}
}
return ListAliasesError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ListAliasesError {
fn from(err: serde_json::error::Error) -> ListAliasesError {
ListAliasesError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ListAliasesError {
fn from(err: CredentialsError) -> ListAliasesError {
ListAliasesError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListAliasesError {
fn from(err: HttpDispatchError) -> ListAliasesError {
ListAliasesError::HttpDispatch(err)
}
}
impl From<io::Error> for ListAliasesError {
fn from(err: io::Error) -> ListAliasesError {
ListAliasesError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListAliasesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListAliasesError {
fn description(&self) -> &str {
match *self {
ListAliasesError::EntityNotFound(ref cause) => cause,
ListAliasesError::EntityState(ref cause) => cause,
ListAliasesError::InvalidParameter(ref cause) => cause,
ListAliasesError::OrganizationNotFound(ref cause) => cause,
ListAliasesError::OrganizationState(ref cause) => cause,
ListAliasesError::Validation(ref cause) => cause,
ListAliasesError::Credentials(ref err) => err.description(),
ListAliasesError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
ListAliasesError::ParseError(ref cause) => cause,
ListAliasesError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListGroupMembersError {
EntityNotFound(String),
EntityState(String),
InvalidParameter(String),
OrganizationNotFound(String),
OrganizationState(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListGroupMembersError {
pub fn from_response(res: BufferedHttpResponse) -> ListGroupMembersError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"EntityNotFoundException" => {
return ListGroupMembersError::EntityNotFound(String::from(error_message));
}
"EntityStateException" => {
return ListGroupMembersError::EntityState(String::from(error_message));
}
"InvalidParameterException" => {
return ListGroupMembersError::InvalidParameter(String::from(error_message));
}
"OrganizationNotFoundException" => {
return ListGroupMembersError::OrganizationNotFound(String::from(error_message));
}
"OrganizationStateException" => {
return ListGroupMembersError::OrganizationState(String::from(error_message));
}
"ValidationException" => {
return ListGroupMembersError::Validation(error_message.to_string());
}
_ => {}
}
}
return ListGroupMembersError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ListGroupMembersError {
fn from(err: serde_json::error::Error) -> ListGroupMembersError {
ListGroupMembersError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ListGroupMembersError {
fn from(err: CredentialsError) -> ListGroupMembersError {
ListGroupMembersError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListGroupMembersError {
fn from(err: HttpDispatchError) -> ListGroupMembersError {
ListGroupMembersError::HttpDispatch(err)
}
}
impl From<io::Error> for ListGroupMembersError {
fn from(err: io::Error) -> ListGroupMembersError {
ListGroupMembersError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListGroupMembersError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListGroupMembersError {
fn description(&self) -> &str {
match *self {
ListGroupMembersError::EntityNotFound(ref cause) => cause,
ListGroupMembersError::EntityState(ref cause) => cause,
ListGroupMembersError::InvalidParameter(ref cause) => cause,
ListGroupMembersError::OrganizationNotFound(ref cause) => cause,
ListGroupMembersError::OrganizationState(ref cause) => cause,
ListGroupMembersError::Validation(ref cause) => cause,
ListGroupMembersError::Credentials(ref err) => err.description(),
ListGroupMembersError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
ListGroupMembersError::ParseError(ref cause) => cause,
ListGroupMembersError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListGroupsError {
EntityNotFound(String),
InvalidParameter(String),
OrganizationNotFound(String),
OrganizationState(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListGroupsError {
pub fn from_response(res: BufferedHttpResponse) -> ListGroupsError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"EntityNotFoundException" => {
return ListGroupsError::EntityNotFound(String::from(error_message));
}
"InvalidParameterException" => {
return ListGroupsError::InvalidParameter(String::from(error_message));
}
"OrganizationNotFoundException" => {
return ListGroupsError::OrganizationNotFound(String::from(error_message));
}
"OrganizationStateException" => {
return ListGroupsError::OrganizationState(String::from(error_message));
}
"ValidationException" => {
return ListGroupsError::Validation(error_message.to_string());
}
_ => {}
}
}
return ListGroupsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ListGroupsError {
fn from(err: serde_json::error::Error) -> ListGroupsError {
ListGroupsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ListGroupsError {
fn from(err: CredentialsError) -> ListGroupsError {
ListGroupsError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListGroupsError {
fn from(err: HttpDispatchError) -> ListGroupsError {
ListGroupsError::HttpDispatch(err)
}
}
impl From<io::Error> for ListGroupsError {
fn from(err: io::Error) -> ListGroupsError {
ListGroupsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListGroupsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListGroupsError {
fn description(&self) -> &str {
match *self {
ListGroupsError::EntityNotFound(ref cause) => cause,
ListGroupsError::InvalidParameter(ref cause) => cause,
ListGroupsError::OrganizationNotFound(ref cause) => cause,
ListGroupsError::OrganizationState(ref cause) => cause,
ListGroupsError::Validation(ref cause) => cause,
ListGroupsError::Credentials(ref err) => err.description(),
ListGroupsError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
ListGroupsError::ParseError(ref cause) => cause,
ListGroupsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListMailboxPermissionsError {
EntityNotFound(String),
InvalidParameter(String),
OrganizationNotFound(String),
OrganizationState(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListMailboxPermissionsError {
pub fn from_response(res: BufferedHttpResponse) -> ListMailboxPermissionsError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"EntityNotFoundException" => {
return ListMailboxPermissionsError::EntityNotFound(String::from(error_message));
}
"InvalidParameterException" => {
return ListMailboxPermissionsError::InvalidParameter(String::from(
error_message,
));
}
"OrganizationNotFoundException" => {
return ListMailboxPermissionsError::OrganizationNotFound(String::from(
error_message,
));
}
"OrganizationStateException" => {
return ListMailboxPermissionsError::OrganizationState(String::from(
error_message,
));
}
"ValidationException" => {
return ListMailboxPermissionsError::Validation(error_message.to_string());
}
_ => {}
}
}
return ListMailboxPermissionsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ListMailboxPermissionsError {
fn from(err: serde_json::error::Error) -> ListMailboxPermissionsError {
ListMailboxPermissionsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ListMailboxPermissionsError {
fn from(err: CredentialsError) -> ListMailboxPermissionsError {
ListMailboxPermissionsError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListMailboxPermissionsError {
fn from(err: HttpDispatchError) -> ListMailboxPermissionsError {
ListMailboxPermissionsError::HttpDispatch(err)
}
}
impl From<io::Error> for ListMailboxPermissionsError {
fn from(err: io::Error) -> ListMailboxPermissionsError {
ListMailboxPermissionsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListMailboxPermissionsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListMailboxPermissionsError {
fn description(&self) -> &str {
match *self {
ListMailboxPermissionsError::EntityNotFound(ref cause) => cause,
ListMailboxPermissionsError::InvalidParameter(ref cause) => cause,
ListMailboxPermissionsError::OrganizationNotFound(ref cause) => cause,
ListMailboxPermissionsError::OrganizationState(ref cause) => cause,
ListMailboxPermissionsError::Validation(ref cause) => cause,
ListMailboxPermissionsError::Credentials(ref err) => err.description(),
ListMailboxPermissionsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ListMailboxPermissionsError::ParseError(ref cause) => cause,
ListMailboxPermissionsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListOrganizationsError {
InvalidParameter(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListOrganizationsError {
pub fn from_response(res: BufferedHttpResponse) -> ListOrganizationsError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"InvalidParameterException" => {
return ListOrganizationsError::InvalidParameter(String::from(error_message));
}
"ValidationException" => {
return ListOrganizationsError::Validation(error_message.to_string());
}
_ => {}
}
}
return ListOrganizationsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ListOrganizationsError {
fn from(err: serde_json::error::Error) -> ListOrganizationsError {
ListOrganizationsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ListOrganizationsError {
fn from(err: CredentialsError) -> ListOrganizationsError {
ListOrganizationsError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListOrganizationsError {
fn from(err: HttpDispatchError) -> ListOrganizationsError {
ListOrganizationsError::HttpDispatch(err)
}
}
impl From<io::Error> for ListOrganizationsError {
fn from(err: io::Error) -> ListOrganizationsError {
ListOrganizationsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListOrganizationsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListOrganizationsError {
fn description(&self) -> &str {
match *self {
ListOrganizationsError::InvalidParameter(ref cause) => cause,
ListOrganizationsError::Validation(ref cause) => cause,
ListOrganizationsError::Credentials(ref err) => err.description(),
ListOrganizationsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ListOrganizationsError::ParseError(ref cause) => cause,
ListOrganizationsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListResourceDelegatesError {
EntityNotFound(String),
EntityState(String),
InvalidParameter(String),
OrganizationNotFound(String),
OrganizationState(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListResourceDelegatesError {
pub fn from_response(res: BufferedHttpResponse) -> ListResourceDelegatesError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"EntityNotFoundException" => {
return ListResourceDelegatesError::EntityNotFound(String::from(error_message));
}
"EntityStateException" => {
return ListResourceDelegatesError::EntityState(String::from(error_message));
}
"InvalidParameterException" => {
return ListResourceDelegatesError::InvalidParameter(String::from(error_message));
}
"OrganizationNotFoundException" => {
return ListResourceDelegatesError::OrganizationNotFound(String::from(
error_message,
));
}
"OrganizationStateException" => {
return ListResourceDelegatesError::OrganizationState(String::from(
error_message,
));
}
"ValidationException" => {
return ListResourceDelegatesError::Validation(error_message.to_string());
}
_ => {}
}
}
return ListResourceDelegatesError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ListResourceDelegatesError {
fn from(err: serde_json::error::Error) -> ListResourceDelegatesError {
ListResourceDelegatesError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ListResourceDelegatesError {
fn from(err: CredentialsError) -> ListResourceDelegatesError {
ListResourceDelegatesError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListResourceDelegatesError {
fn from(err: HttpDispatchError) -> ListResourceDelegatesError {
ListResourceDelegatesError::HttpDispatch(err)
}
}
impl From<io::Error> for ListResourceDelegatesError {
fn from(err: io::Error) -> ListResourceDelegatesError {
ListResourceDelegatesError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListResourceDelegatesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListResourceDelegatesError {
fn description(&self) -> &str {
match *self {
ListResourceDelegatesError::EntityNotFound(ref cause) => cause,
ListResourceDelegatesError::EntityState(ref cause) => cause,
ListResourceDelegatesError::InvalidParameter(ref cause) => cause,
ListResourceDelegatesError::OrganizationNotFound(ref cause) => cause,
ListResourceDelegatesError::OrganizationState(ref cause) => cause,
ListResourceDelegatesError::Validation(ref cause) => cause,
ListResourceDelegatesError::Credentials(ref err) => err.description(),
ListResourceDelegatesError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
ListResourceDelegatesError::ParseError(ref cause) => cause,
ListResourceDelegatesError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListResourcesError {
InvalidParameter(String),
OrganizationNotFound(String),
OrganizationState(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListResourcesError {
pub fn from_response(res: BufferedHttpResponse) -> ListResourcesError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"InvalidParameterException" => {
return ListResourcesError::InvalidParameter(String::from(error_message));
}
"OrganizationNotFoundException" => {
return ListResourcesError::OrganizationNotFound(String::from(error_message));
}
"OrganizationStateException" => {
return ListResourcesError::OrganizationState(String::from(error_message));
}
"ValidationException" => {
return ListResourcesError::Validation(error_message.to_string());
}
_ => {}
}
}
return ListResourcesError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ListResourcesError {
fn from(err: serde_json::error::Error) -> ListResourcesError {
ListResourcesError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ListResourcesError {
fn from(err: CredentialsError) -> ListResourcesError {
ListResourcesError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListResourcesError {
fn from(err: HttpDispatchError) -> ListResourcesError {
ListResourcesError::HttpDispatch(err)
}
}
impl From<io::Error> for ListResourcesError {
fn from(err: io::Error) -> ListResourcesError {
ListResourcesError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListResourcesError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListResourcesError {
fn description(&self) -> &str {
match *self {
ListResourcesError::InvalidParameter(ref cause) => cause,
ListResourcesError::OrganizationNotFound(ref cause) => cause,
ListResourcesError::OrganizationState(ref cause) => cause,
ListResourcesError::Validation(ref cause) => cause,
ListResourcesError::Credentials(ref err) => err.description(),
ListResourcesError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
ListResourcesError::ParseError(ref cause) => cause,
ListResourcesError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ListUsersError {
InvalidParameter(String),
OrganizationNotFound(String),
OrganizationState(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ListUsersError {
pub fn from_response(res: BufferedHttpResponse) -> ListUsersError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"InvalidParameterException" => {
return ListUsersError::InvalidParameter(String::from(error_message));
}
"OrganizationNotFoundException" => {
return ListUsersError::OrganizationNotFound(String::from(error_message));
}
"OrganizationStateException" => {
return ListUsersError::OrganizationState(String::from(error_message));
}
"ValidationException" => {
return ListUsersError::Validation(error_message.to_string());
}
_ => {}
}
}
return ListUsersError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ListUsersError {
fn from(err: serde_json::error::Error) -> ListUsersError {
ListUsersError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ListUsersError {
fn from(err: CredentialsError) -> ListUsersError {
ListUsersError::Credentials(err)
}
}
impl From<HttpDispatchError> for ListUsersError {
fn from(err: HttpDispatchError) -> ListUsersError {
ListUsersError::HttpDispatch(err)
}
}
impl From<io::Error> for ListUsersError {
fn from(err: io::Error) -> ListUsersError {
ListUsersError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ListUsersError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ListUsersError {
fn description(&self) -> &str {
match *self {
ListUsersError::InvalidParameter(ref cause) => cause,
ListUsersError::OrganizationNotFound(ref cause) => cause,
ListUsersError::OrganizationState(ref cause) => cause,
ListUsersError::Validation(ref cause) => cause,
ListUsersError::Credentials(ref err) => err.description(),
ListUsersError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
ListUsersError::ParseError(ref cause) => cause,
ListUsersError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum PutMailboxPermissionsError {
EntityNotFound(String),
EntityState(String),
InvalidParameter(String),
OrganizationNotFound(String),
OrganizationState(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl PutMailboxPermissionsError {
pub fn from_response(res: BufferedHttpResponse) -> PutMailboxPermissionsError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"EntityNotFoundException" => {
return PutMailboxPermissionsError::EntityNotFound(String::from(error_message));
}
"EntityStateException" => {
return PutMailboxPermissionsError::EntityState(String::from(error_message));
}
"InvalidParameterException" => {
return PutMailboxPermissionsError::InvalidParameter(String::from(error_message));
}
"OrganizationNotFoundException" => {
return PutMailboxPermissionsError::OrganizationNotFound(String::from(
error_message,
));
}
"OrganizationStateException" => {
return PutMailboxPermissionsError::OrganizationState(String::from(
error_message,
));
}
"ValidationException" => {
return PutMailboxPermissionsError::Validation(error_message.to_string());
}
_ => {}
}
}
return PutMailboxPermissionsError::Unknown(res);
}
}
impl From<serde_json::error::Error> for PutMailboxPermissionsError {
fn from(err: serde_json::error::Error) -> PutMailboxPermissionsError {
PutMailboxPermissionsError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for PutMailboxPermissionsError {
fn from(err: CredentialsError) -> PutMailboxPermissionsError {
PutMailboxPermissionsError::Credentials(err)
}
}
impl From<HttpDispatchError> for PutMailboxPermissionsError {
fn from(err: HttpDispatchError) -> PutMailboxPermissionsError {
PutMailboxPermissionsError::HttpDispatch(err)
}
}
impl From<io::Error> for PutMailboxPermissionsError {
fn from(err: io::Error) -> PutMailboxPermissionsError {
PutMailboxPermissionsError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for PutMailboxPermissionsError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for PutMailboxPermissionsError {
fn description(&self) -> &str {
match *self {
PutMailboxPermissionsError::EntityNotFound(ref cause) => cause,
PutMailboxPermissionsError::EntityState(ref cause) => cause,
PutMailboxPermissionsError::InvalidParameter(ref cause) => cause,
PutMailboxPermissionsError::OrganizationNotFound(ref cause) => cause,
PutMailboxPermissionsError::OrganizationState(ref cause) => cause,
PutMailboxPermissionsError::Validation(ref cause) => cause,
PutMailboxPermissionsError::Credentials(ref err) => err.description(),
PutMailboxPermissionsError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
PutMailboxPermissionsError::ParseError(ref cause) => cause,
PutMailboxPermissionsError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum RegisterToWorkMailError {
DirectoryServiceAuthenticationFailed(String),
DirectoryUnavailable(String),
EmailAddressInUse(String),
EntityAlreadyRegistered(String),
EntityNotFound(String),
EntityState(String),
InvalidParameter(String),
MailDomainNotFound(String),
MailDomainState(String),
OrganizationNotFound(String),
OrganizationState(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl RegisterToWorkMailError {
pub fn from_response(res: BufferedHttpResponse) -> RegisterToWorkMailError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"DirectoryServiceAuthenticationFailedException" => {
return RegisterToWorkMailError::DirectoryServiceAuthenticationFailed(
String::from(error_message),
);
}
"DirectoryUnavailableException" => {
return RegisterToWorkMailError::DirectoryUnavailable(String::from(
error_message,
));
}
"EmailAddressInUseException" => {
return RegisterToWorkMailError::EmailAddressInUse(String::from(error_message));
}
"EntityAlreadyRegisteredException" => {
return RegisterToWorkMailError::EntityAlreadyRegistered(String::from(
error_message,
));
}
"EntityNotFoundException" => {
return RegisterToWorkMailError::EntityNotFound(String::from(error_message));
}
"EntityStateException" => {
return RegisterToWorkMailError::EntityState(String::from(error_message));
}
"InvalidParameterException" => {
return RegisterToWorkMailError::InvalidParameter(String::from(error_message));
}
"MailDomainNotFoundException" => {
return RegisterToWorkMailError::MailDomainNotFound(String::from(error_message));
}
"MailDomainStateException" => {
return RegisterToWorkMailError::MailDomainState(String::from(error_message));
}
"OrganizationNotFoundException" => {
return RegisterToWorkMailError::OrganizationNotFound(String::from(
error_message,
));
}
"OrganizationStateException" => {
return RegisterToWorkMailError::OrganizationState(String::from(error_message));
}
"ValidationException" => {
return RegisterToWorkMailError::Validation(error_message.to_string());
}
_ => {}
}
}
return RegisterToWorkMailError::Unknown(res);
}
}
impl From<serde_json::error::Error> for RegisterToWorkMailError {
fn from(err: serde_json::error::Error) -> RegisterToWorkMailError {
RegisterToWorkMailError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for RegisterToWorkMailError {
fn from(err: CredentialsError) -> RegisterToWorkMailError {
RegisterToWorkMailError::Credentials(err)
}
}
impl From<HttpDispatchError> for RegisterToWorkMailError {
fn from(err: HttpDispatchError) -> RegisterToWorkMailError {
RegisterToWorkMailError::HttpDispatch(err)
}
}
impl From<io::Error> for RegisterToWorkMailError {
fn from(err: io::Error) -> RegisterToWorkMailError {
RegisterToWorkMailError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for RegisterToWorkMailError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for RegisterToWorkMailError {
fn description(&self) -> &str {
match *self {
RegisterToWorkMailError::DirectoryServiceAuthenticationFailed(ref cause) => cause,
RegisterToWorkMailError::DirectoryUnavailable(ref cause) => cause,
RegisterToWorkMailError::EmailAddressInUse(ref cause) => cause,
RegisterToWorkMailError::EntityAlreadyRegistered(ref cause) => cause,
RegisterToWorkMailError::EntityNotFound(ref cause) => cause,
RegisterToWorkMailError::EntityState(ref cause) => cause,
RegisterToWorkMailError::InvalidParameter(ref cause) => cause,
RegisterToWorkMailError::MailDomainNotFound(ref cause) => cause,
RegisterToWorkMailError::MailDomainState(ref cause) => cause,
RegisterToWorkMailError::OrganizationNotFound(ref cause) => cause,
RegisterToWorkMailError::OrganizationState(ref cause) => cause,
RegisterToWorkMailError::Validation(ref cause) => cause,
RegisterToWorkMailError::Credentials(ref err) => err.description(),
RegisterToWorkMailError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
RegisterToWorkMailError::ParseError(ref cause) => cause,
RegisterToWorkMailError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum ResetPasswordError {
DirectoryServiceAuthenticationFailed(String),
DirectoryUnavailable(String),
EntityNotFound(String),
EntityState(String),
InvalidParameter(String),
InvalidPassword(String),
OrganizationNotFound(String),
OrganizationState(String),
UnsupportedOperation(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl ResetPasswordError {
pub fn from_response(res: BufferedHttpResponse) -> ResetPasswordError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"DirectoryServiceAuthenticationFailedException" => {
return ResetPasswordError::DirectoryServiceAuthenticationFailed(String::from(
error_message,
));
}
"DirectoryUnavailableException" => {
return ResetPasswordError::DirectoryUnavailable(String::from(error_message));
}
"EntityNotFoundException" => {
return ResetPasswordError::EntityNotFound(String::from(error_message));
}
"EntityStateException" => {
return ResetPasswordError::EntityState(String::from(error_message));
}
"InvalidParameterException" => {
return ResetPasswordError::InvalidParameter(String::from(error_message));
}
"InvalidPasswordException" => {
return ResetPasswordError::InvalidPassword(String::from(error_message));
}
"OrganizationNotFoundException" => {
return ResetPasswordError::OrganizationNotFound(String::from(error_message));
}
"OrganizationStateException" => {
return ResetPasswordError::OrganizationState(String::from(error_message));
}
"UnsupportedOperationException" => {
return ResetPasswordError::UnsupportedOperation(String::from(error_message));
}
"ValidationException" => {
return ResetPasswordError::Validation(error_message.to_string());
}
_ => {}
}
}
return ResetPasswordError::Unknown(res);
}
}
impl From<serde_json::error::Error> for ResetPasswordError {
fn from(err: serde_json::error::Error) -> ResetPasswordError {
ResetPasswordError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for ResetPasswordError {
fn from(err: CredentialsError) -> ResetPasswordError {
ResetPasswordError::Credentials(err)
}
}
impl From<HttpDispatchError> for ResetPasswordError {
fn from(err: HttpDispatchError) -> ResetPasswordError {
ResetPasswordError::HttpDispatch(err)
}
}
impl From<io::Error> for ResetPasswordError {
fn from(err: io::Error) -> ResetPasswordError {
ResetPasswordError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for ResetPasswordError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for ResetPasswordError {
fn description(&self) -> &str {
match *self {
ResetPasswordError::DirectoryServiceAuthenticationFailed(ref cause) => cause,
ResetPasswordError::DirectoryUnavailable(ref cause) => cause,
ResetPasswordError::EntityNotFound(ref cause) => cause,
ResetPasswordError::EntityState(ref cause) => cause,
ResetPasswordError::InvalidParameter(ref cause) => cause,
ResetPasswordError::InvalidPassword(ref cause) => cause,
ResetPasswordError::OrganizationNotFound(ref cause) => cause,
ResetPasswordError::OrganizationState(ref cause) => cause,
ResetPasswordError::UnsupportedOperation(ref cause) => cause,
ResetPasswordError::Validation(ref cause) => cause,
ResetPasswordError::Credentials(ref err) => err.description(),
ResetPasswordError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
ResetPasswordError::ParseError(ref cause) => cause,
ResetPasswordError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum UpdatePrimaryEmailAddressError {
DirectoryServiceAuthenticationFailed(String),
DirectoryUnavailable(String),
EmailAddressInUse(String),
EntityNotFound(String),
EntityState(String),
InvalidParameter(String),
MailDomainNotFound(String),
MailDomainState(String),
OrganizationNotFound(String),
OrganizationState(String),
UnsupportedOperation(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl UpdatePrimaryEmailAddressError {
pub fn from_response(res: BufferedHttpResponse) -> UpdatePrimaryEmailAddressError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"DirectoryServiceAuthenticationFailedException" => {
return UpdatePrimaryEmailAddressError::DirectoryServiceAuthenticationFailed(
String::from(error_message),
);
}
"DirectoryUnavailableException" => {
return UpdatePrimaryEmailAddressError::DirectoryUnavailable(String::from(
error_message,
));
}
"EmailAddressInUseException" => {
return UpdatePrimaryEmailAddressError::EmailAddressInUse(String::from(
error_message,
));
}
"EntityNotFoundException" => {
return UpdatePrimaryEmailAddressError::EntityNotFound(String::from(
error_message,
));
}
"EntityStateException" => {
return UpdatePrimaryEmailAddressError::EntityState(String::from(error_message));
}
"InvalidParameterException" => {
return UpdatePrimaryEmailAddressError::InvalidParameter(String::from(
error_message,
));
}
"MailDomainNotFoundException" => {
return UpdatePrimaryEmailAddressError::MailDomainNotFound(String::from(
error_message,
));
}
"MailDomainStateException" => {
return UpdatePrimaryEmailAddressError::MailDomainState(String::from(
error_message,
));
}
"OrganizationNotFoundException" => {
return UpdatePrimaryEmailAddressError::OrganizationNotFound(String::from(
error_message,
));
}
"OrganizationStateException" => {
return UpdatePrimaryEmailAddressError::OrganizationState(String::from(
error_message,
));
}
"UnsupportedOperationException" => {
return UpdatePrimaryEmailAddressError::UnsupportedOperation(String::from(
error_message,
));
}
"ValidationException" => {
return UpdatePrimaryEmailAddressError::Validation(error_message.to_string());
}
_ => {}
}
}
return UpdatePrimaryEmailAddressError::Unknown(res);
}
}
impl From<serde_json::error::Error> for UpdatePrimaryEmailAddressError {
fn from(err: serde_json::error::Error) -> UpdatePrimaryEmailAddressError {
UpdatePrimaryEmailAddressError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for UpdatePrimaryEmailAddressError {
fn from(err: CredentialsError) -> UpdatePrimaryEmailAddressError {
UpdatePrimaryEmailAddressError::Credentials(err)
}
}
impl From<HttpDispatchError> for UpdatePrimaryEmailAddressError {
fn from(err: HttpDispatchError) -> UpdatePrimaryEmailAddressError {
UpdatePrimaryEmailAddressError::HttpDispatch(err)
}
}
impl From<io::Error> for UpdatePrimaryEmailAddressError {
fn from(err: io::Error) -> UpdatePrimaryEmailAddressError {
UpdatePrimaryEmailAddressError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for UpdatePrimaryEmailAddressError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for UpdatePrimaryEmailAddressError {
fn description(&self) -> &str {
match *self {
UpdatePrimaryEmailAddressError::DirectoryServiceAuthenticationFailed(ref cause) => {
cause
}
UpdatePrimaryEmailAddressError::DirectoryUnavailable(ref cause) => cause,
UpdatePrimaryEmailAddressError::EmailAddressInUse(ref cause) => cause,
UpdatePrimaryEmailAddressError::EntityNotFound(ref cause) => cause,
UpdatePrimaryEmailAddressError::EntityState(ref cause) => cause,
UpdatePrimaryEmailAddressError::InvalidParameter(ref cause) => cause,
UpdatePrimaryEmailAddressError::MailDomainNotFound(ref cause) => cause,
UpdatePrimaryEmailAddressError::MailDomainState(ref cause) => cause,
UpdatePrimaryEmailAddressError::OrganizationNotFound(ref cause) => cause,
UpdatePrimaryEmailAddressError::OrganizationState(ref cause) => cause,
UpdatePrimaryEmailAddressError::UnsupportedOperation(ref cause) => cause,
UpdatePrimaryEmailAddressError::Validation(ref cause) => cause,
UpdatePrimaryEmailAddressError::Credentials(ref err) => err.description(),
UpdatePrimaryEmailAddressError::HttpDispatch(ref dispatch_error) => {
dispatch_error.description()
}
UpdatePrimaryEmailAddressError::ParseError(ref cause) => cause,
UpdatePrimaryEmailAddressError::Unknown(_) => "unknown error",
}
}
}
#[derive(Debug, PartialEq)]
pub enum UpdateResourceError {
DirectoryUnavailable(String),
EmailAddressInUse(String),
EntityNotFound(String),
EntityState(String),
InvalidConfiguration(String),
MailDomainNotFound(String),
MailDomainState(String),
NameAvailability(String),
OrganizationNotFound(String),
OrganizationState(String),
HttpDispatch(HttpDispatchError),
Credentials(CredentialsError),
Validation(String),
ParseError(String),
Unknown(BufferedHttpResponse),
}
impl UpdateResourceError {
pub fn from_response(res: BufferedHttpResponse) -> UpdateResourceError {
if let Ok(json) = from_slice::<SerdeJsonValue>(&res.body) {
let raw_error_type = json
.get("__type")
.and_then(|e| e.as_str())
.unwrap_or("Unknown");
let error_message = json.get("message").and_then(|m| m.as_str()).unwrap_or("");
let pieces: Vec<&str> = raw_error_type.split("#").collect();
let error_type = pieces.last().expect("Expected error type");
match *error_type {
"DirectoryUnavailableException" => {
return UpdateResourceError::DirectoryUnavailable(String::from(error_message));
}
"EmailAddressInUseException" => {
return UpdateResourceError::EmailAddressInUse(String::from(error_message));
}
"EntityNotFoundException" => {
return UpdateResourceError::EntityNotFound(String::from(error_message));
}
"EntityStateException" => {
return UpdateResourceError::EntityState(String::from(error_message));
}
"InvalidConfigurationException" => {
return UpdateResourceError::InvalidConfiguration(String::from(error_message));
}
"MailDomainNotFoundException" => {
return UpdateResourceError::MailDomainNotFound(String::from(error_message));
}
"MailDomainStateException" => {
return UpdateResourceError::MailDomainState(String::from(error_message));
}
"NameAvailabilityException" => {
return UpdateResourceError::NameAvailability(String::from(error_message));
}
"OrganizationNotFoundException" => {
return UpdateResourceError::OrganizationNotFound(String::from(error_message));
}
"OrganizationStateException" => {
return UpdateResourceError::OrganizationState(String::from(error_message));
}
"ValidationException" => {
return UpdateResourceError::Validation(error_message.to_string());
}
_ => {}
}
}
return UpdateResourceError::Unknown(res);
}
}
impl From<serde_json::error::Error> for UpdateResourceError {
fn from(err: serde_json::error::Error) -> UpdateResourceError {
UpdateResourceError::ParseError(err.description().to_string())
}
}
impl From<CredentialsError> for UpdateResourceError {
fn from(err: CredentialsError) -> UpdateResourceError {
UpdateResourceError::Credentials(err)
}
}
impl From<HttpDispatchError> for UpdateResourceError {
fn from(err: HttpDispatchError) -> UpdateResourceError {
UpdateResourceError::HttpDispatch(err)
}
}
impl From<io::Error> for UpdateResourceError {
fn from(err: io::Error) -> UpdateResourceError {
UpdateResourceError::HttpDispatch(HttpDispatchError::from(err))
}
}
impl fmt::Display for UpdateResourceError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.description())
}
}
impl Error for UpdateResourceError {
fn description(&self) -> &str {
match *self {
UpdateResourceError::DirectoryUnavailable(ref cause) => cause,
UpdateResourceError::EmailAddressInUse(ref cause) => cause,
UpdateResourceError::EntityNotFound(ref cause) => cause,
UpdateResourceError::EntityState(ref cause) => cause,
UpdateResourceError::InvalidConfiguration(ref cause) => cause,
UpdateResourceError::MailDomainNotFound(ref cause) => cause,
UpdateResourceError::MailDomainState(ref cause) => cause,
UpdateResourceError::NameAvailability(ref cause) => cause,
UpdateResourceError::OrganizationNotFound(ref cause) => cause,
UpdateResourceError::OrganizationState(ref cause) => cause,
UpdateResourceError::Validation(ref cause) => cause,
UpdateResourceError::Credentials(ref err) => err.description(),
UpdateResourceError::HttpDispatch(ref dispatch_error) => dispatch_error.description(),
UpdateResourceError::ParseError(ref cause) => cause,
UpdateResourceError::Unknown(_) => "unknown error",
}
}
}
pub trait Workmail {
fn associate_delegate_to_resource(
&self,
input: AssociateDelegateToResourceRequest,
) -> RusotoFuture<AssociateDelegateToResourceResponse, AssociateDelegateToResourceError>;
fn associate_member_to_group(
&self,
input: AssociateMemberToGroupRequest,
) -> RusotoFuture<AssociateMemberToGroupResponse, AssociateMemberToGroupError>;
fn create_alias(
&self,
input: CreateAliasRequest,
) -> RusotoFuture<CreateAliasResponse, CreateAliasError>;
fn create_group(
&self,
input: CreateGroupRequest,
) -> RusotoFuture<CreateGroupResponse, CreateGroupError>;
fn create_resource(
&self,
input: CreateResourceRequest,
) -> RusotoFuture<CreateResourceResponse, CreateResourceError>;
fn create_user(
&self,
input: CreateUserRequest,
) -> RusotoFuture<CreateUserResponse, CreateUserError>;
fn delete_alias(
&self,
input: DeleteAliasRequest,
) -> RusotoFuture<DeleteAliasResponse, DeleteAliasError>;
fn delete_group(
&self,
input: DeleteGroupRequest,
) -> RusotoFuture<DeleteGroupResponse, DeleteGroupError>;
fn delete_mailbox_permissions(
&self,
input: DeleteMailboxPermissionsRequest,
) -> RusotoFuture<DeleteMailboxPermissionsResponse, DeleteMailboxPermissionsError>;
fn delete_resource(
&self,
input: DeleteResourceRequest,
) -> RusotoFuture<DeleteResourceResponse, DeleteResourceError>;
fn delete_user(
&self,
input: DeleteUserRequest,
) -> RusotoFuture<DeleteUserResponse, DeleteUserError>;
fn deregister_from_work_mail(
&self,
input: DeregisterFromWorkMailRequest,
) -> RusotoFuture<DeregisterFromWorkMailResponse, DeregisterFromWorkMailError>;
fn describe_group(
&self,
input: DescribeGroupRequest,
) -> RusotoFuture<DescribeGroupResponse, DescribeGroupError>;
fn describe_organization(
&self,
input: DescribeOrganizationRequest,
) -> RusotoFuture<DescribeOrganizationResponse, DescribeOrganizationError>;
fn describe_resource(
&self,
input: DescribeResourceRequest,
) -> RusotoFuture<DescribeResourceResponse, DescribeResourceError>;
fn describe_user(
&self,
input: DescribeUserRequest,
) -> RusotoFuture<DescribeUserResponse, DescribeUserError>;
fn disassociate_delegate_from_resource(
&self,
input: DisassociateDelegateFromResourceRequest,
) -> RusotoFuture<DisassociateDelegateFromResourceResponse, DisassociateDelegateFromResourceError>;
fn disassociate_member_from_group(
&self,
input: DisassociateMemberFromGroupRequest,
) -> RusotoFuture<DisassociateMemberFromGroupResponse, DisassociateMemberFromGroupError>;
fn list_aliases(
&self,
input: ListAliasesRequest,
) -> RusotoFuture<ListAliasesResponse, ListAliasesError>;
fn list_group_members(
&self,
input: ListGroupMembersRequest,
) -> RusotoFuture<ListGroupMembersResponse, ListGroupMembersError>;
fn list_groups(
&self,
input: ListGroupsRequest,
) -> RusotoFuture<ListGroupsResponse, ListGroupsError>;
fn list_mailbox_permissions(
&self,
input: ListMailboxPermissionsRequest,
) -> RusotoFuture<ListMailboxPermissionsResponse, ListMailboxPermissionsError>;
fn list_organizations(
&self,
input: ListOrganizationsRequest,
) -> RusotoFuture<ListOrganizationsResponse, ListOrganizationsError>;
fn list_resource_delegates(
&self,
input: ListResourceDelegatesRequest,
) -> RusotoFuture<ListResourceDelegatesResponse, ListResourceDelegatesError>;
fn list_resources(
&self,
input: ListResourcesRequest,
) -> RusotoFuture<ListResourcesResponse, ListResourcesError>;
fn list_users(
&self,
input: ListUsersRequest,
) -> RusotoFuture<ListUsersResponse, ListUsersError>;
fn put_mailbox_permissions(
&self,
input: PutMailboxPermissionsRequest,
) -> RusotoFuture<PutMailboxPermissionsResponse, PutMailboxPermissionsError>;
fn register_to_work_mail(
&self,
input: RegisterToWorkMailRequest,
) -> RusotoFuture<RegisterToWorkMailResponse, RegisterToWorkMailError>;
fn reset_password(
&self,
input: ResetPasswordRequest,
) -> RusotoFuture<ResetPasswordResponse, ResetPasswordError>;
fn update_primary_email_address(
&self,
input: UpdatePrimaryEmailAddressRequest,
) -> RusotoFuture<UpdatePrimaryEmailAddressResponse, UpdatePrimaryEmailAddressError>;
fn update_resource(
&self,
input: UpdateResourceRequest,
) -> RusotoFuture<UpdateResourceResponse, UpdateResourceError>;
}
#[derive(Clone)]
pub struct WorkmailClient {
client: Client,
region: region::Region,
}
impl WorkmailClient {
pub fn new(region: region::Region) -> WorkmailClient {
WorkmailClient {
client: Client::shared(),
region: region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> WorkmailClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
P::Future: Send,
D: DispatchSignedRequest + Send + Sync + 'static,
D::Future: Send,
{
WorkmailClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region: region,
}
}
}
impl Workmail for WorkmailClient {
fn associate_delegate_to_resource(
&self,
input: AssociateDelegateToResourceRequest,
) -> RusotoFuture<AssociateDelegateToResourceResponse, AssociateDelegateToResourceError> {
let mut request = SignedRequest::new("POST", "workmail", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"WorkMailService.AssociateDelegateToResource",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<AssociateDelegateToResourceResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(AssociateDelegateToResourceError::from_response(response))
}))
}
})
}
fn associate_member_to_group(
&self,
input: AssociateMemberToGroupRequest,
) -> RusotoFuture<AssociateMemberToGroupResponse, AssociateMemberToGroupError> {
let mut request = SignedRequest::new("POST", "workmail", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "WorkMailService.AssociateMemberToGroup");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<AssociateMemberToGroupResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(AssociateMemberToGroupError::from_response(response))
}),
)
}
})
}
fn create_alias(
&self,
input: CreateAliasRequest,
) -> RusotoFuture<CreateAliasResponse, CreateAliasError> {
let mut request = SignedRequest::new("POST", "workmail", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "WorkMailService.CreateAlias");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<CreateAliasResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(CreateAliasError::from_response(response))),
)
}
})
}
fn create_group(
&self,
input: CreateGroupRequest,
) -> RusotoFuture<CreateGroupResponse, CreateGroupError> {
let mut request = SignedRequest::new("POST", "workmail", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "WorkMailService.CreateGroup");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<CreateGroupResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(CreateGroupError::from_response(response))),
)
}
})
}
fn create_resource(
&self,
input: CreateResourceRequest,
) -> RusotoFuture<CreateResourceResponse, CreateResourceError> {
let mut request = SignedRequest::new("POST", "workmail", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "WorkMailService.CreateResource");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<CreateResourceResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(CreateResourceError::from_response(response))),
)
}
})
}
fn create_user(
&self,
input: CreateUserRequest,
) -> RusotoFuture<CreateUserResponse, CreateUserError> {
let mut request = SignedRequest::new("POST", "workmail", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "WorkMailService.CreateUser");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<CreateUserResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(CreateUserError::from_response(response))),
)
}
})
}
fn delete_alias(
&self,
input: DeleteAliasRequest,
) -> RusotoFuture<DeleteAliasResponse, DeleteAliasError> {
let mut request = SignedRequest::new("POST", "workmail", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "WorkMailService.DeleteAlias");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<DeleteAliasResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DeleteAliasError::from_response(response))),
)
}
})
}
fn delete_group(
&self,
input: DeleteGroupRequest,
) -> RusotoFuture<DeleteGroupResponse, DeleteGroupError> {
let mut request = SignedRequest::new("POST", "workmail", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "WorkMailService.DeleteGroup");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<DeleteGroupResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DeleteGroupError::from_response(response))),
)
}
})
}
fn delete_mailbox_permissions(
&self,
input: DeleteMailboxPermissionsRequest,
) -> RusotoFuture<DeleteMailboxPermissionsResponse, DeleteMailboxPermissionsError> {
let mut request = SignedRequest::new("POST", "workmail", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "WorkMailService.DeleteMailboxPermissions");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<DeleteMailboxPermissionsResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(DeleteMailboxPermissionsError::from_response(response))
}))
}
})
}
fn delete_resource(
&self,
input: DeleteResourceRequest,
) -> RusotoFuture<DeleteResourceResponse, DeleteResourceError> {
let mut request = SignedRequest::new("POST", "workmail", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "WorkMailService.DeleteResource");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<DeleteResourceResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DeleteResourceError::from_response(response))),
)
}
})
}
fn delete_user(
&self,
input: DeleteUserRequest,
) -> RusotoFuture<DeleteUserResponse, DeleteUserError> {
let mut request = SignedRequest::new("POST", "workmail", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "WorkMailService.DeleteUser");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<DeleteUserResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DeleteUserError::from_response(response))),
)
}
})
}
fn deregister_from_work_mail(
&self,
input: DeregisterFromWorkMailRequest,
) -> RusotoFuture<DeregisterFromWorkMailResponse, DeregisterFromWorkMailError> {
let mut request = SignedRequest::new("POST", "workmail", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "WorkMailService.DeregisterFromWorkMail");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<DeregisterFromWorkMailResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(DeregisterFromWorkMailError::from_response(response))
}),
)
}
})
}
fn describe_group(
&self,
input: DescribeGroupRequest,
) -> RusotoFuture<DescribeGroupResponse, DescribeGroupError> {
let mut request = SignedRequest::new("POST", "workmail", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "WorkMailService.DescribeGroup");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<DescribeGroupResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DescribeGroupError::from_response(response))),
)
}
})
}
fn describe_organization(
&self,
input: DescribeOrganizationRequest,
) -> RusotoFuture<DescribeOrganizationResponse, DescribeOrganizationError> {
let mut request = SignedRequest::new("POST", "workmail", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "WorkMailService.DescribeOrganization");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<DescribeOrganizationResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(DescribeOrganizationError::from_response(response))
}),
)
}
})
}
fn describe_resource(
&self,
input: DescribeResourceRequest,
) -> RusotoFuture<DescribeResourceResponse, DescribeResourceError> {
let mut request = SignedRequest::new("POST", "workmail", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "WorkMailService.DescribeResource");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<DescribeResourceResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DescribeResourceError::from_response(response))),
)
}
})
}
fn describe_user(
&self,
input: DescribeUserRequest,
) -> RusotoFuture<DescribeUserResponse, DescribeUserError> {
let mut request = SignedRequest::new("POST", "workmail", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "WorkMailService.DescribeUser");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<DescribeUserResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(DescribeUserError::from_response(response))),
)
}
})
}
fn disassociate_delegate_from_resource(
&self,
input: DisassociateDelegateFromResourceRequest,
) -> RusotoFuture<DisassociateDelegateFromResourceResponse, DisassociateDelegateFromResourceError>
{
let mut request = SignedRequest::new("POST", "workmail", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"WorkMailService.DisassociateDelegateFromResource",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<DisassociateDelegateFromResourceResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(DisassociateDelegateFromResourceError::from_response(
response,
))
}))
}
})
}
fn disassociate_member_from_group(
&self,
input: DisassociateMemberFromGroupRequest,
) -> RusotoFuture<DisassociateMemberFromGroupResponse, DisassociateMemberFromGroupError> {
let mut request = SignedRequest::new("POST", "workmail", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"WorkMailService.DisassociateMemberFromGroup",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<DisassociateMemberFromGroupResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(DisassociateMemberFromGroupError::from_response(response))
}))
}
})
}
fn list_aliases(
&self,
input: ListAliasesRequest,
) -> RusotoFuture<ListAliasesResponse, ListAliasesError> {
let mut request = SignedRequest::new("POST", "workmail", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "WorkMailService.ListAliases");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<ListAliasesResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(ListAliasesError::from_response(response))),
)
}
})
}
fn list_group_members(
&self,
input: ListGroupMembersRequest,
) -> RusotoFuture<ListGroupMembersResponse, ListGroupMembersError> {
let mut request = SignedRequest::new("POST", "workmail", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "WorkMailService.ListGroupMembers");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<ListGroupMembersResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(ListGroupMembersError::from_response(response))),
)
}
})
}
fn list_groups(
&self,
input: ListGroupsRequest,
) -> RusotoFuture<ListGroupsResponse, ListGroupsError> {
let mut request = SignedRequest::new("POST", "workmail", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "WorkMailService.ListGroups");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<ListGroupsResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(ListGroupsError::from_response(response))),
)
}
})
}
fn list_mailbox_permissions(
&self,
input: ListMailboxPermissionsRequest,
) -> RusotoFuture<ListMailboxPermissionsResponse, ListMailboxPermissionsError> {
let mut request = SignedRequest::new("POST", "workmail", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "WorkMailService.ListMailboxPermissions");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<ListMailboxPermissionsResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(ListMailboxPermissionsError::from_response(response))
}),
)
}
})
}
fn list_organizations(
&self,
input: ListOrganizationsRequest,
) -> RusotoFuture<ListOrganizationsResponse, ListOrganizationsError> {
let mut request = SignedRequest::new("POST", "workmail", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "WorkMailService.ListOrganizations");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<ListOrganizationsResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(ListOrganizationsError::from_response(response))),
)
}
})
}
fn list_resource_delegates(
&self,
input: ListResourceDelegatesRequest,
) -> RusotoFuture<ListResourceDelegatesResponse, ListResourceDelegatesError> {
let mut request = SignedRequest::new("POST", "workmail", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "WorkMailService.ListResourceDelegates");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<ListResourceDelegatesResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(ListResourceDelegatesError::from_response(response))
}),
)
}
})
}
fn list_resources(
&self,
input: ListResourcesRequest,
) -> RusotoFuture<ListResourcesResponse, ListResourcesError> {
let mut request = SignedRequest::new("POST", "workmail", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "WorkMailService.ListResources");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<ListResourcesResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(ListResourcesError::from_response(response))),
)
}
})
}
fn list_users(
&self,
input: ListUsersRequest,
) -> RusotoFuture<ListUsersResponse, ListUsersError> {
let mut request = SignedRequest::new("POST", "workmail", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "WorkMailService.ListUsers");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<ListUsersResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(ListUsersError::from_response(response))),
)
}
})
}
fn put_mailbox_permissions(
&self,
input: PutMailboxPermissionsRequest,
) -> RusotoFuture<PutMailboxPermissionsResponse, PutMailboxPermissionsError> {
let mut request = SignedRequest::new("POST", "workmail", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "WorkMailService.PutMailboxPermissions");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<PutMailboxPermissionsResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response.buffer().from_err().and_then(|response| {
Err(PutMailboxPermissionsError::from_response(response))
}),
)
}
})
}
fn register_to_work_mail(
&self,
input: RegisterToWorkMailRequest,
) -> RusotoFuture<RegisterToWorkMailResponse, RegisterToWorkMailError> {
let mut request = SignedRequest::new("POST", "workmail", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "WorkMailService.RegisterToWorkMail");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<RegisterToWorkMailResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(RegisterToWorkMailError::from_response(response))),
)
}
})
}
fn reset_password(
&self,
input: ResetPasswordRequest,
) -> RusotoFuture<ResetPasswordResponse, ResetPasswordError> {
let mut request = SignedRequest::new("POST", "workmail", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "WorkMailService.ResetPassword");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<ResetPasswordResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(ResetPasswordError::from_response(response))),
)
}
})
}
fn update_primary_email_address(
&self,
input: UpdatePrimaryEmailAddressRequest,
) -> RusotoFuture<UpdatePrimaryEmailAddressResponse, UpdatePrimaryEmailAddressError> {
let mut request = SignedRequest::new("POST", "workmail", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "WorkMailService.UpdatePrimaryEmailAddress");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<UpdatePrimaryEmailAddressResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(response.buffer().from_err().and_then(|response| {
Err(UpdatePrimaryEmailAddressError::from_response(response))
}))
}
})
}
fn update_resource(
&self,
input: UpdateResourceRequest,
) -> RusotoFuture<UpdateResourceResponse, UpdateResourceError> {
let mut request = SignedRequest::new("POST", "workmail", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "WorkMailService.UpdateResource");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded.into_bytes()));
self.client.sign_and_dispatch(request, |response| {
if response.status.is_success() {
Box::new(response.buffer().from_err().map(|response| {
let mut body = response.body;
if body.is_empty() || body == b"null" {
body = b"{}".to_vec();
}
serde_json::from_str::<UpdateResourceResponse>(
String::from_utf8_lossy(body.as_ref()).as_ref(),
)
.unwrap()
}))
} else {
Box::new(
response
.buffer()
.from_err()
.and_then(|response| Err(UpdateResourceError::from_response(response))),
)
}
})
}
}
#[cfg(test)]
mod protocol_tests {}