use std::error::Error;
use std::fmt;
use async_trait::async_trait;
use rusoto_core::credential::ProvideAwsCredentials;
use rusoto_core::region;
use rusoto_core::request::{BufferedHttpResponse, DispatchSignedRequest};
use rusoto_core::{Client, RusotoError};
use rusoto_core::proto;
use rusoto_core::request::HttpResponse;
use rusoto_core::signature::SignedRequest;
#[allow(unused_imports)]
use serde::{Deserialize, Serialize};
impl CognitoIdentityProviderClient {
fn new_signed_request(&self, http_method: &str, request_uri: &str) -> SignedRequest {
let mut request = SignedRequest::new(http_method, "cognito-idp", &self.region, request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request
}
async fn sign_and_dispatch<E>(
&self,
request: SignedRequest,
from_response: fn(BufferedHttpResponse) -> RusotoError<E>,
) -> Result<HttpResponse, RusotoError<E>> {
let mut response = self.client.sign_and_dispatch(request).await?;
if !response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
return Err(from_response(response));
}
Ok(response)
}
}
use serde_json;
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct AccountRecoverySettingType {
#[serde(rename = "RecoveryMechanisms")]
#[serde(skip_serializing_if = "Option::is_none")]
pub recovery_mechanisms: Option<Vec<RecoveryOptionType>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct AccountTakeoverActionType {
#[serde(rename = "EventAction")]
pub event_action: String,
#[serde(rename = "Notify")]
pub notify: bool,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct AccountTakeoverActionsType {
#[serde(rename = "HighAction")]
#[serde(skip_serializing_if = "Option::is_none")]
pub high_action: Option<AccountTakeoverActionType>,
#[serde(rename = "LowAction")]
#[serde(skip_serializing_if = "Option::is_none")]
pub low_action: Option<AccountTakeoverActionType>,
#[serde(rename = "MediumAction")]
#[serde(skip_serializing_if = "Option::is_none")]
pub medium_action: Option<AccountTakeoverActionType>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct AccountTakeoverRiskConfigurationType {
#[serde(rename = "Actions")]
pub actions: AccountTakeoverActionsType,
#[serde(rename = "NotifyConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub notify_configuration: Option<NotifyConfigurationType>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AddCustomAttributesRequest {
#[serde(rename = "CustomAttributes")]
pub custom_attributes: Vec<SchemaAttributeType>,
#[serde(rename = "UserPoolId")]
pub user_pool_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AddCustomAttributesResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AdminAddUserToGroupRequest {
#[serde(rename = "GroupName")]
pub group_name: String,
#[serde(rename = "UserPoolId")]
pub user_pool_id: String,
#[serde(rename = "Username")]
pub username: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AdminConfirmSignUpRequest {
#[serde(rename = "ClientMetadata")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_metadata: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "UserPoolId")]
pub user_pool_id: String,
#[serde(rename = "Username")]
pub username: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AdminConfirmSignUpResponse {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct AdminCreateUserConfigType {
#[serde(rename = "AllowAdminCreateUserOnly")]
#[serde(skip_serializing_if = "Option::is_none")]
pub allow_admin_create_user_only: Option<bool>,
#[serde(rename = "InviteMessageTemplate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub invite_message_template: Option<MessageTemplateType>,
#[serde(rename = "UnusedAccountValidityDays")]
#[serde(skip_serializing_if = "Option::is_none")]
pub unused_account_validity_days: Option<i64>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AdminCreateUserRequest {
#[serde(rename = "ClientMetadata")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_metadata: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "DesiredDeliveryMediums")]
#[serde(skip_serializing_if = "Option::is_none")]
pub desired_delivery_mediums: Option<Vec<String>>,
#[serde(rename = "ForceAliasCreation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub force_alias_creation: Option<bool>,
#[serde(rename = "MessageAction")]
#[serde(skip_serializing_if = "Option::is_none")]
pub message_action: Option<String>,
#[serde(rename = "TemporaryPassword")]
#[serde(skip_serializing_if = "Option::is_none")]
pub temporary_password: Option<String>,
#[serde(rename = "UserAttributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_attributes: Option<Vec<AttributeType>>,
#[serde(rename = "UserPoolId")]
pub user_pool_id: String,
#[serde(rename = "Username")]
pub username: String,
#[serde(rename = "ValidationData")]
#[serde(skip_serializing_if = "Option::is_none")]
pub validation_data: Option<Vec<AttributeType>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AdminCreateUserResponse {
#[serde(rename = "User")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user: Option<UserType>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AdminDeleteUserAttributesRequest {
#[serde(rename = "UserAttributeNames")]
pub user_attribute_names: Vec<String>,
#[serde(rename = "UserPoolId")]
pub user_pool_id: String,
#[serde(rename = "Username")]
pub username: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AdminDeleteUserAttributesResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AdminDeleteUserRequest {
#[serde(rename = "UserPoolId")]
pub user_pool_id: String,
#[serde(rename = "Username")]
pub username: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AdminDisableProviderForUserRequest {
#[serde(rename = "User")]
pub user: ProviderUserIdentifierType,
#[serde(rename = "UserPoolId")]
pub user_pool_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AdminDisableProviderForUserResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AdminDisableUserRequest {
#[serde(rename = "UserPoolId")]
pub user_pool_id: String,
#[serde(rename = "Username")]
pub username: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AdminDisableUserResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AdminEnableUserRequest {
#[serde(rename = "UserPoolId")]
pub user_pool_id: String,
#[serde(rename = "Username")]
pub username: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AdminEnableUserResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AdminForgetDeviceRequest {
#[serde(rename = "DeviceKey")]
pub device_key: String,
#[serde(rename = "UserPoolId")]
pub user_pool_id: String,
#[serde(rename = "Username")]
pub username: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AdminGetDeviceRequest {
#[serde(rename = "DeviceKey")]
pub device_key: String,
#[serde(rename = "UserPoolId")]
pub user_pool_id: String,
#[serde(rename = "Username")]
pub username: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AdminGetDeviceResponse {
#[serde(rename = "Device")]
pub device: DeviceType,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AdminGetUserRequest {
#[serde(rename = "UserPoolId")]
pub user_pool_id: String,
#[serde(rename = "Username")]
pub username: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AdminGetUserResponse {
#[serde(rename = "Enabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enabled: Option<bool>,
#[serde(rename = "MFAOptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub mfa_options: Option<Vec<MFAOptionType>>,
#[serde(rename = "PreferredMfaSetting")]
#[serde(skip_serializing_if = "Option::is_none")]
pub preferred_mfa_setting: Option<String>,
#[serde(rename = "UserAttributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_attributes: Option<Vec<AttributeType>>,
#[serde(rename = "UserCreateDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_create_date: Option<f64>,
#[serde(rename = "UserLastModifiedDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_last_modified_date: Option<f64>,
#[serde(rename = "UserMFASettingList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_mfa_setting_list: Option<Vec<String>>,
#[serde(rename = "UserStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_status: Option<String>,
#[serde(rename = "Username")]
pub username: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AdminInitiateAuthRequest {
#[serde(rename = "AnalyticsMetadata")]
#[serde(skip_serializing_if = "Option::is_none")]
pub analytics_metadata: Option<AnalyticsMetadataType>,
#[serde(rename = "AuthFlow")]
pub auth_flow: String,
#[serde(rename = "AuthParameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auth_parameters: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "ClientId")]
pub client_id: String,
#[serde(rename = "ClientMetadata")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_metadata: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "ContextData")]
#[serde(skip_serializing_if = "Option::is_none")]
pub context_data: Option<ContextDataType>,
#[serde(rename = "UserPoolId")]
pub user_pool_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AdminInitiateAuthResponse {
#[serde(rename = "AuthenticationResult")]
#[serde(skip_serializing_if = "Option::is_none")]
pub authentication_result: Option<AuthenticationResultType>,
#[serde(rename = "ChallengeName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub challenge_name: Option<String>,
#[serde(rename = "ChallengeParameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub challenge_parameters: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "Session")]
#[serde(skip_serializing_if = "Option::is_none")]
pub session: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AdminLinkProviderForUserRequest {
#[serde(rename = "DestinationUser")]
pub destination_user: ProviderUserIdentifierType,
#[serde(rename = "SourceUser")]
pub source_user: ProviderUserIdentifierType,
#[serde(rename = "UserPoolId")]
pub user_pool_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AdminLinkProviderForUserResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AdminListDevicesRequest {
#[serde(rename = "Limit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub limit: Option<i64>,
#[serde(rename = "PaginationToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pagination_token: Option<String>,
#[serde(rename = "UserPoolId")]
pub user_pool_id: String,
#[serde(rename = "Username")]
pub username: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AdminListDevicesResponse {
#[serde(rename = "Devices")]
#[serde(skip_serializing_if = "Option::is_none")]
pub devices: Option<Vec<DeviceType>>,
#[serde(rename = "PaginationToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pagination_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AdminListGroupsForUserRequest {
#[serde(rename = "Limit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub limit: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "UserPoolId")]
pub user_pool_id: String,
#[serde(rename = "Username")]
pub username: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AdminListGroupsForUserResponse {
#[serde(rename = "Groups")]
#[serde(skip_serializing_if = "Option::is_none")]
pub groups: Option<Vec<GroupType>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AdminListUserAuthEventsRequest {
#[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 = "UserPoolId")]
pub user_pool_id: String,
#[serde(rename = "Username")]
pub username: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AdminListUserAuthEventsResponse {
#[serde(rename = "AuthEvents")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auth_events: Option<Vec<AuthEventType>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AdminRemoveUserFromGroupRequest {
#[serde(rename = "GroupName")]
pub group_name: String,
#[serde(rename = "UserPoolId")]
pub user_pool_id: String,
#[serde(rename = "Username")]
pub username: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AdminResetUserPasswordRequest {
#[serde(rename = "ClientMetadata")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_metadata: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "UserPoolId")]
pub user_pool_id: String,
#[serde(rename = "Username")]
pub username: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AdminResetUserPasswordResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AdminRespondToAuthChallengeRequest {
#[serde(rename = "AnalyticsMetadata")]
#[serde(skip_serializing_if = "Option::is_none")]
pub analytics_metadata: Option<AnalyticsMetadataType>,
#[serde(rename = "ChallengeName")]
pub challenge_name: String,
#[serde(rename = "ChallengeResponses")]
#[serde(skip_serializing_if = "Option::is_none")]
pub challenge_responses: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "ClientId")]
pub client_id: String,
#[serde(rename = "ClientMetadata")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_metadata: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "ContextData")]
#[serde(skip_serializing_if = "Option::is_none")]
pub context_data: Option<ContextDataType>,
#[serde(rename = "Session")]
#[serde(skip_serializing_if = "Option::is_none")]
pub session: Option<String>,
#[serde(rename = "UserPoolId")]
pub user_pool_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AdminRespondToAuthChallengeResponse {
#[serde(rename = "AuthenticationResult")]
#[serde(skip_serializing_if = "Option::is_none")]
pub authentication_result: Option<AuthenticationResultType>,
#[serde(rename = "ChallengeName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub challenge_name: Option<String>,
#[serde(rename = "ChallengeParameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub challenge_parameters: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "Session")]
#[serde(skip_serializing_if = "Option::is_none")]
pub session: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AdminSetUserMFAPreferenceRequest {
#[serde(rename = "SMSMfaSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sms_mfa_settings: Option<SMSMfaSettingsType>,
#[serde(rename = "SoftwareTokenMfaSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub software_token_mfa_settings: Option<SoftwareTokenMfaSettingsType>,
#[serde(rename = "UserPoolId")]
pub user_pool_id: String,
#[serde(rename = "Username")]
pub username: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AdminSetUserMFAPreferenceResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AdminSetUserPasswordRequest {
#[serde(rename = "Password")]
pub password: String,
#[serde(rename = "Permanent")]
#[serde(skip_serializing_if = "Option::is_none")]
pub permanent: Option<bool>,
#[serde(rename = "UserPoolId")]
pub user_pool_id: String,
#[serde(rename = "Username")]
pub username: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AdminSetUserPasswordResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AdminSetUserSettingsRequest {
#[serde(rename = "MFAOptions")]
pub mfa_options: Vec<MFAOptionType>,
#[serde(rename = "UserPoolId")]
pub user_pool_id: String,
#[serde(rename = "Username")]
pub username: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AdminSetUserSettingsResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AdminUpdateAuthEventFeedbackRequest {
#[serde(rename = "EventId")]
pub event_id: String,
#[serde(rename = "FeedbackValue")]
pub feedback_value: String,
#[serde(rename = "UserPoolId")]
pub user_pool_id: String,
#[serde(rename = "Username")]
pub username: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AdminUpdateAuthEventFeedbackResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AdminUpdateDeviceStatusRequest {
#[serde(rename = "DeviceKey")]
pub device_key: String,
#[serde(rename = "DeviceRememberedStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub device_remembered_status: Option<String>,
#[serde(rename = "UserPoolId")]
pub user_pool_id: String,
#[serde(rename = "Username")]
pub username: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AdminUpdateDeviceStatusResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AdminUpdateUserAttributesRequest {
#[serde(rename = "ClientMetadata")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_metadata: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "UserAttributes")]
pub user_attributes: Vec<AttributeType>,
#[serde(rename = "UserPoolId")]
pub user_pool_id: String,
#[serde(rename = "Username")]
pub username: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AdminUpdateUserAttributesResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AdminUserGlobalSignOutRequest {
#[serde(rename = "UserPoolId")]
pub user_pool_id: String,
#[serde(rename = "Username")]
pub username: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AdminUserGlobalSignOutResponse {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct AnalyticsConfigurationType {
#[serde(rename = "ApplicationArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_arn: Option<String>,
#[serde(rename = "ApplicationId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_id: Option<String>,
#[serde(rename = "ExternalId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub external_id: Option<String>,
#[serde(rename = "RoleArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub role_arn: Option<String>,
#[serde(rename = "UserDataShared")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_data_shared: Option<bool>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AnalyticsMetadataType {
#[serde(rename = "AnalyticsEndpointId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub analytics_endpoint_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AssociateSoftwareTokenRequest {
#[serde(rename = "AccessToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub access_token: Option<String>,
#[serde(rename = "Session")]
#[serde(skip_serializing_if = "Option::is_none")]
pub session: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AssociateSoftwareTokenResponse {
#[serde(rename = "SecretCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub secret_code: Option<String>,
#[serde(rename = "Session")]
#[serde(skip_serializing_if = "Option::is_none")]
pub session: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct AttributeType {
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "Value")]
#[serde(skip_serializing_if = "Option::is_none")]
pub value: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AuthEventType {
#[serde(rename = "ChallengeResponses")]
#[serde(skip_serializing_if = "Option::is_none")]
pub challenge_responses: Option<Vec<ChallengeResponseType>>,
#[serde(rename = "CreationDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_date: Option<f64>,
#[serde(rename = "EventContextData")]
#[serde(skip_serializing_if = "Option::is_none")]
pub event_context_data: Option<EventContextDataType>,
#[serde(rename = "EventFeedback")]
#[serde(skip_serializing_if = "Option::is_none")]
pub event_feedback: Option<EventFeedbackType>,
#[serde(rename = "EventId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub event_id: Option<String>,
#[serde(rename = "EventResponse")]
#[serde(skip_serializing_if = "Option::is_none")]
pub event_response: Option<String>,
#[serde(rename = "EventRisk")]
#[serde(skip_serializing_if = "Option::is_none")]
pub event_risk: Option<EventRiskType>,
#[serde(rename = "EventType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub event_type: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AuthenticationResultType {
#[serde(rename = "AccessToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub access_token: Option<String>,
#[serde(rename = "ExpiresIn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub expires_in: Option<i64>,
#[serde(rename = "IdToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id_token: Option<String>,
#[serde(rename = "NewDeviceMetadata")]
#[serde(skip_serializing_if = "Option::is_none")]
pub new_device_metadata: Option<NewDeviceMetadataType>,
#[serde(rename = "RefreshToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub refresh_token: Option<String>,
#[serde(rename = "TokenType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub token_type: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ChallengeResponseType {
#[serde(rename = "ChallengeName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub challenge_name: Option<String>,
#[serde(rename = "ChallengeResponse")]
#[serde(skip_serializing_if = "Option::is_none")]
pub challenge_response: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ChangePasswordRequest {
#[serde(rename = "AccessToken")]
pub access_token: String,
#[serde(rename = "PreviousPassword")]
pub previous_password: String,
#[serde(rename = "ProposedPassword")]
pub proposed_password: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ChangePasswordResponse {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CodeDeliveryDetailsType {
#[serde(rename = "AttributeName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attribute_name: Option<String>,
#[serde(rename = "DeliveryMedium")]
#[serde(skip_serializing_if = "Option::is_none")]
pub delivery_medium: Option<String>,
#[serde(rename = "Destination")]
#[serde(skip_serializing_if = "Option::is_none")]
pub destination: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct CompromisedCredentialsActionsType {
#[serde(rename = "EventAction")]
pub event_action: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct CompromisedCredentialsRiskConfigurationType {
#[serde(rename = "Actions")]
pub actions: CompromisedCredentialsActionsType,
#[serde(rename = "EventFilter")]
#[serde(skip_serializing_if = "Option::is_none")]
pub event_filter: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ConfirmDeviceRequest {
#[serde(rename = "AccessToken")]
pub access_token: String,
#[serde(rename = "DeviceKey")]
pub device_key: String,
#[serde(rename = "DeviceName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub device_name: Option<String>,
#[serde(rename = "DeviceSecretVerifierConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub device_secret_verifier_config: Option<DeviceSecretVerifierConfigType>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ConfirmDeviceResponse {
#[serde(rename = "UserConfirmationNecessary")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_confirmation_necessary: Option<bool>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ConfirmForgotPasswordRequest {
#[serde(rename = "AnalyticsMetadata")]
#[serde(skip_serializing_if = "Option::is_none")]
pub analytics_metadata: Option<AnalyticsMetadataType>,
#[serde(rename = "ClientId")]
pub client_id: String,
#[serde(rename = "ClientMetadata")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_metadata: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "ConfirmationCode")]
pub confirmation_code: String,
#[serde(rename = "Password")]
pub password: String,
#[serde(rename = "SecretHash")]
#[serde(skip_serializing_if = "Option::is_none")]
pub secret_hash: Option<String>,
#[serde(rename = "UserContextData")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_context_data: Option<UserContextDataType>,
#[serde(rename = "Username")]
pub username: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ConfirmForgotPasswordResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ConfirmSignUpRequest {
#[serde(rename = "AnalyticsMetadata")]
#[serde(skip_serializing_if = "Option::is_none")]
pub analytics_metadata: Option<AnalyticsMetadataType>,
#[serde(rename = "ClientId")]
pub client_id: String,
#[serde(rename = "ClientMetadata")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_metadata: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "ConfirmationCode")]
pub confirmation_code: String,
#[serde(rename = "ForceAliasCreation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub force_alias_creation: Option<bool>,
#[serde(rename = "SecretHash")]
#[serde(skip_serializing_if = "Option::is_none")]
pub secret_hash: Option<String>,
#[serde(rename = "UserContextData")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_context_data: Option<UserContextDataType>,
#[serde(rename = "Username")]
pub username: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ConfirmSignUpResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ContextDataType {
#[serde(rename = "EncodedData")]
#[serde(skip_serializing_if = "Option::is_none")]
pub encoded_data: Option<String>,
#[serde(rename = "HttpHeaders")]
pub http_headers: Vec<HttpHeader>,
#[serde(rename = "IpAddress")]
pub ip_address: String,
#[serde(rename = "ServerName")]
pub server_name: String,
#[serde(rename = "ServerPath")]
pub server_path: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateGroupRequest {
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "GroupName")]
pub group_name: String,
#[serde(rename = "Precedence")]
#[serde(skip_serializing_if = "Option::is_none")]
pub precedence: Option<i64>,
#[serde(rename = "RoleArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub role_arn: Option<String>,
#[serde(rename = "UserPoolId")]
pub user_pool_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateGroupResponse {
#[serde(rename = "Group")]
#[serde(skip_serializing_if = "Option::is_none")]
pub group: Option<GroupType>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateIdentityProviderRequest {
#[serde(rename = "AttributeMapping")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attribute_mapping: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "IdpIdentifiers")]
#[serde(skip_serializing_if = "Option::is_none")]
pub idp_identifiers: Option<Vec<String>>,
#[serde(rename = "ProviderDetails")]
pub provider_details: ::std::collections::HashMap<String, String>,
#[serde(rename = "ProviderName")]
pub provider_name: String,
#[serde(rename = "ProviderType")]
pub provider_type: String,
#[serde(rename = "UserPoolId")]
pub user_pool_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateIdentityProviderResponse {
#[serde(rename = "IdentityProvider")]
pub identity_provider: IdentityProviderType,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateResourceServerRequest {
#[serde(rename = "Identifier")]
pub identifier: String,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "Scopes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub scopes: Option<Vec<ResourceServerScopeType>>,
#[serde(rename = "UserPoolId")]
pub user_pool_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateResourceServerResponse {
#[serde(rename = "ResourceServer")]
pub resource_server: ResourceServerType,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateUserImportJobRequest {
#[serde(rename = "CloudWatchLogsRoleArn")]
pub cloud_watch_logs_role_arn: String,
#[serde(rename = "JobName")]
pub job_name: String,
#[serde(rename = "UserPoolId")]
pub user_pool_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateUserImportJobResponse {
#[serde(rename = "UserImportJob")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_import_job: Option<UserImportJobType>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateUserPoolClientRequest {
#[serde(rename = "AccessTokenValidity")]
#[serde(skip_serializing_if = "Option::is_none")]
pub access_token_validity: Option<i64>,
#[serde(rename = "AllowedOAuthFlows")]
#[serde(skip_serializing_if = "Option::is_none")]
pub allowed_o_auth_flows: Option<Vec<String>>,
#[serde(rename = "AllowedOAuthFlowsUserPoolClient")]
#[serde(skip_serializing_if = "Option::is_none")]
pub allowed_o_auth_flows_user_pool_client: Option<bool>,
#[serde(rename = "AllowedOAuthScopes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub allowed_o_auth_scopes: Option<Vec<String>>,
#[serde(rename = "AnalyticsConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub analytics_configuration: Option<AnalyticsConfigurationType>,
#[serde(rename = "CallbackURLs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub callback_ur_ls: Option<Vec<String>>,
#[serde(rename = "ClientName")]
pub client_name: String,
#[serde(rename = "DefaultRedirectURI")]
#[serde(skip_serializing_if = "Option::is_none")]
pub default_redirect_uri: Option<String>,
#[serde(rename = "ExplicitAuthFlows")]
#[serde(skip_serializing_if = "Option::is_none")]
pub explicit_auth_flows: Option<Vec<String>>,
#[serde(rename = "GenerateSecret")]
#[serde(skip_serializing_if = "Option::is_none")]
pub generate_secret: Option<bool>,
#[serde(rename = "IdTokenValidity")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id_token_validity: Option<i64>,
#[serde(rename = "LogoutURLs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub logout_ur_ls: Option<Vec<String>>,
#[serde(rename = "PreventUserExistenceErrors")]
#[serde(skip_serializing_if = "Option::is_none")]
pub prevent_user_existence_errors: Option<String>,
#[serde(rename = "ReadAttributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub read_attributes: Option<Vec<String>>,
#[serde(rename = "RefreshTokenValidity")]
#[serde(skip_serializing_if = "Option::is_none")]
pub refresh_token_validity: Option<i64>,
#[serde(rename = "SupportedIdentityProviders")]
#[serde(skip_serializing_if = "Option::is_none")]
pub supported_identity_providers: Option<Vec<String>>,
#[serde(rename = "TokenValidityUnits")]
#[serde(skip_serializing_if = "Option::is_none")]
pub token_validity_units: Option<TokenValidityUnitsType>,
#[serde(rename = "UserPoolId")]
pub user_pool_id: String,
#[serde(rename = "WriteAttributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub write_attributes: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateUserPoolClientResponse {
#[serde(rename = "UserPoolClient")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_pool_client: Option<UserPoolClientType>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateUserPoolDomainRequest {
#[serde(rename = "CustomDomainConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub custom_domain_config: Option<CustomDomainConfigType>,
#[serde(rename = "Domain")]
pub domain: String,
#[serde(rename = "UserPoolId")]
pub user_pool_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateUserPoolDomainResponse {
#[serde(rename = "CloudFrontDomain")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cloud_front_domain: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateUserPoolRequest {
#[serde(rename = "AccountRecoverySetting")]
#[serde(skip_serializing_if = "Option::is_none")]
pub account_recovery_setting: Option<AccountRecoverySettingType>,
#[serde(rename = "AdminCreateUserConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub admin_create_user_config: Option<AdminCreateUserConfigType>,
#[serde(rename = "AliasAttributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub alias_attributes: Option<Vec<String>>,
#[serde(rename = "AutoVerifiedAttributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_verified_attributes: Option<Vec<String>>,
#[serde(rename = "DeviceConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub device_configuration: Option<DeviceConfigurationType>,
#[serde(rename = "EmailConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub email_configuration: Option<EmailConfigurationType>,
#[serde(rename = "EmailVerificationMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub email_verification_message: Option<String>,
#[serde(rename = "EmailVerificationSubject")]
#[serde(skip_serializing_if = "Option::is_none")]
pub email_verification_subject: Option<String>,
#[serde(rename = "LambdaConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub lambda_config: Option<LambdaConfigType>,
#[serde(rename = "MfaConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub mfa_configuration: Option<String>,
#[serde(rename = "Policies")]
#[serde(skip_serializing_if = "Option::is_none")]
pub policies: Option<UserPoolPolicyType>,
#[serde(rename = "PoolName")]
pub pool_name: String,
#[serde(rename = "Schema")]
#[serde(skip_serializing_if = "Option::is_none")]
pub schema: Option<Vec<SchemaAttributeType>>,
#[serde(rename = "SmsAuthenticationMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sms_authentication_message: Option<String>,
#[serde(rename = "SmsConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sms_configuration: Option<SmsConfigurationType>,
#[serde(rename = "SmsVerificationMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sms_verification_message: Option<String>,
#[serde(rename = "UserPoolAddOns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_pool_add_ons: Option<UserPoolAddOnsType>,
#[serde(rename = "UserPoolTags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_pool_tags: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "UsernameAttributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub username_attributes: Option<Vec<String>>,
#[serde(rename = "UsernameConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub username_configuration: Option<UsernameConfigurationType>,
#[serde(rename = "VerificationMessageTemplate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub verification_message_template: Option<VerificationMessageTemplateType>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateUserPoolResponse {
#[serde(rename = "UserPool")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_pool: Option<UserPoolType>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct CustomDomainConfigType {
#[serde(rename = "CertificateArn")]
pub certificate_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct CustomEmailLambdaVersionConfigType {
#[serde(rename = "LambdaArn")]
pub lambda_arn: String,
#[serde(rename = "LambdaVersion")]
pub lambda_version: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct CustomSMSLambdaVersionConfigType {
#[serde(rename = "LambdaArn")]
pub lambda_arn: String,
#[serde(rename = "LambdaVersion")]
pub lambda_version: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteGroupRequest {
#[serde(rename = "GroupName")]
pub group_name: String,
#[serde(rename = "UserPoolId")]
pub user_pool_id: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteIdentityProviderRequest {
#[serde(rename = "ProviderName")]
pub provider_name: String,
#[serde(rename = "UserPoolId")]
pub user_pool_id: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteResourceServerRequest {
#[serde(rename = "Identifier")]
pub identifier: String,
#[serde(rename = "UserPoolId")]
pub user_pool_id: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteUserAttributesRequest {
#[serde(rename = "AccessToken")]
pub access_token: String,
#[serde(rename = "UserAttributeNames")]
pub user_attribute_names: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteUserAttributesResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteUserPoolClientRequest {
#[serde(rename = "ClientId")]
pub client_id: String,
#[serde(rename = "UserPoolId")]
pub user_pool_id: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteUserPoolDomainRequest {
#[serde(rename = "Domain")]
pub domain: String,
#[serde(rename = "UserPoolId")]
pub user_pool_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteUserPoolDomainResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteUserPoolRequest {
#[serde(rename = "UserPoolId")]
pub user_pool_id: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteUserRequest {
#[serde(rename = "AccessToken")]
pub access_token: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeIdentityProviderRequest {
#[serde(rename = "ProviderName")]
pub provider_name: String,
#[serde(rename = "UserPoolId")]
pub user_pool_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeIdentityProviderResponse {
#[serde(rename = "IdentityProvider")]
pub identity_provider: IdentityProviderType,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeResourceServerRequest {
#[serde(rename = "Identifier")]
pub identifier: String,
#[serde(rename = "UserPoolId")]
pub user_pool_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeResourceServerResponse {
#[serde(rename = "ResourceServer")]
pub resource_server: ResourceServerType,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeRiskConfigurationRequest {
#[serde(rename = "ClientId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_id: Option<String>,
#[serde(rename = "UserPoolId")]
pub user_pool_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeRiskConfigurationResponse {
#[serde(rename = "RiskConfiguration")]
pub risk_configuration: RiskConfigurationType,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeUserImportJobRequest {
#[serde(rename = "JobId")]
pub job_id: String,
#[serde(rename = "UserPoolId")]
pub user_pool_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeUserImportJobResponse {
#[serde(rename = "UserImportJob")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_import_job: Option<UserImportJobType>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeUserPoolClientRequest {
#[serde(rename = "ClientId")]
pub client_id: String,
#[serde(rename = "UserPoolId")]
pub user_pool_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeUserPoolClientResponse {
#[serde(rename = "UserPoolClient")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_pool_client: Option<UserPoolClientType>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeUserPoolDomainRequest {
#[serde(rename = "Domain")]
pub domain: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeUserPoolDomainResponse {
#[serde(rename = "DomainDescription")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain_description: Option<DomainDescriptionType>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeUserPoolRequest {
#[serde(rename = "UserPoolId")]
pub user_pool_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeUserPoolResponse {
#[serde(rename = "UserPool")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_pool: Option<UserPoolType>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct DeviceConfigurationType {
#[serde(rename = "ChallengeRequiredOnNewDevice")]
#[serde(skip_serializing_if = "Option::is_none")]
pub challenge_required_on_new_device: Option<bool>,
#[serde(rename = "DeviceOnlyRememberedOnUserPrompt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub device_only_remembered_on_user_prompt: Option<bool>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeviceSecretVerifierConfigType {
#[serde(rename = "PasswordVerifier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub password_verifier: Option<String>,
#[serde(rename = "Salt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub salt: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeviceType {
#[serde(rename = "DeviceAttributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub device_attributes: Option<Vec<AttributeType>>,
#[serde(rename = "DeviceCreateDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub device_create_date: Option<f64>,
#[serde(rename = "DeviceKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub device_key: Option<String>,
#[serde(rename = "DeviceLastAuthenticatedDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub device_last_authenticated_date: Option<f64>,
#[serde(rename = "DeviceLastModifiedDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub device_last_modified_date: Option<f64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DomainDescriptionType {
#[serde(rename = "AWSAccountId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub aws_account_id: Option<String>,
#[serde(rename = "CloudFrontDistribution")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cloud_front_distribution: Option<String>,
#[serde(rename = "CustomDomainConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub custom_domain_config: Option<CustomDomainConfigType>,
#[serde(rename = "Domain")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain: Option<String>,
#[serde(rename = "S3Bucket")]
#[serde(skip_serializing_if = "Option::is_none")]
pub s3_bucket: Option<String>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "UserPoolId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_pool_id: Option<String>,
#[serde(rename = "Version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct EmailConfigurationType {
#[serde(rename = "ConfigurationSet")]
#[serde(skip_serializing_if = "Option::is_none")]
pub configuration_set: Option<String>,
#[serde(rename = "EmailSendingAccount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub email_sending_account: Option<String>,
#[serde(rename = "From")]
#[serde(skip_serializing_if = "Option::is_none")]
pub from: Option<String>,
#[serde(rename = "ReplyToEmailAddress")]
#[serde(skip_serializing_if = "Option::is_none")]
pub reply_to_email_address: Option<String>,
#[serde(rename = "SourceArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_arn: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct EventContextDataType {
#[serde(rename = "City")]
#[serde(skip_serializing_if = "Option::is_none")]
pub city: Option<String>,
#[serde(rename = "Country")]
#[serde(skip_serializing_if = "Option::is_none")]
pub country: Option<String>,
#[serde(rename = "DeviceName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub device_name: Option<String>,
#[serde(rename = "IpAddress")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ip_address: Option<String>,
#[serde(rename = "Timezone")]
#[serde(skip_serializing_if = "Option::is_none")]
pub timezone: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct EventFeedbackType {
#[serde(rename = "FeedbackDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub feedback_date: Option<f64>,
#[serde(rename = "FeedbackValue")]
pub feedback_value: String,
#[serde(rename = "Provider")]
pub provider: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct EventRiskType {
#[serde(rename = "CompromisedCredentialsDetected")]
#[serde(skip_serializing_if = "Option::is_none")]
pub compromised_credentials_detected: Option<bool>,
#[serde(rename = "RiskDecision")]
#[serde(skip_serializing_if = "Option::is_none")]
pub risk_decision: Option<String>,
#[serde(rename = "RiskLevel")]
#[serde(skip_serializing_if = "Option::is_none")]
pub risk_level: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ForgetDeviceRequest {
#[serde(rename = "AccessToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub access_token: Option<String>,
#[serde(rename = "DeviceKey")]
pub device_key: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ForgotPasswordRequest {
#[serde(rename = "AnalyticsMetadata")]
#[serde(skip_serializing_if = "Option::is_none")]
pub analytics_metadata: Option<AnalyticsMetadataType>,
#[serde(rename = "ClientId")]
pub client_id: String,
#[serde(rename = "ClientMetadata")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_metadata: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "SecretHash")]
#[serde(skip_serializing_if = "Option::is_none")]
pub secret_hash: Option<String>,
#[serde(rename = "UserContextData")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_context_data: Option<UserContextDataType>,
#[serde(rename = "Username")]
pub username: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ForgotPasswordResponse {
#[serde(rename = "CodeDeliveryDetails")]
#[serde(skip_serializing_if = "Option::is_none")]
pub code_delivery_details: Option<CodeDeliveryDetailsType>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetCSVHeaderRequest {
#[serde(rename = "UserPoolId")]
pub user_pool_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetCSVHeaderResponse {
#[serde(rename = "CSVHeader")]
#[serde(skip_serializing_if = "Option::is_none")]
pub csv_header: Option<Vec<String>>,
#[serde(rename = "UserPoolId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_pool_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetDeviceRequest {
#[serde(rename = "AccessToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub access_token: Option<String>,
#[serde(rename = "DeviceKey")]
pub device_key: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetDeviceResponse {
#[serde(rename = "Device")]
pub device: DeviceType,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetGroupRequest {
#[serde(rename = "GroupName")]
pub group_name: String,
#[serde(rename = "UserPoolId")]
pub user_pool_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetGroupResponse {
#[serde(rename = "Group")]
#[serde(skip_serializing_if = "Option::is_none")]
pub group: Option<GroupType>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetIdentityProviderByIdentifierRequest {
#[serde(rename = "IdpIdentifier")]
pub idp_identifier: String,
#[serde(rename = "UserPoolId")]
pub user_pool_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetIdentityProviderByIdentifierResponse {
#[serde(rename = "IdentityProvider")]
pub identity_provider: IdentityProviderType,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetSigningCertificateRequest {
#[serde(rename = "UserPoolId")]
pub user_pool_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetSigningCertificateResponse {
#[serde(rename = "Certificate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub certificate: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetUICustomizationRequest {
#[serde(rename = "ClientId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_id: Option<String>,
#[serde(rename = "UserPoolId")]
pub user_pool_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetUICustomizationResponse {
#[serde(rename = "UICustomization")]
pub ui_customization: UICustomizationType,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetUserAttributeVerificationCodeRequest {
#[serde(rename = "AccessToken")]
pub access_token: String,
#[serde(rename = "AttributeName")]
pub attribute_name: String,
#[serde(rename = "ClientMetadata")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_metadata: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetUserAttributeVerificationCodeResponse {
#[serde(rename = "CodeDeliveryDetails")]
#[serde(skip_serializing_if = "Option::is_none")]
pub code_delivery_details: Option<CodeDeliveryDetailsType>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetUserPoolMfaConfigRequest {
#[serde(rename = "UserPoolId")]
pub user_pool_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetUserPoolMfaConfigResponse {
#[serde(rename = "MfaConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub mfa_configuration: Option<String>,
#[serde(rename = "SmsMfaConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sms_mfa_configuration: Option<SmsMfaConfigType>,
#[serde(rename = "SoftwareTokenMfaConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub software_token_mfa_configuration: Option<SoftwareTokenMfaConfigType>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetUserRequest {
#[serde(rename = "AccessToken")]
pub access_token: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetUserResponse {
#[serde(rename = "MFAOptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub mfa_options: Option<Vec<MFAOptionType>>,
#[serde(rename = "PreferredMfaSetting")]
#[serde(skip_serializing_if = "Option::is_none")]
pub preferred_mfa_setting: Option<String>,
#[serde(rename = "UserAttributes")]
pub user_attributes: Vec<AttributeType>,
#[serde(rename = "UserMFASettingList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_mfa_setting_list: Option<Vec<String>>,
#[serde(rename = "Username")]
pub username: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GlobalSignOutRequest {
#[serde(rename = "AccessToken")]
pub access_token: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GlobalSignOutResponse {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GroupType {
#[serde(rename = "CreationDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_date: Option<f64>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "GroupName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub group_name: Option<String>,
#[serde(rename = "LastModifiedDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_modified_date: Option<f64>,
#[serde(rename = "Precedence")]
#[serde(skip_serializing_if = "Option::is_none")]
pub precedence: Option<i64>,
#[serde(rename = "RoleArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub role_arn: Option<String>,
#[serde(rename = "UserPoolId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_pool_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct HttpHeader {
#[serde(rename = "headerName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub header_name: Option<String>,
#[serde(rename = "headerValue")]
#[serde(skip_serializing_if = "Option::is_none")]
pub header_value: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct IdentityProviderType {
#[serde(rename = "AttributeMapping")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attribute_mapping: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "CreationDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_date: Option<f64>,
#[serde(rename = "IdpIdentifiers")]
#[serde(skip_serializing_if = "Option::is_none")]
pub idp_identifiers: Option<Vec<String>>,
#[serde(rename = "LastModifiedDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_modified_date: Option<f64>,
#[serde(rename = "ProviderDetails")]
#[serde(skip_serializing_if = "Option::is_none")]
pub provider_details: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "ProviderName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub provider_name: Option<String>,
#[serde(rename = "ProviderType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub provider_type: Option<String>,
#[serde(rename = "UserPoolId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_pool_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct InitiateAuthRequest {
#[serde(rename = "AnalyticsMetadata")]
#[serde(skip_serializing_if = "Option::is_none")]
pub analytics_metadata: Option<AnalyticsMetadataType>,
#[serde(rename = "AuthFlow")]
pub auth_flow: String,
#[serde(rename = "AuthParameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auth_parameters: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "ClientId")]
pub client_id: String,
#[serde(rename = "ClientMetadata")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_metadata: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "UserContextData")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_context_data: Option<UserContextDataType>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct InitiateAuthResponse {
#[serde(rename = "AuthenticationResult")]
#[serde(skip_serializing_if = "Option::is_none")]
pub authentication_result: Option<AuthenticationResultType>,
#[serde(rename = "ChallengeName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub challenge_name: Option<String>,
#[serde(rename = "ChallengeParameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub challenge_parameters: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "Session")]
#[serde(skip_serializing_if = "Option::is_none")]
pub session: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct LambdaConfigType {
#[serde(rename = "CreateAuthChallenge")]
#[serde(skip_serializing_if = "Option::is_none")]
pub create_auth_challenge: Option<String>,
#[serde(rename = "CustomEmailSender")]
#[serde(skip_serializing_if = "Option::is_none")]
pub custom_email_sender: Option<CustomEmailLambdaVersionConfigType>,
#[serde(rename = "CustomMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub custom_message: Option<String>,
#[serde(rename = "CustomSMSSender")]
#[serde(skip_serializing_if = "Option::is_none")]
pub custom_sms_sender: Option<CustomSMSLambdaVersionConfigType>,
#[serde(rename = "DefineAuthChallenge")]
#[serde(skip_serializing_if = "Option::is_none")]
pub define_auth_challenge: Option<String>,
#[serde(rename = "KMSKeyID")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kms_key_id: Option<String>,
#[serde(rename = "PostAuthentication")]
#[serde(skip_serializing_if = "Option::is_none")]
pub post_authentication: Option<String>,
#[serde(rename = "PostConfirmation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub post_confirmation: Option<String>,
#[serde(rename = "PreAuthentication")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pre_authentication: Option<String>,
#[serde(rename = "PreSignUp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pre_sign_up: Option<String>,
#[serde(rename = "PreTokenGeneration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pre_token_generation: Option<String>,
#[serde(rename = "UserMigration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_migration: Option<String>,
#[serde(rename = "VerifyAuthChallengeResponse")]
#[serde(skip_serializing_if = "Option::is_none")]
pub verify_auth_challenge_response: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListDevicesRequest {
#[serde(rename = "AccessToken")]
pub access_token: String,
#[serde(rename = "Limit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub limit: Option<i64>,
#[serde(rename = "PaginationToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pagination_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListDevicesResponse {
#[serde(rename = "Devices")]
#[serde(skip_serializing_if = "Option::is_none")]
pub devices: Option<Vec<DeviceType>>,
#[serde(rename = "PaginationToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pagination_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListGroupsRequest {
#[serde(rename = "Limit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub limit: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "UserPoolId")]
pub user_pool_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListGroupsResponse {
#[serde(rename = "Groups")]
#[serde(skip_serializing_if = "Option::is_none")]
pub groups: Option<Vec<GroupType>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListIdentityProvidersRequest {
#[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 = "UserPoolId")]
pub user_pool_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListIdentityProvidersResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Providers")]
pub providers: Vec<ProviderDescription>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListResourceServersRequest {
#[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 = "UserPoolId")]
pub user_pool_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListResourceServersResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "ResourceServers")]
pub resource_servers: Vec<ResourceServerType>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListTagsForResourceRequest {
#[serde(rename = "ResourceArn")]
pub resource_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListTagsForResourceResponse {
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListUserImportJobsRequest {
#[serde(rename = "MaxResults")]
pub max_results: i64,
#[serde(rename = "PaginationToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pagination_token: Option<String>,
#[serde(rename = "UserPoolId")]
pub user_pool_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListUserImportJobsResponse {
#[serde(rename = "PaginationToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pagination_token: Option<String>,
#[serde(rename = "UserImportJobs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_import_jobs: Option<Vec<UserImportJobType>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListUserPoolClientsRequest {
#[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 = "UserPoolId")]
pub user_pool_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListUserPoolClientsResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "UserPoolClients")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_pool_clients: Option<Vec<UserPoolClientDescription>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListUserPoolsRequest {
#[serde(rename = "MaxResults")]
pub max_results: i64,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListUserPoolsResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "UserPools")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_pools: Option<Vec<UserPoolDescriptionType>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListUsersInGroupRequest {
#[serde(rename = "GroupName")]
pub group_name: String,
#[serde(rename = "Limit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub limit: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "UserPoolId")]
pub user_pool_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListUsersInGroupResponse {
#[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<UserType>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListUsersRequest {
#[serde(rename = "AttributesToGet")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attributes_to_get: Option<Vec<String>>,
#[serde(rename = "Filter")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filter: Option<String>,
#[serde(rename = "Limit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub limit: Option<i64>,
#[serde(rename = "PaginationToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pagination_token: Option<String>,
#[serde(rename = "UserPoolId")]
pub user_pool_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListUsersResponse {
#[serde(rename = "PaginationToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pagination_token: Option<String>,
#[serde(rename = "Users")]
#[serde(skip_serializing_if = "Option::is_none")]
pub users: Option<Vec<UserType>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct MFAOptionType {
#[serde(rename = "AttributeName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attribute_name: Option<String>,
#[serde(rename = "DeliveryMedium")]
#[serde(skip_serializing_if = "Option::is_none")]
pub delivery_medium: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct MessageTemplateType {
#[serde(rename = "EmailMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub email_message: Option<String>,
#[serde(rename = "EmailSubject")]
#[serde(skip_serializing_if = "Option::is_none")]
pub email_subject: Option<String>,
#[serde(rename = "SMSMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sms_message: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct NewDeviceMetadataType {
#[serde(rename = "DeviceGroupKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub device_group_key: Option<String>,
#[serde(rename = "DeviceKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub device_key: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct NotifyConfigurationType {
#[serde(rename = "BlockEmail")]
#[serde(skip_serializing_if = "Option::is_none")]
pub block_email: Option<NotifyEmailType>,
#[serde(rename = "From")]
#[serde(skip_serializing_if = "Option::is_none")]
pub from: Option<String>,
#[serde(rename = "MfaEmail")]
#[serde(skip_serializing_if = "Option::is_none")]
pub mfa_email: Option<NotifyEmailType>,
#[serde(rename = "NoActionEmail")]
#[serde(skip_serializing_if = "Option::is_none")]
pub no_action_email: Option<NotifyEmailType>,
#[serde(rename = "ReplyTo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub reply_to: Option<String>,
#[serde(rename = "SourceArn")]
pub source_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct NotifyEmailType {
#[serde(rename = "HtmlBody")]
#[serde(skip_serializing_if = "Option::is_none")]
pub html_body: Option<String>,
#[serde(rename = "Subject")]
pub subject: String,
#[serde(rename = "TextBody")]
#[serde(skip_serializing_if = "Option::is_none")]
pub text_body: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct NumberAttributeConstraintsType {
#[serde(rename = "MaxValue")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_value: Option<String>,
#[serde(rename = "MinValue")]
#[serde(skip_serializing_if = "Option::is_none")]
pub min_value: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct PasswordPolicyType {
#[serde(rename = "MinimumLength")]
#[serde(skip_serializing_if = "Option::is_none")]
pub minimum_length: Option<i64>,
#[serde(rename = "RequireLowercase")]
#[serde(skip_serializing_if = "Option::is_none")]
pub require_lowercase: Option<bool>,
#[serde(rename = "RequireNumbers")]
#[serde(skip_serializing_if = "Option::is_none")]
pub require_numbers: Option<bool>,
#[serde(rename = "RequireSymbols")]
#[serde(skip_serializing_if = "Option::is_none")]
pub require_symbols: Option<bool>,
#[serde(rename = "RequireUppercase")]
#[serde(skip_serializing_if = "Option::is_none")]
pub require_uppercase: Option<bool>,
#[serde(rename = "TemporaryPasswordValidityDays")]
#[serde(skip_serializing_if = "Option::is_none")]
pub temporary_password_validity_days: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ProviderDescription {
#[serde(rename = "CreationDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_date: Option<f64>,
#[serde(rename = "LastModifiedDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_modified_date: Option<f64>,
#[serde(rename = "ProviderName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub provider_name: Option<String>,
#[serde(rename = "ProviderType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub provider_type: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ProviderUserIdentifierType {
#[serde(rename = "ProviderAttributeName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub provider_attribute_name: Option<String>,
#[serde(rename = "ProviderAttributeValue")]
#[serde(skip_serializing_if = "Option::is_none")]
pub provider_attribute_value: Option<String>,
#[serde(rename = "ProviderName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub provider_name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct RecoveryOptionType {
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "Priority")]
pub priority: i64,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ResendConfirmationCodeRequest {
#[serde(rename = "AnalyticsMetadata")]
#[serde(skip_serializing_if = "Option::is_none")]
pub analytics_metadata: Option<AnalyticsMetadataType>,
#[serde(rename = "ClientId")]
pub client_id: String,
#[serde(rename = "ClientMetadata")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_metadata: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "SecretHash")]
#[serde(skip_serializing_if = "Option::is_none")]
pub secret_hash: Option<String>,
#[serde(rename = "UserContextData")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_context_data: Option<UserContextDataType>,
#[serde(rename = "Username")]
pub username: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ResendConfirmationCodeResponse {
#[serde(rename = "CodeDeliveryDetails")]
#[serde(skip_serializing_if = "Option::is_none")]
pub code_delivery_details: Option<CodeDeliveryDetailsType>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ResourceServerScopeType {
#[serde(rename = "ScopeDescription")]
pub scope_description: String,
#[serde(rename = "ScopeName")]
pub scope_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ResourceServerType {
#[serde(rename = "Identifier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub identifier: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "Scopes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub scopes: Option<Vec<ResourceServerScopeType>>,
#[serde(rename = "UserPoolId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_pool_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct RespondToAuthChallengeRequest {
#[serde(rename = "AnalyticsMetadata")]
#[serde(skip_serializing_if = "Option::is_none")]
pub analytics_metadata: Option<AnalyticsMetadataType>,
#[serde(rename = "ChallengeName")]
pub challenge_name: String,
#[serde(rename = "ChallengeResponses")]
#[serde(skip_serializing_if = "Option::is_none")]
pub challenge_responses: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "ClientId")]
pub client_id: String,
#[serde(rename = "ClientMetadata")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_metadata: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "Session")]
#[serde(skip_serializing_if = "Option::is_none")]
pub session: Option<String>,
#[serde(rename = "UserContextData")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_context_data: Option<UserContextDataType>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RespondToAuthChallengeResponse {
#[serde(rename = "AuthenticationResult")]
#[serde(skip_serializing_if = "Option::is_none")]
pub authentication_result: Option<AuthenticationResultType>,
#[serde(rename = "ChallengeName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub challenge_name: Option<String>,
#[serde(rename = "ChallengeParameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub challenge_parameters: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "Session")]
#[serde(skip_serializing_if = "Option::is_none")]
pub session: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RiskConfigurationType {
#[serde(rename = "AccountTakeoverRiskConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub account_takeover_risk_configuration: Option<AccountTakeoverRiskConfigurationType>,
#[serde(rename = "ClientId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_id: Option<String>,
#[serde(rename = "CompromisedCredentialsRiskConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub compromised_credentials_risk_configuration:
Option<CompromisedCredentialsRiskConfigurationType>,
#[serde(rename = "LastModifiedDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_modified_date: Option<f64>,
#[serde(rename = "RiskExceptionConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub risk_exception_configuration: Option<RiskExceptionConfigurationType>,
#[serde(rename = "UserPoolId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_pool_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct RiskExceptionConfigurationType {
#[serde(rename = "BlockedIPRangeList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub blocked_ip_range_list: Option<Vec<String>>,
#[serde(rename = "SkippedIPRangeList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub skipped_ip_range_list: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct SMSMfaSettingsType {
#[serde(rename = "Enabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enabled: Option<bool>,
#[serde(rename = "PreferredMfa")]
#[serde(skip_serializing_if = "Option::is_none")]
pub preferred_mfa: Option<bool>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct SchemaAttributeType {
#[serde(rename = "AttributeDataType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attribute_data_type: Option<String>,
#[serde(rename = "DeveloperOnlyAttribute")]
#[serde(skip_serializing_if = "Option::is_none")]
pub developer_only_attribute: Option<bool>,
#[serde(rename = "Mutable")]
#[serde(skip_serializing_if = "Option::is_none")]
pub mutable: Option<bool>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "NumberAttributeConstraints")]
#[serde(skip_serializing_if = "Option::is_none")]
pub number_attribute_constraints: Option<NumberAttributeConstraintsType>,
#[serde(rename = "Required")]
#[serde(skip_serializing_if = "Option::is_none")]
pub required: Option<bool>,
#[serde(rename = "StringAttributeConstraints")]
#[serde(skip_serializing_if = "Option::is_none")]
pub string_attribute_constraints: Option<StringAttributeConstraintsType>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct SetRiskConfigurationRequest {
#[serde(rename = "AccountTakeoverRiskConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub account_takeover_risk_configuration: Option<AccountTakeoverRiskConfigurationType>,
#[serde(rename = "ClientId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_id: Option<String>,
#[serde(rename = "CompromisedCredentialsRiskConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub compromised_credentials_risk_configuration:
Option<CompromisedCredentialsRiskConfigurationType>,
#[serde(rename = "RiskExceptionConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub risk_exception_configuration: Option<RiskExceptionConfigurationType>,
#[serde(rename = "UserPoolId")]
pub user_pool_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct SetRiskConfigurationResponse {
#[serde(rename = "RiskConfiguration")]
pub risk_configuration: RiskConfigurationType,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct SetUICustomizationRequest {
#[serde(rename = "CSS")]
#[serde(skip_serializing_if = "Option::is_none")]
pub css: Option<String>,
#[serde(rename = "ClientId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_id: Option<String>,
#[serde(rename = "ImageFile")]
#[serde(
deserialize_with = "::rusoto_core::serialization::SerdeBlob::deserialize_blob",
serialize_with = "::rusoto_core::serialization::SerdeBlob::serialize_blob",
default
)]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_file: Option<bytes::Bytes>,
#[serde(rename = "UserPoolId")]
pub user_pool_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct SetUICustomizationResponse {
#[serde(rename = "UICustomization")]
pub ui_customization: UICustomizationType,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct SetUserMFAPreferenceRequest {
#[serde(rename = "AccessToken")]
pub access_token: String,
#[serde(rename = "SMSMfaSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sms_mfa_settings: Option<SMSMfaSettingsType>,
#[serde(rename = "SoftwareTokenMfaSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub software_token_mfa_settings: Option<SoftwareTokenMfaSettingsType>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct SetUserMFAPreferenceResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct SetUserPoolMfaConfigRequest {
#[serde(rename = "MfaConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub mfa_configuration: Option<String>,
#[serde(rename = "SmsMfaConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sms_mfa_configuration: Option<SmsMfaConfigType>,
#[serde(rename = "SoftwareTokenMfaConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub software_token_mfa_configuration: Option<SoftwareTokenMfaConfigType>,
#[serde(rename = "UserPoolId")]
pub user_pool_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct SetUserPoolMfaConfigResponse {
#[serde(rename = "MfaConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub mfa_configuration: Option<String>,
#[serde(rename = "SmsMfaConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sms_mfa_configuration: Option<SmsMfaConfigType>,
#[serde(rename = "SoftwareTokenMfaConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub software_token_mfa_configuration: Option<SoftwareTokenMfaConfigType>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct SetUserSettingsRequest {
#[serde(rename = "AccessToken")]
pub access_token: String,
#[serde(rename = "MFAOptions")]
pub mfa_options: Vec<MFAOptionType>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct SetUserSettingsResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct SignUpRequest {
#[serde(rename = "AnalyticsMetadata")]
#[serde(skip_serializing_if = "Option::is_none")]
pub analytics_metadata: Option<AnalyticsMetadataType>,
#[serde(rename = "ClientId")]
pub client_id: String,
#[serde(rename = "ClientMetadata")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_metadata: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "Password")]
pub password: String,
#[serde(rename = "SecretHash")]
#[serde(skip_serializing_if = "Option::is_none")]
pub secret_hash: Option<String>,
#[serde(rename = "UserAttributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_attributes: Option<Vec<AttributeType>>,
#[serde(rename = "UserContextData")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_context_data: Option<UserContextDataType>,
#[serde(rename = "Username")]
pub username: String,
#[serde(rename = "ValidationData")]
#[serde(skip_serializing_if = "Option::is_none")]
pub validation_data: Option<Vec<AttributeType>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct SignUpResponse {
#[serde(rename = "CodeDeliveryDetails")]
#[serde(skip_serializing_if = "Option::is_none")]
pub code_delivery_details: Option<CodeDeliveryDetailsType>,
#[serde(rename = "UserConfirmed")]
pub user_confirmed: bool,
#[serde(rename = "UserSub")]
pub user_sub: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct SmsConfigurationType {
#[serde(rename = "ExternalId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub external_id: Option<String>,
#[serde(rename = "SnsCallerArn")]
pub sns_caller_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct SmsMfaConfigType {
#[serde(rename = "SmsAuthenticationMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sms_authentication_message: Option<String>,
#[serde(rename = "SmsConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sms_configuration: Option<SmsConfigurationType>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct SoftwareTokenMfaConfigType {
#[serde(rename = "Enabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enabled: Option<bool>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct SoftwareTokenMfaSettingsType {
#[serde(rename = "Enabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enabled: Option<bool>,
#[serde(rename = "PreferredMfa")]
#[serde(skip_serializing_if = "Option::is_none")]
pub preferred_mfa: Option<bool>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StartUserImportJobRequest {
#[serde(rename = "JobId")]
pub job_id: String,
#[serde(rename = "UserPoolId")]
pub user_pool_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct StartUserImportJobResponse {
#[serde(rename = "UserImportJob")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_import_job: Option<UserImportJobType>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StopUserImportJobRequest {
#[serde(rename = "JobId")]
pub job_id: String,
#[serde(rename = "UserPoolId")]
pub user_pool_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct StopUserImportJobResponse {
#[serde(rename = "UserImportJob")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_import_job: Option<UserImportJobType>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct StringAttributeConstraintsType {
#[serde(rename = "MaxLength")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_length: Option<String>,
#[serde(rename = "MinLength")]
#[serde(skip_serializing_if = "Option::is_none")]
pub min_length: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct TagResourceRequest {
#[serde(rename = "ResourceArn")]
pub resource_arn: String,
#[serde(rename = "Tags")]
pub tags: ::std::collections::HashMap<String, String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct TagResourceResponse {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct TokenValidityUnitsType {
#[serde(rename = "AccessToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub access_token: Option<String>,
#[serde(rename = "IdToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id_token: Option<String>,
#[serde(rename = "RefreshToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub refresh_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UICustomizationType {
#[serde(rename = "CSS")]
#[serde(skip_serializing_if = "Option::is_none")]
pub css: Option<String>,
#[serde(rename = "CSSVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub css_version: Option<String>,
#[serde(rename = "ClientId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_id: Option<String>,
#[serde(rename = "CreationDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_date: Option<f64>,
#[serde(rename = "ImageUrl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_url: Option<String>,
#[serde(rename = "LastModifiedDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_modified_date: Option<f64>,
#[serde(rename = "UserPoolId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_pool_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UntagResourceRequest {
#[serde(rename = "ResourceArn")]
pub resource_arn: String,
#[serde(rename = "TagKeys")]
pub tag_keys: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UntagResourceResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateAuthEventFeedbackRequest {
#[serde(rename = "EventId")]
pub event_id: String,
#[serde(rename = "FeedbackToken")]
pub feedback_token: String,
#[serde(rename = "FeedbackValue")]
pub feedback_value: String,
#[serde(rename = "UserPoolId")]
pub user_pool_id: String,
#[serde(rename = "Username")]
pub username: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateAuthEventFeedbackResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateDeviceStatusRequest {
#[serde(rename = "AccessToken")]
pub access_token: String,
#[serde(rename = "DeviceKey")]
pub device_key: String,
#[serde(rename = "DeviceRememberedStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub device_remembered_status: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateDeviceStatusResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateGroupRequest {
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "GroupName")]
pub group_name: String,
#[serde(rename = "Precedence")]
#[serde(skip_serializing_if = "Option::is_none")]
pub precedence: Option<i64>,
#[serde(rename = "RoleArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub role_arn: Option<String>,
#[serde(rename = "UserPoolId")]
pub user_pool_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateGroupResponse {
#[serde(rename = "Group")]
#[serde(skip_serializing_if = "Option::is_none")]
pub group: Option<GroupType>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateIdentityProviderRequest {
#[serde(rename = "AttributeMapping")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attribute_mapping: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "IdpIdentifiers")]
#[serde(skip_serializing_if = "Option::is_none")]
pub idp_identifiers: Option<Vec<String>>,
#[serde(rename = "ProviderDetails")]
#[serde(skip_serializing_if = "Option::is_none")]
pub provider_details: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "ProviderName")]
pub provider_name: String,
#[serde(rename = "UserPoolId")]
pub user_pool_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateIdentityProviderResponse {
#[serde(rename = "IdentityProvider")]
pub identity_provider: IdentityProviderType,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateResourceServerRequest {
#[serde(rename = "Identifier")]
pub identifier: String,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "Scopes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub scopes: Option<Vec<ResourceServerScopeType>>,
#[serde(rename = "UserPoolId")]
pub user_pool_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateResourceServerResponse {
#[serde(rename = "ResourceServer")]
pub resource_server: ResourceServerType,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateUserAttributesRequest {
#[serde(rename = "AccessToken")]
pub access_token: String,
#[serde(rename = "ClientMetadata")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_metadata: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "UserAttributes")]
pub user_attributes: Vec<AttributeType>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateUserAttributesResponse {
#[serde(rename = "CodeDeliveryDetailsList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub code_delivery_details_list: Option<Vec<CodeDeliveryDetailsType>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateUserPoolClientRequest {
#[serde(rename = "AccessTokenValidity")]
#[serde(skip_serializing_if = "Option::is_none")]
pub access_token_validity: Option<i64>,
#[serde(rename = "AllowedOAuthFlows")]
#[serde(skip_serializing_if = "Option::is_none")]
pub allowed_o_auth_flows: Option<Vec<String>>,
#[serde(rename = "AllowedOAuthFlowsUserPoolClient")]
#[serde(skip_serializing_if = "Option::is_none")]
pub allowed_o_auth_flows_user_pool_client: Option<bool>,
#[serde(rename = "AllowedOAuthScopes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub allowed_o_auth_scopes: Option<Vec<String>>,
#[serde(rename = "AnalyticsConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub analytics_configuration: Option<AnalyticsConfigurationType>,
#[serde(rename = "CallbackURLs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub callback_ur_ls: Option<Vec<String>>,
#[serde(rename = "ClientId")]
pub client_id: String,
#[serde(rename = "ClientName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_name: Option<String>,
#[serde(rename = "DefaultRedirectURI")]
#[serde(skip_serializing_if = "Option::is_none")]
pub default_redirect_uri: Option<String>,
#[serde(rename = "ExplicitAuthFlows")]
#[serde(skip_serializing_if = "Option::is_none")]
pub explicit_auth_flows: Option<Vec<String>>,
#[serde(rename = "IdTokenValidity")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id_token_validity: Option<i64>,
#[serde(rename = "LogoutURLs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub logout_ur_ls: Option<Vec<String>>,
#[serde(rename = "PreventUserExistenceErrors")]
#[serde(skip_serializing_if = "Option::is_none")]
pub prevent_user_existence_errors: Option<String>,
#[serde(rename = "ReadAttributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub read_attributes: Option<Vec<String>>,
#[serde(rename = "RefreshTokenValidity")]
#[serde(skip_serializing_if = "Option::is_none")]
pub refresh_token_validity: Option<i64>,
#[serde(rename = "SupportedIdentityProviders")]
#[serde(skip_serializing_if = "Option::is_none")]
pub supported_identity_providers: Option<Vec<String>>,
#[serde(rename = "TokenValidityUnits")]
#[serde(skip_serializing_if = "Option::is_none")]
pub token_validity_units: Option<TokenValidityUnitsType>,
#[serde(rename = "UserPoolId")]
pub user_pool_id: String,
#[serde(rename = "WriteAttributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub write_attributes: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateUserPoolClientResponse {
#[serde(rename = "UserPoolClient")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_pool_client: Option<UserPoolClientType>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateUserPoolDomainRequest {
#[serde(rename = "CustomDomainConfig")]
pub custom_domain_config: CustomDomainConfigType,
#[serde(rename = "Domain")]
pub domain: String,
#[serde(rename = "UserPoolId")]
pub user_pool_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateUserPoolDomainResponse {
#[serde(rename = "CloudFrontDomain")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cloud_front_domain: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateUserPoolRequest {
#[serde(rename = "AccountRecoverySetting")]
#[serde(skip_serializing_if = "Option::is_none")]
pub account_recovery_setting: Option<AccountRecoverySettingType>,
#[serde(rename = "AdminCreateUserConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub admin_create_user_config: Option<AdminCreateUserConfigType>,
#[serde(rename = "AutoVerifiedAttributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_verified_attributes: Option<Vec<String>>,
#[serde(rename = "DeviceConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub device_configuration: Option<DeviceConfigurationType>,
#[serde(rename = "EmailConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub email_configuration: Option<EmailConfigurationType>,
#[serde(rename = "EmailVerificationMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub email_verification_message: Option<String>,
#[serde(rename = "EmailVerificationSubject")]
#[serde(skip_serializing_if = "Option::is_none")]
pub email_verification_subject: Option<String>,
#[serde(rename = "LambdaConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub lambda_config: Option<LambdaConfigType>,
#[serde(rename = "MfaConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub mfa_configuration: Option<String>,
#[serde(rename = "Policies")]
#[serde(skip_serializing_if = "Option::is_none")]
pub policies: Option<UserPoolPolicyType>,
#[serde(rename = "SmsAuthenticationMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sms_authentication_message: Option<String>,
#[serde(rename = "SmsConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sms_configuration: Option<SmsConfigurationType>,
#[serde(rename = "SmsVerificationMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sms_verification_message: Option<String>,
#[serde(rename = "UserPoolAddOns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_pool_add_ons: Option<UserPoolAddOnsType>,
#[serde(rename = "UserPoolId")]
pub user_pool_id: String,
#[serde(rename = "UserPoolTags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_pool_tags: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "VerificationMessageTemplate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub verification_message_template: Option<VerificationMessageTemplateType>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateUserPoolResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UserContextDataType {
#[serde(rename = "EncodedData")]
#[serde(skip_serializing_if = "Option::is_none")]
pub encoded_data: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UserImportJobType {
#[serde(rename = "CloudWatchLogsRoleArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cloud_watch_logs_role_arn: Option<String>,
#[serde(rename = "CompletionDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub completion_date: Option<f64>,
#[serde(rename = "CompletionMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub completion_message: Option<String>,
#[serde(rename = "CreationDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_date: Option<f64>,
#[serde(rename = "FailedUsers")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failed_users: Option<i64>,
#[serde(rename = "ImportedUsers")]
#[serde(skip_serializing_if = "Option::is_none")]
pub imported_users: Option<i64>,
#[serde(rename = "JobId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_id: Option<String>,
#[serde(rename = "JobName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_name: Option<String>,
#[serde(rename = "PreSignedUrl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pre_signed_url: Option<String>,
#[serde(rename = "SkippedUsers")]
#[serde(skip_serializing_if = "Option::is_none")]
pub skipped_users: Option<i64>,
#[serde(rename = "StartDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub start_date: Option<f64>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "UserPoolId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_pool_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct UserPoolAddOnsType {
#[serde(rename = "AdvancedSecurityMode")]
pub advanced_security_mode: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UserPoolClientDescription {
#[serde(rename = "ClientId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_id: Option<String>,
#[serde(rename = "ClientName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_name: Option<String>,
#[serde(rename = "UserPoolId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_pool_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UserPoolClientType {
#[serde(rename = "AccessTokenValidity")]
#[serde(skip_serializing_if = "Option::is_none")]
pub access_token_validity: Option<i64>,
#[serde(rename = "AllowedOAuthFlows")]
#[serde(skip_serializing_if = "Option::is_none")]
pub allowed_o_auth_flows: Option<Vec<String>>,
#[serde(rename = "AllowedOAuthFlowsUserPoolClient")]
#[serde(skip_serializing_if = "Option::is_none")]
pub allowed_o_auth_flows_user_pool_client: Option<bool>,
#[serde(rename = "AllowedOAuthScopes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub allowed_o_auth_scopes: Option<Vec<String>>,
#[serde(rename = "AnalyticsConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub analytics_configuration: Option<AnalyticsConfigurationType>,
#[serde(rename = "CallbackURLs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub callback_ur_ls: Option<Vec<String>>,
#[serde(rename = "ClientId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_id: Option<String>,
#[serde(rename = "ClientName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_name: Option<String>,
#[serde(rename = "ClientSecret")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_secret: Option<String>,
#[serde(rename = "CreationDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_date: Option<f64>,
#[serde(rename = "DefaultRedirectURI")]
#[serde(skip_serializing_if = "Option::is_none")]
pub default_redirect_uri: Option<String>,
#[serde(rename = "ExplicitAuthFlows")]
#[serde(skip_serializing_if = "Option::is_none")]
pub explicit_auth_flows: Option<Vec<String>>,
#[serde(rename = "IdTokenValidity")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id_token_validity: Option<i64>,
#[serde(rename = "LastModifiedDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_modified_date: Option<f64>,
#[serde(rename = "LogoutURLs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub logout_ur_ls: Option<Vec<String>>,
#[serde(rename = "PreventUserExistenceErrors")]
#[serde(skip_serializing_if = "Option::is_none")]
pub prevent_user_existence_errors: Option<String>,
#[serde(rename = "ReadAttributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub read_attributes: Option<Vec<String>>,
#[serde(rename = "RefreshTokenValidity")]
#[serde(skip_serializing_if = "Option::is_none")]
pub refresh_token_validity: Option<i64>,
#[serde(rename = "SupportedIdentityProviders")]
#[serde(skip_serializing_if = "Option::is_none")]
pub supported_identity_providers: Option<Vec<String>>,
#[serde(rename = "TokenValidityUnits")]
#[serde(skip_serializing_if = "Option::is_none")]
pub token_validity_units: Option<TokenValidityUnitsType>,
#[serde(rename = "UserPoolId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_pool_id: Option<String>,
#[serde(rename = "WriteAttributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub write_attributes: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UserPoolDescriptionType {
#[serde(rename = "CreationDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_date: Option<f64>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "LambdaConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub lambda_config: Option<LambdaConfigType>,
#[serde(rename = "LastModifiedDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_modified_date: Option<f64>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct UserPoolPolicyType {
#[serde(rename = "PasswordPolicy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub password_policy: Option<PasswordPolicyType>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UserPoolType {
#[serde(rename = "AccountRecoverySetting")]
#[serde(skip_serializing_if = "Option::is_none")]
pub account_recovery_setting: Option<AccountRecoverySettingType>,
#[serde(rename = "AdminCreateUserConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub admin_create_user_config: Option<AdminCreateUserConfigType>,
#[serde(rename = "AliasAttributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub alias_attributes: Option<Vec<String>>,
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "AutoVerifiedAttributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_verified_attributes: Option<Vec<String>>,
#[serde(rename = "CreationDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_date: Option<f64>,
#[serde(rename = "CustomDomain")]
#[serde(skip_serializing_if = "Option::is_none")]
pub custom_domain: Option<String>,
#[serde(rename = "DeviceConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub device_configuration: Option<DeviceConfigurationType>,
#[serde(rename = "Domain")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain: Option<String>,
#[serde(rename = "EmailConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub email_configuration: Option<EmailConfigurationType>,
#[serde(rename = "EmailConfigurationFailure")]
#[serde(skip_serializing_if = "Option::is_none")]
pub email_configuration_failure: Option<String>,
#[serde(rename = "EmailVerificationMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub email_verification_message: Option<String>,
#[serde(rename = "EmailVerificationSubject")]
#[serde(skip_serializing_if = "Option::is_none")]
pub email_verification_subject: Option<String>,
#[serde(rename = "EstimatedNumberOfUsers")]
#[serde(skip_serializing_if = "Option::is_none")]
pub estimated_number_of_users: Option<i64>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "LambdaConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub lambda_config: Option<LambdaConfigType>,
#[serde(rename = "LastModifiedDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_modified_date: Option<f64>,
#[serde(rename = "MfaConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub mfa_configuration: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "Policies")]
#[serde(skip_serializing_if = "Option::is_none")]
pub policies: Option<UserPoolPolicyType>,
#[serde(rename = "SchemaAttributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub schema_attributes: Option<Vec<SchemaAttributeType>>,
#[serde(rename = "SmsAuthenticationMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sms_authentication_message: Option<String>,
#[serde(rename = "SmsConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sms_configuration: Option<SmsConfigurationType>,
#[serde(rename = "SmsConfigurationFailure")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sms_configuration_failure: Option<String>,
#[serde(rename = "SmsVerificationMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sms_verification_message: Option<String>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "UserPoolAddOns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_pool_add_ons: Option<UserPoolAddOnsType>,
#[serde(rename = "UserPoolTags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_pool_tags: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "UsernameAttributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub username_attributes: Option<Vec<String>>,
#[serde(rename = "UsernameConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub username_configuration: Option<UsernameConfigurationType>,
#[serde(rename = "VerificationMessageTemplate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub verification_message_template: Option<VerificationMessageTemplateType>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UserType {
#[serde(rename = "Attributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attributes: Option<Vec<AttributeType>>,
#[serde(rename = "Enabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enabled: Option<bool>,
#[serde(rename = "MFAOptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub mfa_options: Option<Vec<MFAOptionType>>,
#[serde(rename = "UserCreateDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_create_date: Option<f64>,
#[serde(rename = "UserLastModifiedDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_last_modified_date: Option<f64>,
#[serde(rename = "UserStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_status: Option<String>,
#[serde(rename = "Username")]
#[serde(skip_serializing_if = "Option::is_none")]
pub username: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct UsernameConfigurationType {
#[serde(rename = "CaseSensitive")]
pub case_sensitive: bool,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct VerificationMessageTemplateType {
#[serde(rename = "DefaultEmailOption")]
#[serde(skip_serializing_if = "Option::is_none")]
pub default_email_option: Option<String>,
#[serde(rename = "EmailMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub email_message: Option<String>,
#[serde(rename = "EmailMessageByLink")]
#[serde(skip_serializing_if = "Option::is_none")]
pub email_message_by_link: Option<String>,
#[serde(rename = "EmailSubject")]
#[serde(skip_serializing_if = "Option::is_none")]
pub email_subject: Option<String>,
#[serde(rename = "EmailSubjectByLink")]
#[serde(skip_serializing_if = "Option::is_none")]
pub email_subject_by_link: Option<String>,
#[serde(rename = "SmsMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sms_message: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct VerifySoftwareTokenRequest {
#[serde(rename = "AccessToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub access_token: Option<String>,
#[serde(rename = "FriendlyDeviceName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub friendly_device_name: Option<String>,
#[serde(rename = "Session")]
#[serde(skip_serializing_if = "Option::is_none")]
pub session: Option<String>,
#[serde(rename = "UserCode")]
pub user_code: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct VerifySoftwareTokenResponse {
#[serde(rename = "Session")]
#[serde(skip_serializing_if = "Option::is_none")]
pub session: Option<String>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct VerifyUserAttributeRequest {
#[serde(rename = "AccessToken")]
pub access_token: String,
#[serde(rename = "AttributeName")]
pub attribute_name: String,
#[serde(rename = "Code")]
pub code: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct VerifyUserAttributeResponse {}
#[derive(Debug, PartialEq)]
pub enum AddCustomAttributesError {
InternalError(String),
InvalidParameter(String),
NotAuthorized(String),
ResourceNotFound(String),
TooManyRequests(String),
UserImportInProgress(String),
}
impl AddCustomAttributesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AddCustomAttributesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(AddCustomAttributesError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(AddCustomAttributesError::InvalidParameter(
err.msg,
))
}
"NotAuthorizedException" => {
return RusotoError::Service(AddCustomAttributesError::NotAuthorized(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(AddCustomAttributesError::ResourceNotFound(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(AddCustomAttributesError::TooManyRequests(err.msg))
}
"UserImportInProgressException" => {
return RusotoError::Service(AddCustomAttributesError::UserImportInProgress(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AddCustomAttributesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AddCustomAttributesError::InternalError(ref cause) => write!(f, "{}", cause),
AddCustomAttributesError::InvalidParameter(ref cause) => write!(f, "{}", cause),
AddCustomAttributesError::NotAuthorized(ref cause) => write!(f, "{}", cause),
AddCustomAttributesError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
AddCustomAttributesError::TooManyRequests(ref cause) => write!(f, "{}", cause),
AddCustomAttributesError::UserImportInProgress(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for AddCustomAttributesError {}
#[derive(Debug, PartialEq)]
pub enum AdminAddUserToGroupError {
InternalError(String),
InvalidParameter(String),
NotAuthorized(String),
ResourceNotFound(String),
TooManyRequests(String),
UserNotFound(String),
}
impl AdminAddUserToGroupError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AdminAddUserToGroupError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(AdminAddUserToGroupError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(AdminAddUserToGroupError::InvalidParameter(
err.msg,
))
}
"NotAuthorizedException" => {
return RusotoError::Service(AdminAddUserToGroupError::NotAuthorized(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(AdminAddUserToGroupError::ResourceNotFound(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(AdminAddUserToGroupError::TooManyRequests(err.msg))
}
"UserNotFoundException" => {
return RusotoError::Service(AdminAddUserToGroupError::UserNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AdminAddUserToGroupError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AdminAddUserToGroupError::InternalError(ref cause) => write!(f, "{}", cause),
AdminAddUserToGroupError::InvalidParameter(ref cause) => write!(f, "{}", cause),
AdminAddUserToGroupError::NotAuthorized(ref cause) => write!(f, "{}", cause),
AdminAddUserToGroupError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
AdminAddUserToGroupError::TooManyRequests(ref cause) => write!(f, "{}", cause),
AdminAddUserToGroupError::UserNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for AdminAddUserToGroupError {}
#[derive(Debug, PartialEq)]
pub enum AdminConfirmSignUpError {
InternalError(String),
InvalidLambdaResponse(String),
InvalidParameter(String),
LimitExceeded(String),
NotAuthorized(String),
ResourceNotFound(String),
TooManyFailedAttempts(String),
TooManyRequests(String),
UnexpectedLambda(String),
UserLambdaValidation(String),
UserNotFound(String),
}
impl AdminConfirmSignUpError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AdminConfirmSignUpError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(AdminConfirmSignUpError::InternalError(err.msg))
}
"InvalidLambdaResponseException" => {
return RusotoError::Service(AdminConfirmSignUpError::InvalidLambdaResponse(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(AdminConfirmSignUpError::InvalidParameter(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(AdminConfirmSignUpError::LimitExceeded(err.msg))
}
"NotAuthorizedException" => {
return RusotoError::Service(AdminConfirmSignUpError::NotAuthorized(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(AdminConfirmSignUpError::ResourceNotFound(err.msg))
}
"TooManyFailedAttemptsException" => {
return RusotoError::Service(AdminConfirmSignUpError::TooManyFailedAttempts(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(AdminConfirmSignUpError::TooManyRequests(err.msg))
}
"UnexpectedLambdaException" => {
return RusotoError::Service(AdminConfirmSignUpError::UnexpectedLambda(err.msg))
}
"UserLambdaValidationException" => {
return RusotoError::Service(AdminConfirmSignUpError::UserLambdaValidation(
err.msg,
))
}
"UserNotFoundException" => {
return RusotoError::Service(AdminConfirmSignUpError::UserNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AdminConfirmSignUpError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AdminConfirmSignUpError::InternalError(ref cause) => write!(f, "{}", cause),
AdminConfirmSignUpError::InvalidLambdaResponse(ref cause) => write!(f, "{}", cause),
AdminConfirmSignUpError::InvalidParameter(ref cause) => write!(f, "{}", cause),
AdminConfirmSignUpError::LimitExceeded(ref cause) => write!(f, "{}", cause),
AdminConfirmSignUpError::NotAuthorized(ref cause) => write!(f, "{}", cause),
AdminConfirmSignUpError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
AdminConfirmSignUpError::TooManyFailedAttempts(ref cause) => write!(f, "{}", cause),
AdminConfirmSignUpError::TooManyRequests(ref cause) => write!(f, "{}", cause),
AdminConfirmSignUpError::UnexpectedLambda(ref cause) => write!(f, "{}", cause),
AdminConfirmSignUpError::UserLambdaValidation(ref cause) => write!(f, "{}", cause),
AdminConfirmSignUpError::UserNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for AdminConfirmSignUpError {}
#[derive(Debug, PartialEq)]
pub enum AdminCreateUserError {
CodeDeliveryFailure(String),
InternalError(String),
InvalidLambdaResponse(String),
InvalidParameter(String),
InvalidPassword(String),
InvalidSmsRoleAccessPolicy(String),
InvalidSmsRoleTrustRelationship(String),
NotAuthorized(String),
PreconditionNotMet(String),
ResourceNotFound(String),
TooManyRequests(String),
UnexpectedLambda(String),
UnsupportedUserState(String),
UserLambdaValidation(String),
UserNotFound(String),
UsernameExists(String),
}
impl AdminCreateUserError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AdminCreateUserError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"CodeDeliveryFailureException" => {
return RusotoError::Service(AdminCreateUserError::CodeDeliveryFailure(err.msg))
}
"InternalErrorException" => {
return RusotoError::Service(AdminCreateUserError::InternalError(err.msg))
}
"InvalidLambdaResponseException" => {
return RusotoError::Service(AdminCreateUserError::InvalidLambdaResponse(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(AdminCreateUserError::InvalidParameter(err.msg))
}
"InvalidPasswordException" => {
return RusotoError::Service(AdminCreateUserError::InvalidPassword(err.msg))
}
"InvalidSmsRoleAccessPolicyException" => {
return RusotoError::Service(AdminCreateUserError::InvalidSmsRoleAccessPolicy(
err.msg,
))
}
"InvalidSmsRoleTrustRelationshipException" => {
return RusotoError::Service(
AdminCreateUserError::InvalidSmsRoleTrustRelationship(err.msg),
)
}
"NotAuthorizedException" => {
return RusotoError::Service(AdminCreateUserError::NotAuthorized(err.msg))
}
"PreconditionNotMetException" => {
return RusotoError::Service(AdminCreateUserError::PreconditionNotMet(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(AdminCreateUserError::ResourceNotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(AdminCreateUserError::TooManyRequests(err.msg))
}
"UnexpectedLambdaException" => {
return RusotoError::Service(AdminCreateUserError::UnexpectedLambda(err.msg))
}
"UnsupportedUserStateException" => {
return RusotoError::Service(AdminCreateUserError::UnsupportedUserState(
err.msg,
))
}
"UserLambdaValidationException" => {
return RusotoError::Service(AdminCreateUserError::UserLambdaValidation(
err.msg,
))
}
"UserNotFoundException" => {
return RusotoError::Service(AdminCreateUserError::UserNotFound(err.msg))
}
"UsernameExistsException" => {
return RusotoError::Service(AdminCreateUserError::UsernameExists(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AdminCreateUserError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AdminCreateUserError::CodeDeliveryFailure(ref cause) => write!(f, "{}", cause),
AdminCreateUserError::InternalError(ref cause) => write!(f, "{}", cause),
AdminCreateUserError::InvalidLambdaResponse(ref cause) => write!(f, "{}", cause),
AdminCreateUserError::InvalidParameter(ref cause) => write!(f, "{}", cause),
AdminCreateUserError::InvalidPassword(ref cause) => write!(f, "{}", cause),
AdminCreateUserError::InvalidSmsRoleAccessPolicy(ref cause) => write!(f, "{}", cause),
AdminCreateUserError::InvalidSmsRoleTrustRelationship(ref cause) => {
write!(f, "{}", cause)
}
AdminCreateUserError::NotAuthorized(ref cause) => write!(f, "{}", cause),
AdminCreateUserError::PreconditionNotMet(ref cause) => write!(f, "{}", cause),
AdminCreateUserError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
AdminCreateUserError::TooManyRequests(ref cause) => write!(f, "{}", cause),
AdminCreateUserError::UnexpectedLambda(ref cause) => write!(f, "{}", cause),
AdminCreateUserError::UnsupportedUserState(ref cause) => write!(f, "{}", cause),
AdminCreateUserError::UserLambdaValidation(ref cause) => write!(f, "{}", cause),
AdminCreateUserError::UserNotFound(ref cause) => write!(f, "{}", cause),
AdminCreateUserError::UsernameExists(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for AdminCreateUserError {}
#[derive(Debug, PartialEq)]
pub enum AdminDeleteUserError {
InternalError(String),
InvalidParameter(String),
NotAuthorized(String),
ResourceNotFound(String),
TooManyRequests(String),
UserNotFound(String),
}
impl AdminDeleteUserError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AdminDeleteUserError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(AdminDeleteUserError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(AdminDeleteUserError::InvalidParameter(err.msg))
}
"NotAuthorizedException" => {
return RusotoError::Service(AdminDeleteUserError::NotAuthorized(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(AdminDeleteUserError::ResourceNotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(AdminDeleteUserError::TooManyRequests(err.msg))
}
"UserNotFoundException" => {
return RusotoError::Service(AdminDeleteUserError::UserNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AdminDeleteUserError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AdminDeleteUserError::InternalError(ref cause) => write!(f, "{}", cause),
AdminDeleteUserError::InvalidParameter(ref cause) => write!(f, "{}", cause),
AdminDeleteUserError::NotAuthorized(ref cause) => write!(f, "{}", cause),
AdminDeleteUserError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
AdminDeleteUserError::TooManyRequests(ref cause) => write!(f, "{}", cause),
AdminDeleteUserError::UserNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for AdminDeleteUserError {}
#[derive(Debug, PartialEq)]
pub enum AdminDeleteUserAttributesError {
InternalError(String),
InvalidParameter(String),
NotAuthorized(String),
ResourceNotFound(String),
TooManyRequests(String),
UserNotFound(String),
}
impl AdminDeleteUserAttributesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AdminDeleteUserAttributesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(AdminDeleteUserAttributesError::InternalError(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(AdminDeleteUserAttributesError::InvalidParameter(
err.msg,
))
}
"NotAuthorizedException" => {
return RusotoError::Service(AdminDeleteUserAttributesError::NotAuthorized(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(AdminDeleteUserAttributesError::ResourceNotFound(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(AdminDeleteUserAttributesError::TooManyRequests(
err.msg,
))
}
"UserNotFoundException" => {
return RusotoError::Service(AdminDeleteUserAttributesError::UserNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AdminDeleteUserAttributesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AdminDeleteUserAttributesError::InternalError(ref cause) => write!(f, "{}", cause),
AdminDeleteUserAttributesError::InvalidParameter(ref cause) => write!(f, "{}", cause),
AdminDeleteUserAttributesError::NotAuthorized(ref cause) => write!(f, "{}", cause),
AdminDeleteUserAttributesError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
AdminDeleteUserAttributesError::TooManyRequests(ref cause) => write!(f, "{}", cause),
AdminDeleteUserAttributesError::UserNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for AdminDeleteUserAttributesError {}
#[derive(Debug, PartialEq)]
pub enum AdminDisableProviderForUserError {
AliasExists(String),
InternalError(String),
InvalidParameter(String),
NotAuthorized(String),
ResourceNotFound(String),
TooManyRequests(String),
UserNotFound(String),
}
impl AdminDisableProviderForUserError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<AdminDisableProviderForUserError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AliasExistsException" => {
return RusotoError::Service(AdminDisableProviderForUserError::AliasExists(
err.msg,
))
}
"InternalErrorException" => {
return RusotoError::Service(AdminDisableProviderForUserError::InternalError(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(
AdminDisableProviderForUserError::InvalidParameter(err.msg),
)
}
"NotAuthorizedException" => {
return RusotoError::Service(AdminDisableProviderForUserError::NotAuthorized(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(
AdminDisableProviderForUserError::ResourceNotFound(err.msg),
)
}
"TooManyRequestsException" => {
return RusotoError::Service(AdminDisableProviderForUserError::TooManyRequests(
err.msg,
))
}
"UserNotFoundException" => {
return RusotoError::Service(AdminDisableProviderForUserError::UserNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AdminDisableProviderForUserError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AdminDisableProviderForUserError::AliasExists(ref cause) => write!(f, "{}", cause),
AdminDisableProviderForUserError::InternalError(ref cause) => write!(f, "{}", cause),
AdminDisableProviderForUserError::InvalidParameter(ref cause) => write!(f, "{}", cause),
AdminDisableProviderForUserError::NotAuthorized(ref cause) => write!(f, "{}", cause),
AdminDisableProviderForUserError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
AdminDisableProviderForUserError::TooManyRequests(ref cause) => write!(f, "{}", cause),
AdminDisableProviderForUserError::UserNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for AdminDisableProviderForUserError {}
#[derive(Debug, PartialEq)]
pub enum AdminDisableUserError {
InternalError(String),
InvalidParameter(String),
NotAuthorized(String),
ResourceNotFound(String),
TooManyRequests(String),
UserNotFound(String),
}
impl AdminDisableUserError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AdminDisableUserError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(AdminDisableUserError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(AdminDisableUserError::InvalidParameter(err.msg))
}
"NotAuthorizedException" => {
return RusotoError::Service(AdminDisableUserError::NotAuthorized(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(AdminDisableUserError::ResourceNotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(AdminDisableUserError::TooManyRequests(err.msg))
}
"UserNotFoundException" => {
return RusotoError::Service(AdminDisableUserError::UserNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AdminDisableUserError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AdminDisableUserError::InternalError(ref cause) => write!(f, "{}", cause),
AdminDisableUserError::InvalidParameter(ref cause) => write!(f, "{}", cause),
AdminDisableUserError::NotAuthorized(ref cause) => write!(f, "{}", cause),
AdminDisableUserError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
AdminDisableUserError::TooManyRequests(ref cause) => write!(f, "{}", cause),
AdminDisableUserError::UserNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for AdminDisableUserError {}
#[derive(Debug, PartialEq)]
pub enum AdminEnableUserError {
InternalError(String),
InvalidParameter(String),
NotAuthorized(String),
ResourceNotFound(String),
TooManyRequests(String),
UserNotFound(String),
}
impl AdminEnableUserError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AdminEnableUserError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(AdminEnableUserError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(AdminEnableUserError::InvalidParameter(err.msg))
}
"NotAuthorizedException" => {
return RusotoError::Service(AdminEnableUserError::NotAuthorized(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(AdminEnableUserError::ResourceNotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(AdminEnableUserError::TooManyRequests(err.msg))
}
"UserNotFoundException" => {
return RusotoError::Service(AdminEnableUserError::UserNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AdminEnableUserError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AdminEnableUserError::InternalError(ref cause) => write!(f, "{}", cause),
AdminEnableUserError::InvalidParameter(ref cause) => write!(f, "{}", cause),
AdminEnableUserError::NotAuthorized(ref cause) => write!(f, "{}", cause),
AdminEnableUserError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
AdminEnableUserError::TooManyRequests(ref cause) => write!(f, "{}", cause),
AdminEnableUserError::UserNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for AdminEnableUserError {}
#[derive(Debug, PartialEq)]
pub enum AdminForgetDeviceError {
InternalError(String),
InvalidParameter(String),
InvalidUserPoolConfiguration(String),
NotAuthorized(String),
ResourceNotFound(String),
TooManyRequests(String),
UserNotFound(String),
}
impl AdminForgetDeviceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AdminForgetDeviceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(AdminForgetDeviceError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(AdminForgetDeviceError::InvalidParameter(err.msg))
}
"InvalidUserPoolConfigurationException" => {
return RusotoError::Service(
AdminForgetDeviceError::InvalidUserPoolConfiguration(err.msg),
)
}
"NotAuthorizedException" => {
return RusotoError::Service(AdminForgetDeviceError::NotAuthorized(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(AdminForgetDeviceError::ResourceNotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(AdminForgetDeviceError::TooManyRequests(err.msg))
}
"UserNotFoundException" => {
return RusotoError::Service(AdminForgetDeviceError::UserNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AdminForgetDeviceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AdminForgetDeviceError::InternalError(ref cause) => write!(f, "{}", cause),
AdminForgetDeviceError::InvalidParameter(ref cause) => write!(f, "{}", cause),
AdminForgetDeviceError::InvalidUserPoolConfiguration(ref cause) => {
write!(f, "{}", cause)
}
AdminForgetDeviceError::NotAuthorized(ref cause) => write!(f, "{}", cause),
AdminForgetDeviceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
AdminForgetDeviceError::TooManyRequests(ref cause) => write!(f, "{}", cause),
AdminForgetDeviceError::UserNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for AdminForgetDeviceError {}
#[derive(Debug, PartialEq)]
pub enum AdminGetDeviceError {
InternalError(String),
InvalidParameter(String),
InvalidUserPoolConfiguration(String),
NotAuthorized(String),
ResourceNotFound(String),
TooManyRequests(String),
}
impl AdminGetDeviceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AdminGetDeviceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(AdminGetDeviceError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(AdminGetDeviceError::InvalidParameter(err.msg))
}
"InvalidUserPoolConfigurationException" => {
return RusotoError::Service(AdminGetDeviceError::InvalidUserPoolConfiguration(
err.msg,
))
}
"NotAuthorizedException" => {
return RusotoError::Service(AdminGetDeviceError::NotAuthorized(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(AdminGetDeviceError::ResourceNotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(AdminGetDeviceError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AdminGetDeviceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AdminGetDeviceError::InternalError(ref cause) => write!(f, "{}", cause),
AdminGetDeviceError::InvalidParameter(ref cause) => write!(f, "{}", cause),
AdminGetDeviceError::InvalidUserPoolConfiguration(ref cause) => write!(f, "{}", cause),
AdminGetDeviceError::NotAuthorized(ref cause) => write!(f, "{}", cause),
AdminGetDeviceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
AdminGetDeviceError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for AdminGetDeviceError {}
#[derive(Debug, PartialEq)]
pub enum AdminGetUserError {
InternalError(String),
InvalidParameter(String),
NotAuthorized(String),
ResourceNotFound(String),
TooManyRequests(String),
UserNotFound(String),
}
impl AdminGetUserError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AdminGetUserError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(AdminGetUserError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(AdminGetUserError::InvalidParameter(err.msg))
}
"NotAuthorizedException" => {
return RusotoError::Service(AdminGetUserError::NotAuthorized(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(AdminGetUserError::ResourceNotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(AdminGetUserError::TooManyRequests(err.msg))
}
"UserNotFoundException" => {
return RusotoError::Service(AdminGetUserError::UserNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AdminGetUserError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AdminGetUserError::InternalError(ref cause) => write!(f, "{}", cause),
AdminGetUserError::InvalidParameter(ref cause) => write!(f, "{}", cause),
AdminGetUserError::NotAuthorized(ref cause) => write!(f, "{}", cause),
AdminGetUserError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
AdminGetUserError::TooManyRequests(ref cause) => write!(f, "{}", cause),
AdminGetUserError::UserNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for AdminGetUserError {}
#[derive(Debug, PartialEq)]
pub enum AdminInitiateAuthError {
InternalError(String),
InvalidLambdaResponse(String),
InvalidParameter(String),
InvalidSmsRoleAccessPolicy(String),
InvalidSmsRoleTrustRelationship(String),
InvalidUserPoolConfiguration(String),
MFAMethodNotFound(String),
NotAuthorized(String),
PasswordResetRequired(String),
ResourceNotFound(String),
TooManyRequests(String),
UnexpectedLambda(String),
UserLambdaValidation(String),
UserNotConfirmed(String),
UserNotFound(String),
}
impl AdminInitiateAuthError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AdminInitiateAuthError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(AdminInitiateAuthError::InternalError(err.msg))
}
"InvalidLambdaResponseException" => {
return RusotoError::Service(AdminInitiateAuthError::InvalidLambdaResponse(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(AdminInitiateAuthError::InvalidParameter(err.msg))
}
"InvalidSmsRoleAccessPolicyException" => {
return RusotoError::Service(
AdminInitiateAuthError::InvalidSmsRoleAccessPolicy(err.msg),
)
}
"InvalidSmsRoleTrustRelationshipException" => {
return RusotoError::Service(
AdminInitiateAuthError::InvalidSmsRoleTrustRelationship(err.msg),
)
}
"InvalidUserPoolConfigurationException" => {
return RusotoError::Service(
AdminInitiateAuthError::InvalidUserPoolConfiguration(err.msg),
)
}
"MFAMethodNotFoundException" => {
return RusotoError::Service(AdminInitiateAuthError::MFAMethodNotFound(err.msg))
}
"NotAuthorizedException" => {
return RusotoError::Service(AdminInitiateAuthError::NotAuthorized(err.msg))
}
"PasswordResetRequiredException" => {
return RusotoError::Service(AdminInitiateAuthError::PasswordResetRequired(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(AdminInitiateAuthError::ResourceNotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(AdminInitiateAuthError::TooManyRequests(err.msg))
}
"UnexpectedLambdaException" => {
return RusotoError::Service(AdminInitiateAuthError::UnexpectedLambda(err.msg))
}
"UserLambdaValidationException" => {
return RusotoError::Service(AdminInitiateAuthError::UserLambdaValidation(
err.msg,
))
}
"UserNotConfirmedException" => {
return RusotoError::Service(AdminInitiateAuthError::UserNotConfirmed(err.msg))
}
"UserNotFoundException" => {
return RusotoError::Service(AdminInitiateAuthError::UserNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AdminInitiateAuthError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AdminInitiateAuthError::InternalError(ref cause) => write!(f, "{}", cause),
AdminInitiateAuthError::InvalidLambdaResponse(ref cause) => write!(f, "{}", cause),
AdminInitiateAuthError::InvalidParameter(ref cause) => write!(f, "{}", cause),
AdminInitiateAuthError::InvalidSmsRoleAccessPolicy(ref cause) => write!(f, "{}", cause),
AdminInitiateAuthError::InvalidSmsRoleTrustRelationship(ref cause) => {
write!(f, "{}", cause)
}
AdminInitiateAuthError::InvalidUserPoolConfiguration(ref cause) => {
write!(f, "{}", cause)
}
AdminInitiateAuthError::MFAMethodNotFound(ref cause) => write!(f, "{}", cause),
AdminInitiateAuthError::NotAuthorized(ref cause) => write!(f, "{}", cause),
AdminInitiateAuthError::PasswordResetRequired(ref cause) => write!(f, "{}", cause),
AdminInitiateAuthError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
AdminInitiateAuthError::TooManyRequests(ref cause) => write!(f, "{}", cause),
AdminInitiateAuthError::UnexpectedLambda(ref cause) => write!(f, "{}", cause),
AdminInitiateAuthError::UserLambdaValidation(ref cause) => write!(f, "{}", cause),
AdminInitiateAuthError::UserNotConfirmed(ref cause) => write!(f, "{}", cause),
AdminInitiateAuthError::UserNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for AdminInitiateAuthError {}
#[derive(Debug, PartialEq)]
pub enum AdminLinkProviderForUserError {
AliasExists(String),
InternalError(String),
InvalidParameter(String),
LimitExceeded(String),
NotAuthorized(String),
ResourceNotFound(String),
TooManyRequests(String),
UserNotFound(String),
}
impl AdminLinkProviderForUserError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AdminLinkProviderForUserError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AliasExistsException" => {
return RusotoError::Service(AdminLinkProviderForUserError::AliasExists(
err.msg,
))
}
"InternalErrorException" => {
return RusotoError::Service(AdminLinkProviderForUserError::InternalError(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(AdminLinkProviderForUserError::InvalidParameter(
err.msg,
))
}
"LimitExceededException" => {
return RusotoError::Service(AdminLinkProviderForUserError::LimitExceeded(
err.msg,
))
}
"NotAuthorizedException" => {
return RusotoError::Service(AdminLinkProviderForUserError::NotAuthorized(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(AdminLinkProviderForUserError::ResourceNotFound(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(AdminLinkProviderForUserError::TooManyRequests(
err.msg,
))
}
"UserNotFoundException" => {
return RusotoError::Service(AdminLinkProviderForUserError::UserNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AdminLinkProviderForUserError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AdminLinkProviderForUserError::AliasExists(ref cause) => write!(f, "{}", cause),
AdminLinkProviderForUserError::InternalError(ref cause) => write!(f, "{}", cause),
AdminLinkProviderForUserError::InvalidParameter(ref cause) => write!(f, "{}", cause),
AdminLinkProviderForUserError::LimitExceeded(ref cause) => write!(f, "{}", cause),
AdminLinkProviderForUserError::NotAuthorized(ref cause) => write!(f, "{}", cause),
AdminLinkProviderForUserError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
AdminLinkProviderForUserError::TooManyRequests(ref cause) => write!(f, "{}", cause),
AdminLinkProviderForUserError::UserNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for AdminLinkProviderForUserError {}
#[derive(Debug, PartialEq)]
pub enum AdminListDevicesError {
InternalError(String),
InvalidParameter(String),
InvalidUserPoolConfiguration(String),
NotAuthorized(String),
ResourceNotFound(String),
TooManyRequests(String),
}
impl AdminListDevicesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AdminListDevicesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(AdminListDevicesError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(AdminListDevicesError::InvalidParameter(err.msg))
}
"InvalidUserPoolConfigurationException" => {
return RusotoError::Service(
AdminListDevicesError::InvalidUserPoolConfiguration(err.msg),
)
}
"NotAuthorizedException" => {
return RusotoError::Service(AdminListDevicesError::NotAuthorized(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(AdminListDevicesError::ResourceNotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(AdminListDevicesError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AdminListDevicesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AdminListDevicesError::InternalError(ref cause) => write!(f, "{}", cause),
AdminListDevicesError::InvalidParameter(ref cause) => write!(f, "{}", cause),
AdminListDevicesError::InvalidUserPoolConfiguration(ref cause) => {
write!(f, "{}", cause)
}
AdminListDevicesError::NotAuthorized(ref cause) => write!(f, "{}", cause),
AdminListDevicesError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
AdminListDevicesError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for AdminListDevicesError {}
#[derive(Debug, PartialEq)]
pub enum AdminListGroupsForUserError {
InternalError(String),
InvalidParameter(String),
NotAuthorized(String),
ResourceNotFound(String),
TooManyRequests(String),
UserNotFound(String),
}
impl AdminListGroupsForUserError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AdminListGroupsForUserError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(AdminListGroupsForUserError::InternalError(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(AdminListGroupsForUserError::InvalidParameter(
err.msg,
))
}
"NotAuthorizedException" => {
return RusotoError::Service(AdminListGroupsForUserError::NotAuthorized(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(AdminListGroupsForUserError::ResourceNotFound(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(AdminListGroupsForUserError::TooManyRequests(
err.msg,
))
}
"UserNotFoundException" => {
return RusotoError::Service(AdminListGroupsForUserError::UserNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AdminListGroupsForUserError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AdminListGroupsForUserError::InternalError(ref cause) => write!(f, "{}", cause),
AdminListGroupsForUserError::InvalidParameter(ref cause) => write!(f, "{}", cause),
AdminListGroupsForUserError::NotAuthorized(ref cause) => write!(f, "{}", cause),
AdminListGroupsForUserError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
AdminListGroupsForUserError::TooManyRequests(ref cause) => write!(f, "{}", cause),
AdminListGroupsForUserError::UserNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for AdminListGroupsForUserError {}
#[derive(Debug, PartialEq)]
pub enum AdminListUserAuthEventsError {
InternalError(String),
InvalidParameter(String),
NotAuthorized(String),
ResourceNotFound(String),
TooManyRequests(String),
UserNotFound(String),
UserPoolAddOnNotEnabled(String),
}
impl AdminListUserAuthEventsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AdminListUserAuthEventsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(AdminListUserAuthEventsError::InternalError(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(AdminListUserAuthEventsError::InvalidParameter(
err.msg,
))
}
"NotAuthorizedException" => {
return RusotoError::Service(AdminListUserAuthEventsError::NotAuthorized(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(AdminListUserAuthEventsError::ResourceNotFound(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(AdminListUserAuthEventsError::TooManyRequests(
err.msg,
))
}
"UserNotFoundException" => {
return RusotoError::Service(AdminListUserAuthEventsError::UserNotFound(
err.msg,
))
}
"UserPoolAddOnNotEnabledException" => {
return RusotoError::Service(
AdminListUserAuthEventsError::UserPoolAddOnNotEnabled(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AdminListUserAuthEventsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AdminListUserAuthEventsError::InternalError(ref cause) => write!(f, "{}", cause),
AdminListUserAuthEventsError::InvalidParameter(ref cause) => write!(f, "{}", cause),
AdminListUserAuthEventsError::NotAuthorized(ref cause) => write!(f, "{}", cause),
AdminListUserAuthEventsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
AdminListUserAuthEventsError::TooManyRequests(ref cause) => write!(f, "{}", cause),
AdminListUserAuthEventsError::UserNotFound(ref cause) => write!(f, "{}", cause),
AdminListUserAuthEventsError::UserPoolAddOnNotEnabled(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for AdminListUserAuthEventsError {}
#[derive(Debug, PartialEq)]
pub enum AdminRemoveUserFromGroupError {
InternalError(String),
InvalidParameter(String),
NotAuthorized(String),
ResourceNotFound(String),
TooManyRequests(String),
UserNotFound(String),
}
impl AdminRemoveUserFromGroupError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AdminRemoveUserFromGroupError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(AdminRemoveUserFromGroupError::InternalError(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(AdminRemoveUserFromGroupError::InvalidParameter(
err.msg,
))
}
"NotAuthorizedException" => {
return RusotoError::Service(AdminRemoveUserFromGroupError::NotAuthorized(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(AdminRemoveUserFromGroupError::ResourceNotFound(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(AdminRemoveUserFromGroupError::TooManyRequests(
err.msg,
))
}
"UserNotFoundException" => {
return RusotoError::Service(AdminRemoveUserFromGroupError::UserNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AdminRemoveUserFromGroupError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AdminRemoveUserFromGroupError::InternalError(ref cause) => write!(f, "{}", cause),
AdminRemoveUserFromGroupError::InvalidParameter(ref cause) => write!(f, "{}", cause),
AdminRemoveUserFromGroupError::NotAuthorized(ref cause) => write!(f, "{}", cause),
AdminRemoveUserFromGroupError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
AdminRemoveUserFromGroupError::TooManyRequests(ref cause) => write!(f, "{}", cause),
AdminRemoveUserFromGroupError::UserNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for AdminRemoveUserFromGroupError {}
#[derive(Debug, PartialEq)]
pub enum AdminResetUserPasswordError {
InternalError(String),
InvalidEmailRoleAccessPolicy(String),
InvalidLambdaResponse(String),
InvalidParameter(String),
InvalidSmsRoleAccessPolicy(String),
InvalidSmsRoleTrustRelationship(String),
LimitExceeded(String),
NotAuthorized(String),
ResourceNotFound(String),
TooManyRequests(String),
UnexpectedLambda(String),
UserLambdaValidation(String),
UserNotFound(String),
}
impl AdminResetUserPasswordError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AdminResetUserPasswordError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(AdminResetUserPasswordError::InternalError(
err.msg,
))
}
"InvalidEmailRoleAccessPolicyException" => {
return RusotoError::Service(
AdminResetUserPasswordError::InvalidEmailRoleAccessPolicy(err.msg),
)
}
"InvalidLambdaResponseException" => {
return RusotoError::Service(
AdminResetUserPasswordError::InvalidLambdaResponse(err.msg),
)
}
"InvalidParameterException" => {
return RusotoError::Service(AdminResetUserPasswordError::InvalidParameter(
err.msg,
))
}
"InvalidSmsRoleAccessPolicyException" => {
return RusotoError::Service(
AdminResetUserPasswordError::InvalidSmsRoleAccessPolicy(err.msg),
)
}
"InvalidSmsRoleTrustRelationshipException" => {
return RusotoError::Service(
AdminResetUserPasswordError::InvalidSmsRoleTrustRelationship(err.msg),
)
}
"LimitExceededException" => {
return RusotoError::Service(AdminResetUserPasswordError::LimitExceeded(
err.msg,
))
}
"NotAuthorizedException" => {
return RusotoError::Service(AdminResetUserPasswordError::NotAuthorized(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(AdminResetUserPasswordError::ResourceNotFound(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(AdminResetUserPasswordError::TooManyRequests(
err.msg,
))
}
"UnexpectedLambdaException" => {
return RusotoError::Service(AdminResetUserPasswordError::UnexpectedLambda(
err.msg,
))
}
"UserLambdaValidationException" => {
return RusotoError::Service(AdminResetUserPasswordError::UserLambdaValidation(
err.msg,
))
}
"UserNotFoundException" => {
return RusotoError::Service(AdminResetUserPasswordError::UserNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AdminResetUserPasswordError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AdminResetUserPasswordError::InternalError(ref cause) => write!(f, "{}", cause),
AdminResetUserPasswordError::InvalidEmailRoleAccessPolicy(ref cause) => {
write!(f, "{}", cause)
}
AdminResetUserPasswordError::InvalidLambdaResponse(ref cause) => write!(f, "{}", cause),
AdminResetUserPasswordError::InvalidParameter(ref cause) => write!(f, "{}", cause),
AdminResetUserPasswordError::InvalidSmsRoleAccessPolicy(ref cause) => {
write!(f, "{}", cause)
}
AdminResetUserPasswordError::InvalidSmsRoleTrustRelationship(ref cause) => {
write!(f, "{}", cause)
}
AdminResetUserPasswordError::LimitExceeded(ref cause) => write!(f, "{}", cause),
AdminResetUserPasswordError::NotAuthorized(ref cause) => write!(f, "{}", cause),
AdminResetUserPasswordError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
AdminResetUserPasswordError::TooManyRequests(ref cause) => write!(f, "{}", cause),
AdminResetUserPasswordError::UnexpectedLambda(ref cause) => write!(f, "{}", cause),
AdminResetUserPasswordError::UserLambdaValidation(ref cause) => write!(f, "{}", cause),
AdminResetUserPasswordError::UserNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for AdminResetUserPasswordError {}
#[derive(Debug, PartialEq)]
pub enum AdminRespondToAuthChallengeError {
AliasExists(String),
CodeMismatch(String),
ExpiredCode(String),
InternalError(String),
InvalidLambdaResponse(String),
InvalidParameter(String),
InvalidPassword(String),
InvalidSmsRoleAccessPolicy(String),
InvalidSmsRoleTrustRelationship(String),
InvalidUserPoolConfiguration(String),
MFAMethodNotFound(String),
NotAuthorized(String),
PasswordResetRequired(String),
ResourceNotFound(String),
SoftwareTokenMFANotFound(String),
TooManyRequests(String),
UnexpectedLambda(String),
UserLambdaValidation(String),
UserNotConfirmed(String),
UserNotFound(String),
}
impl AdminRespondToAuthChallengeError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<AdminRespondToAuthChallengeError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AliasExistsException" => {
return RusotoError::Service(AdminRespondToAuthChallengeError::AliasExists(
err.msg,
))
}
"CodeMismatchException" => {
return RusotoError::Service(AdminRespondToAuthChallengeError::CodeMismatch(
err.msg,
))
}
"ExpiredCodeException" => {
return RusotoError::Service(AdminRespondToAuthChallengeError::ExpiredCode(
err.msg,
))
}
"InternalErrorException" => {
return RusotoError::Service(AdminRespondToAuthChallengeError::InternalError(
err.msg,
))
}
"InvalidLambdaResponseException" => {
return RusotoError::Service(
AdminRespondToAuthChallengeError::InvalidLambdaResponse(err.msg),
)
}
"InvalidParameterException" => {
return RusotoError::Service(
AdminRespondToAuthChallengeError::InvalidParameter(err.msg),
)
}
"InvalidPasswordException" => {
return RusotoError::Service(AdminRespondToAuthChallengeError::InvalidPassword(
err.msg,
))
}
"InvalidSmsRoleAccessPolicyException" => {
return RusotoError::Service(
AdminRespondToAuthChallengeError::InvalidSmsRoleAccessPolicy(err.msg),
)
}
"InvalidSmsRoleTrustRelationshipException" => {
return RusotoError::Service(
AdminRespondToAuthChallengeError::InvalidSmsRoleTrustRelationship(err.msg),
)
}
"InvalidUserPoolConfigurationException" => {
return RusotoError::Service(
AdminRespondToAuthChallengeError::InvalidUserPoolConfiguration(err.msg),
)
}
"MFAMethodNotFoundException" => {
return RusotoError::Service(
AdminRespondToAuthChallengeError::MFAMethodNotFound(err.msg),
)
}
"NotAuthorizedException" => {
return RusotoError::Service(AdminRespondToAuthChallengeError::NotAuthorized(
err.msg,
))
}
"PasswordResetRequiredException" => {
return RusotoError::Service(
AdminRespondToAuthChallengeError::PasswordResetRequired(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
AdminRespondToAuthChallengeError::ResourceNotFound(err.msg),
)
}
"SoftwareTokenMFANotFoundException" => {
return RusotoError::Service(
AdminRespondToAuthChallengeError::SoftwareTokenMFANotFound(err.msg),
)
}
"TooManyRequestsException" => {
return RusotoError::Service(AdminRespondToAuthChallengeError::TooManyRequests(
err.msg,
))
}
"UnexpectedLambdaException" => {
return RusotoError::Service(
AdminRespondToAuthChallengeError::UnexpectedLambda(err.msg),
)
}
"UserLambdaValidationException" => {
return RusotoError::Service(
AdminRespondToAuthChallengeError::UserLambdaValidation(err.msg),
)
}
"UserNotConfirmedException" => {
return RusotoError::Service(
AdminRespondToAuthChallengeError::UserNotConfirmed(err.msg),
)
}
"UserNotFoundException" => {
return RusotoError::Service(AdminRespondToAuthChallengeError::UserNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AdminRespondToAuthChallengeError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AdminRespondToAuthChallengeError::AliasExists(ref cause) => write!(f, "{}", cause),
AdminRespondToAuthChallengeError::CodeMismatch(ref cause) => write!(f, "{}", cause),
AdminRespondToAuthChallengeError::ExpiredCode(ref cause) => write!(f, "{}", cause),
AdminRespondToAuthChallengeError::InternalError(ref cause) => write!(f, "{}", cause),
AdminRespondToAuthChallengeError::InvalidLambdaResponse(ref cause) => {
write!(f, "{}", cause)
}
AdminRespondToAuthChallengeError::InvalidParameter(ref cause) => write!(f, "{}", cause),
AdminRespondToAuthChallengeError::InvalidPassword(ref cause) => write!(f, "{}", cause),
AdminRespondToAuthChallengeError::InvalidSmsRoleAccessPolicy(ref cause) => {
write!(f, "{}", cause)
}
AdminRespondToAuthChallengeError::InvalidSmsRoleTrustRelationship(ref cause) => {
write!(f, "{}", cause)
}
AdminRespondToAuthChallengeError::InvalidUserPoolConfiguration(ref cause) => {
write!(f, "{}", cause)
}
AdminRespondToAuthChallengeError::MFAMethodNotFound(ref cause) => {
write!(f, "{}", cause)
}
AdminRespondToAuthChallengeError::NotAuthorized(ref cause) => write!(f, "{}", cause),
AdminRespondToAuthChallengeError::PasswordResetRequired(ref cause) => {
write!(f, "{}", cause)
}
AdminRespondToAuthChallengeError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
AdminRespondToAuthChallengeError::SoftwareTokenMFANotFound(ref cause) => {
write!(f, "{}", cause)
}
AdminRespondToAuthChallengeError::TooManyRequests(ref cause) => write!(f, "{}", cause),
AdminRespondToAuthChallengeError::UnexpectedLambda(ref cause) => write!(f, "{}", cause),
AdminRespondToAuthChallengeError::UserLambdaValidation(ref cause) => {
write!(f, "{}", cause)
}
AdminRespondToAuthChallengeError::UserNotConfirmed(ref cause) => write!(f, "{}", cause),
AdminRespondToAuthChallengeError::UserNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for AdminRespondToAuthChallengeError {}
#[derive(Debug, PartialEq)]
pub enum AdminSetUserMFAPreferenceError {
InternalError(String),
InvalidParameter(String),
NotAuthorized(String),
PasswordResetRequired(String),
ResourceNotFound(String),
UserNotConfirmed(String),
UserNotFound(String),
}
impl AdminSetUserMFAPreferenceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AdminSetUserMFAPreferenceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(AdminSetUserMFAPreferenceError::InternalError(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(AdminSetUserMFAPreferenceError::InvalidParameter(
err.msg,
))
}
"NotAuthorizedException" => {
return RusotoError::Service(AdminSetUserMFAPreferenceError::NotAuthorized(
err.msg,
))
}
"PasswordResetRequiredException" => {
return RusotoError::Service(
AdminSetUserMFAPreferenceError::PasswordResetRequired(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(AdminSetUserMFAPreferenceError::ResourceNotFound(
err.msg,
))
}
"UserNotConfirmedException" => {
return RusotoError::Service(AdminSetUserMFAPreferenceError::UserNotConfirmed(
err.msg,
))
}
"UserNotFoundException" => {
return RusotoError::Service(AdminSetUserMFAPreferenceError::UserNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AdminSetUserMFAPreferenceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AdminSetUserMFAPreferenceError::InternalError(ref cause) => write!(f, "{}", cause),
AdminSetUserMFAPreferenceError::InvalidParameter(ref cause) => write!(f, "{}", cause),
AdminSetUserMFAPreferenceError::NotAuthorized(ref cause) => write!(f, "{}", cause),
AdminSetUserMFAPreferenceError::PasswordResetRequired(ref cause) => {
write!(f, "{}", cause)
}
AdminSetUserMFAPreferenceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
AdminSetUserMFAPreferenceError::UserNotConfirmed(ref cause) => write!(f, "{}", cause),
AdminSetUserMFAPreferenceError::UserNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for AdminSetUserMFAPreferenceError {}
#[derive(Debug, PartialEq)]
pub enum AdminSetUserPasswordError {
InternalError(String),
InvalidParameter(String),
InvalidPassword(String),
NotAuthorized(String),
ResourceNotFound(String),
TooManyRequests(String),
UserNotFound(String),
}
impl AdminSetUserPasswordError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AdminSetUserPasswordError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(AdminSetUserPasswordError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(AdminSetUserPasswordError::InvalidParameter(
err.msg,
))
}
"InvalidPasswordException" => {
return RusotoError::Service(AdminSetUserPasswordError::InvalidPassword(
err.msg,
))
}
"NotAuthorizedException" => {
return RusotoError::Service(AdminSetUserPasswordError::NotAuthorized(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(AdminSetUserPasswordError::ResourceNotFound(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(AdminSetUserPasswordError::TooManyRequests(
err.msg,
))
}
"UserNotFoundException" => {
return RusotoError::Service(AdminSetUserPasswordError::UserNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AdminSetUserPasswordError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AdminSetUserPasswordError::InternalError(ref cause) => write!(f, "{}", cause),
AdminSetUserPasswordError::InvalidParameter(ref cause) => write!(f, "{}", cause),
AdminSetUserPasswordError::InvalidPassword(ref cause) => write!(f, "{}", cause),
AdminSetUserPasswordError::NotAuthorized(ref cause) => write!(f, "{}", cause),
AdminSetUserPasswordError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
AdminSetUserPasswordError::TooManyRequests(ref cause) => write!(f, "{}", cause),
AdminSetUserPasswordError::UserNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for AdminSetUserPasswordError {}
#[derive(Debug, PartialEq)]
pub enum AdminSetUserSettingsError {
InternalError(String),
InvalidParameter(String),
NotAuthorized(String),
ResourceNotFound(String),
UserNotFound(String),
}
impl AdminSetUserSettingsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AdminSetUserSettingsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(AdminSetUserSettingsError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(AdminSetUserSettingsError::InvalidParameter(
err.msg,
))
}
"NotAuthorizedException" => {
return RusotoError::Service(AdminSetUserSettingsError::NotAuthorized(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(AdminSetUserSettingsError::ResourceNotFound(
err.msg,
))
}
"UserNotFoundException" => {
return RusotoError::Service(AdminSetUserSettingsError::UserNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AdminSetUserSettingsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AdminSetUserSettingsError::InternalError(ref cause) => write!(f, "{}", cause),
AdminSetUserSettingsError::InvalidParameter(ref cause) => write!(f, "{}", cause),
AdminSetUserSettingsError::NotAuthorized(ref cause) => write!(f, "{}", cause),
AdminSetUserSettingsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
AdminSetUserSettingsError::UserNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for AdminSetUserSettingsError {}
#[derive(Debug, PartialEq)]
pub enum AdminUpdateAuthEventFeedbackError {
InternalError(String),
InvalidParameter(String),
NotAuthorized(String),
ResourceNotFound(String),
TooManyRequests(String),
UserNotFound(String),
UserPoolAddOnNotEnabled(String),
}
impl AdminUpdateAuthEventFeedbackError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<AdminUpdateAuthEventFeedbackError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(AdminUpdateAuthEventFeedbackError::InternalError(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(
AdminUpdateAuthEventFeedbackError::InvalidParameter(err.msg),
)
}
"NotAuthorizedException" => {
return RusotoError::Service(AdminUpdateAuthEventFeedbackError::NotAuthorized(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(
AdminUpdateAuthEventFeedbackError::ResourceNotFound(err.msg),
)
}
"TooManyRequestsException" => {
return RusotoError::Service(
AdminUpdateAuthEventFeedbackError::TooManyRequests(err.msg),
)
}
"UserNotFoundException" => {
return RusotoError::Service(AdminUpdateAuthEventFeedbackError::UserNotFound(
err.msg,
))
}
"UserPoolAddOnNotEnabledException" => {
return RusotoError::Service(
AdminUpdateAuthEventFeedbackError::UserPoolAddOnNotEnabled(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AdminUpdateAuthEventFeedbackError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AdminUpdateAuthEventFeedbackError::InternalError(ref cause) => write!(f, "{}", cause),
AdminUpdateAuthEventFeedbackError::InvalidParameter(ref cause) => {
write!(f, "{}", cause)
}
AdminUpdateAuthEventFeedbackError::NotAuthorized(ref cause) => write!(f, "{}", cause),
AdminUpdateAuthEventFeedbackError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
AdminUpdateAuthEventFeedbackError::TooManyRequests(ref cause) => write!(f, "{}", cause),
AdminUpdateAuthEventFeedbackError::UserNotFound(ref cause) => write!(f, "{}", cause),
AdminUpdateAuthEventFeedbackError::UserPoolAddOnNotEnabled(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for AdminUpdateAuthEventFeedbackError {}
#[derive(Debug, PartialEq)]
pub enum AdminUpdateDeviceStatusError {
InternalError(String),
InvalidParameter(String),
InvalidUserPoolConfiguration(String),
NotAuthorized(String),
ResourceNotFound(String),
TooManyRequests(String),
UserNotFound(String),
}
impl AdminUpdateDeviceStatusError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AdminUpdateDeviceStatusError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(AdminUpdateDeviceStatusError::InternalError(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(AdminUpdateDeviceStatusError::InvalidParameter(
err.msg,
))
}
"InvalidUserPoolConfigurationException" => {
return RusotoError::Service(
AdminUpdateDeviceStatusError::InvalidUserPoolConfiguration(err.msg),
)
}
"NotAuthorizedException" => {
return RusotoError::Service(AdminUpdateDeviceStatusError::NotAuthorized(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(AdminUpdateDeviceStatusError::ResourceNotFound(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(AdminUpdateDeviceStatusError::TooManyRequests(
err.msg,
))
}
"UserNotFoundException" => {
return RusotoError::Service(AdminUpdateDeviceStatusError::UserNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AdminUpdateDeviceStatusError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AdminUpdateDeviceStatusError::InternalError(ref cause) => write!(f, "{}", cause),
AdminUpdateDeviceStatusError::InvalidParameter(ref cause) => write!(f, "{}", cause),
AdminUpdateDeviceStatusError::InvalidUserPoolConfiguration(ref cause) => {
write!(f, "{}", cause)
}
AdminUpdateDeviceStatusError::NotAuthorized(ref cause) => write!(f, "{}", cause),
AdminUpdateDeviceStatusError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
AdminUpdateDeviceStatusError::TooManyRequests(ref cause) => write!(f, "{}", cause),
AdminUpdateDeviceStatusError::UserNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for AdminUpdateDeviceStatusError {}
#[derive(Debug, PartialEq)]
pub enum AdminUpdateUserAttributesError {
AliasExists(String),
InternalError(String),
InvalidEmailRoleAccessPolicy(String),
InvalidLambdaResponse(String),
InvalidParameter(String),
InvalidSmsRoleAccessPolicy(String),
InvalidSmsRoleTrustRelationship(String),
NotAuthorized(String),
ResourceNotFound(String),
TooManyRequests(String),
UnexpectedLambda(String),
UserLambdaValidation(String),
UserNotFound(String),
}
impl AdminUpdateUserAttributesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AdminUpdateUserAttributesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AliasExistsException" => {
return RusotoError::Service(AdminUpdateUserAttributesError::AliasExists(
err.msg,
))
}
"InternalErrorException" => {
return RusotoError::Service(AdminUpdateUserAttributesError::InternalError(
err.msg,
))
}
"InvalidEmailRoleAccessPolicyException" => {
return RusotoError::Service(
AdminUpdateUserAttributesError::InvalidEmailRoleAccessPolicy(err.msg),
)
}
"InvalidLambdaResponseException" => {
return RusotoError::Service(
AdminUpdateUserAttributesError::InvalidLambdaResponse(err.msg),
)
}
"InvalidParameterException" => {
return RusotoError::Service(AdminUpdateUserAttributesError::InvalidParameter(
err.msg,
))
}
"InvalidSmsRoleAccessPolicyException" => {
return RusotoError::Service(
AdminUpdateUserAttributesError::InvalidSmsRoleAccessPolicy(err.msg),
)
}
"InvalidSmsRoleTrustRelationshipException" => {
return RusotoError::Service(
AdminUpdateUserAttributesError::InvalidSmsRoleTrustRelationship(err.msg),
)
}
"NotAuthorizedException" => {
return RusotoError::Service(AdminUpdateUserAttributesError::NotAuthorized(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(AdminUpdateUserAttributesError::ResourceNotFound(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(AdminUpdateUserAttributesError::TooManyRequests(
err.msg,
))
}
"UnexpectedLambdaException" => {
return RusotoError::Service(AdminUpdateUserAttributesError::UnexpectedLambda(
err.msg,
))
}
"UserLambdaValidationException" => {
return RusotoError::Service(
AdminUpdateUserAttributesError::UserLambdaValidation(err.msg),
)
}
"UserNotFoundException" => {
return RusotoError::Service(AdminUpdateUserAttributesError::UserNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AdminUpdateUserAttributesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AdminUpdateUserAttributesError::AliasExists(ref cause) => write!(f, "{}", cause),
AdminUpdateUserAttributesError::InternalError(ref cause) => write!(f, "{}", cause),
AdminUpdateUserAttributesError::InvalidEmailRoleAccessPolicy(ref cause) => {
write!(f, "{}", cause)
}
AdminUpdateUserAttributesError::InvalidLambdaResponse(ref cause) => {
write!(f, "{}", cause)
}
AdminUpdateUserAttributesError::InvalidParameter(ref cause) => write!(f, "{}", cause),
AdminUpdateUserAttributesError::InvalidSmsRoleAccessPolicy(ref cause) => {
write!(f, "{}", cause)
}
AdminUpdateUserAttributesError::InvalidSmsRoleTrustRelationship(ref cause) => {
write!(f, "{}", cause)
}
AdminUpdateUserAttributesError::NotAuthorized(ref cause) => write!(f, "{}", cause),
AdminUpdateUserAttributesError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
AdminUpdateUserAttributesError::TooManyRequests(ref cause) => write!(f, "{}", cause),
AdminUpdateUserAttributesError::UnexpectedLambda(ref cause) => write!(f, "{}", cause),
AdminUpdateUserAttributesError::UserLambdaValidation(ref cause) => {
write!(f, "{}", cause)
}
AdminUpdateUserAttributesError::UserNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for AdminUpdateUserAttributesError {}
#[derive(Debug, PartialEq)]
pub enum AdminUserGlobalSignOutError {
InternalError(String),
InvalidParameter(String),
NotAuthorized(String),
ResourceNotFound(String),
TooManyRequests(String),
UserNotFound(String),
}
impl AdminUserGlobalSignOutError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AdminUserGlobalSignOutError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(AdminUserGlobalSignOutError::InternalError(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(AdminUserGlobalSignOutError::InvalidParameter(
err.msg,
))
}
"NotAuthorizedException" => {
return RusotoError::Service(AdminUserGlobalSignOutError::NotAuthorized(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(AdminUserGlobalSignOutError::ResourceNotFound(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(AdminUserGlobalSignOutError::TooManyRequests(
err.msg,
))
}
"UserNotFoundException" => {
return RusotoError::Service(AdminUserGlobalSignOutError::UserNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AdminUserGlobalSignOutError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AdminUserGlobalSignOutError::InternalError(ref cause) => write!(f, "{}", cause),
AdminUserGlobalSignOutError::InvalidParameter(ref cause) => write!(f, "{}", cause),
AdminUserGlobalSignOutError::NotAuthorized(ref cause) => write!(f, "{}", cause),
AdminUserGlobalSignOutError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
AdminUserGlobalSignOutError::TooManyRequests(ref cause) => write!(f, "{}", cause),
AdminUserGlobalSignOutError::UserNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for AdminUserGlobalSignOutError {}
#[derive(Debug, PartialEq)]
pub enum AssociateSoftwareTokenError {
ConcurrentModification(String),
InternalError(String),
InvalidParameter(String),
NotAuthorized(String),
ResourceNotFound(String),
SoftwareTokenMFANotFound(String),
}
impl AssociateSoftwareTokenError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AssociateSoftwareTokenError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ConcurrentModificationException" => {
return RusotoError::Service(
AssociateSoftwareTokenError::ConcurrentModification(err.msg),
)
}
"InternalErrorException" => {
return RusotoError::Service(AssociateSoftwareTokenError::InternalError(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(AssociateSoftwareTokenError::InvalidParameter(
err.msg,
))
}
"NotAuthorizedException" => {
return RusotoError::Service(AssociateSoftwareTokenError::NotAuthorized(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(AssociateSoftwareTokenError::ResourceNotFound(
err.msg,
))
}
"SoftwareTokenMFANotFoundException" => {
return RusotoError::Service(
AssociateSoftwareTokenError::SoftwareTokenMFANotFound(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AssociateSoftwareTokenError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AssociateSoftwareTokenError::ConcurrentModification(ref cause) => {
write!(f, "{}", cause)
}
AssociateSoftwareTokenError::InternalError(ref cause) => write!(f, "{}", cause),
AssociateSoftwareTokenError::InvalidParameter(ref cause) => write!(f, "{}", cause),
AssociateSoftwareTokenError::NotAuthorized(ref cause) => write!(f, "{}", cause),
AssociateSoftwareTokenError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
AssociateSoftwareTokenError::SoftwareTokenMFANotFound(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for AssociateSoftwareTokenError {}
#[derive(Debug, PartialEq)]
pub enum ChangePasswordError {
InternalError(String),
InvalidParameter(String),
InvalidPassword(String),
LimitExceeded(String),
NotAuthorized(String),
PasswordResetRequired(String),
ResourceNotFound(String),
TooManyRequests(String),
UserNotConfirmed(String),
UserNotFound(String),
}
impl ChangePasswordError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ChangePasswordError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(ChangePasswordError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(ChangePasswordError::InvalidParameter(err.msg))
}
"InvalidPasswordException" => {
return RusotoError::Service(ChangePasswordError::InvalidPassword(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(ChangePasswordError::LimitExceeded(err.msg))
}
"NotAuthorizedException" => {
return RusotoError::Service(ChangePasswordError::NotAuthorized(err.msg))
}
"PasswordResetRequiredException" => {
return RusotoError::Service(ChangePasswordError::PasswordResetRequired(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ChangePasswordError::ResourceNotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(ChangePasswordError::TooManyRequests(err.msg))
}
"UserNotConfirmedException" => {
return RusotoError::Service(ChangePasswordError::UserNotConfirmed(err.msg))
}
"UserNotFoundException" => {
return RusotoError::Service(ChangePasswordError::UserNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ChangePasswordError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ChangePasswordError::InternalError(ref cause) => write!(f, "{}", cause),
ChangePasswordError::InvalidParameter(ref cause) => write!(f, "{}", cause),
ChangePasswordError::InvalidPassword(ref cause) => write!(f, "{}", cause),
ChangePasswordError::LimitExceeded(ref cause) => write!(f, "{}", cause),
ChangePasswordError::NotAuthorized(ref cause) => write!(f, "{}", cause),
ChangePasswordError::PasswordResetRequired(ref cause) => write!(f, "{}", cause),
ChangePasswordError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ChangePasswordError::TooManyRequests(ref cause) => write!(f, "{}", cause),
ChangePasswordError::UserNotConfirmed(ref cause) => write!(f, "{}", cause),
ChangePasswordError::UserNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ChangePasswordError {}
#[derive(Debug, PartialEq)]
pub enum ConfirmDeviceError {
InternalError(String),
InvalidLambdaResponse(String),
InvalidParameter(String),
InvalidPassword(String),
InvalidUserPoolConfiguration(String),
NotAuthorized(String),
PasswordResetRequired(String),
ResourceNotFound(String),
TooManyRequests(String),
UserNotConfirmed(String),
UserNotFound(String),
UsernameExists(String),
}
impl ConfirmDeviceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ConfirmDeviceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(ConfirmDeviceError::InternalError(err.msg))
}
"InvalidLambdaResponseException" => {
return RusotoError::Service(ConfirmDeviceError::InvalidLambdaResponse(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(ConfirmDeviceError::InvalidParameter(err.msg))
}
"InvalidPasswordException" => {
return RusotoError::Service(ConfirmDeviceError::InvalidPassword(err.msg))
}
"InvalidUserPoolConfigurationException" => {
return RusotoError::Service(ConfirmDeviceError::InvalidUserPoolConfiguration(
err.msg,
))
}
"NotAuthorizedException" => {
return RusotoError::Service(ConfirmDeviceError::NotAuthorized(err.msg))
}
"PasswordResetRequiredException" => {
return RusotoError::Service(ConfirmDeviceError::PasswordResetRequired(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ConfirmDeviceError::ResourceNotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(ConfirmDeviceError::TooManyRequests(err.msg))
}
"UserNotConfirmedException" => {
return RusotoError::Service(ConfirmDeviceError::UserNotConfirmed(err.msg))
}
"UserNotFoundException" => {
return RusotoError::Service(ConfirmDeviceError::UserNotFound(err.msg))
}
"UsernameExistsException" => {
return RusotoError::Service(ConfirmDeviceError::UsernameExists(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ConfirmDeviceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ConfirmDeviceError::InternalError(ref cause) => write!(f, "{}", cause),
ConfirmDeviceError::InvalidLambdaResponse(ref cause) => write!(f, "{}", cause),
ConfirmDeviceError::InvalidParameter(ref cause) => write!(f, "{}", cause),
ConfirmDeviceError::InvalidPassword(ref cause) => write!(f, "{}", cause),
ConfirmDeviceError::InvalidUserPoolConfiguration(ref cause) => write!(f, "{}", cause),
ConfirmDeviceError::NotAuthorized(ref cause) => write!(f, "{}", cause),
ConfirmDeviceError::PasswordResetRequired(ref cause) => write!(f, "{}", cause),
ConfirmDeviceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ConfirmDeviceError::TooManyRequests(ref cause) => write!(f, "{}", cause),
ConfirmDeviceError::UserNotConfirmed(ref cause) => write!(f, "{}", cause),
ConfirmDeviceError::UserNotFound(ref cause) => write!(f, "{}", cause),
ConfirmDeviceError::UsernameExists(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ConfirmDeviceError {}
#[derive(Debug, PartialEq)]
pub enum ConfirmForgotPasswordError {
CodeMismatch(String),
ExpiredCode(String),
InternalError(String),
InvalidLambdaResponse(String),
InvalidParameter(String),
InvalidPassword(String),
LimitExceeded(String),
NotAuthorized(String),
ResourceNotFound(String),
TooManyFailedAttempts(String),
TooManyRequests(String),
UnexpectedLambda(String),
UserLambdaValidation(String),
UserNotConfirmed(String),
UserNotFound(String),
}
impl ConfirmForgotPasswordError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ConfirmForgotPasswordError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"CodeMismatchException" => {
return RusotoError::Service(ConfirmForgotPasswordError::CodeMismatch(err.msg))
}
"ExpiredCodeException" => {
return RusotoError::Service(ConfirmForgotPasswordError::ExpiredCode(err.msg))
}
"InternalErrorException" => {
return RusotoError::Service(ConfirmForgotPasswordError::InternalError(err.msg))
}
"InvalidLambdaResponseException" => {
return RusotoError::Service(ConfirmForgotPasswordError::InvalidLambdaResponse(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(ConfirmForgotPasswordError::InvalidParameter(
err.msg,
))
}
"InvalidPasswordException" => {
return RusotoError::Service(ConfirmForgotPasswordError::InvalidPassword(
err.msg,
))
}
"LimitExceededException" => {
return RusotoError::Service(ConfirmForgotPasswordError::LimitExceeded(err.msg))
}
"NotAuthorizedException" => {
return RusotoError::Service(ConfirmForgotPasswordError::NotAuthorized(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ConfirmForgotPasswordError::ResourceNotFound(
err.msg,
))
}
"TooManyFailedAttemptsException" => {
return RusotoError::Service(ConfirmForgotPasswordError::TooManyFailedAttempts(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(ConfirmForgotPasswordError::TooManyRequests(
err.msg,
))
}
"UnexpectedLambdaException" => {
return RusotoError::Service(ConfirmForgotPasswordError::UnexpectedLambda(
err.msg,
))
}
"UserLambdaValidationException" => {
return RusotoError::Service(ConfirmForgotPasswordError::UserLambdaValidation(
err.msg,
))
}
"UserNotConfirmedException" => {
return RusotoError::Service(ConfirmForgotPasswordError::UserNotConfirmed(
err.msg,
))
}
"UserNotFoundException" => {
return RusotoError::Service(ConfirmForgotPasswordError::UserNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ConfirmForgotPasswordError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ConfirmForgotPasswordError::CodeMismatch(ref cause) => write!(f, "{}", cause),
ConfirmForgotPasswordError::ExpiredCode(ref cause) => write!(f, "{}", cause),
ConfirmForgotPasswordError::InternalError(ref cause) => write!(f, "{}", cause),
ConfirmForgotPasswordError::InvalidLambdaResponse(ref cause) => write!(f, "{}", cause),
ConfirmForgotPasswordError::InvalidParameter(ref cause) => write!(f, "{}", cause),
ConfirmForgotPasswordError::InvalidPassword(ref cause) => write!(f, "{}", cause),
ConfirmForgotPasswordError::LimitExceeded(ref cause) => write!(f, "{}", cause),
ConfirmForgotPasswordError::NotAuthorized(ref cause) => write!(f, "{}", cause),
ConfirmForgotPasswordError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ConfirmForgotPasswordError::TooManyFailedAttempts(ref cause) => write!(f, "{}", cause),
ConfirmForgotPasswordError::TooManyRequests(ref cause) => write!(f, "{}", cause),
ConfirmForgotPasswordError::UnexpectedLambda(ref cause) => write!(f, "{}", cause),
ConfirmForgotPasswordError::UserLambdaValidation(ref cause) => write!(f, "{}", cause),
ConfirmForgotPasswordError::UserNotConfirmed(ref cause) => write!(f, "{}", cause),
ConfirmForgotPasswordError::UserNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ConfirmForgotPasswordError {}
#[derive(Debug, PartialEq)]
pub enum ConfirmSignUpError {
AliasExists(String),
CodeMismatch(String),
ExpiredCode(String),
InternalError(String),
InvalidLambdaResponse(String),
InvalidParameter(String),
LimitExceeded(String),
NotAuthorized(String),
ResourceNotFound(String),
TooManyFailedAttempts(String),
TooManyRequests(String),
UnexpectedLambda(String),
UserLambdaValidation(String),
UserNotFound(String),
}
impl ConfirmSignUpError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ConfirmSignUpError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AliasExistsException" => {
return RusotoError::Service(ConfirmSignUpError::AliasExists(err.msg))
}
"CodeMismatchException" => {
return RusotoError::Service(ConfirmSignUpError::CodeMismatch(err.msg))
}
"ExpiredCodeException" => {
return RusotoError::Service(ConfirmSignUpError::ExpiredCode(err.msg))
}
"InternalErrorException" => {
return RusotoError::Service(ConfirmSignUpError::InternalError(err.msg))
}
"InvalidLambdaResponseException" => {
return RusotoError::Service(ConfirmSignUpError::InvalidLambdaResponse(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(ConfirmSignUpError::InvalidParameter(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(ConfirmSignUpError::LimitExceeded(err.msg))
}
"NotAuthorizedException" => {
return RusotoError::Service(ConfirmSignUpError::NotAuthorized(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ConfirmSignUpError::ResourceNotFound(err.msg))
}
"TooManyFailedAttemptsException" => {
return RusotoError::Service(ConfirmSignUpError::TooManyFailedAttempts(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(ConfirmSignUpError::TooManyRequests(err.msg))
}
"UnexpectedLambdaException" => {
return RusotoError::Service(ConfirmSignUpError::UnexpectedLambda(err.msg))
}
"UserLambdaValidationException" => {
return RusotoError::Service(ConfirmSignUpError::UserLambdaValidation(err.msg))
}
"UserNotFoundException" => {
return RusotoError::Service(ConfirmSignUpError::UserNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ConfirmSignUpError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ConfirmSignUpError::AliasExists(ref cause) => write!(f, "{}", cause),
ConfirmSignUpError::CodeMismatch(ref cause) => write!(f, "{}", cause),
ConfirmSignUpError::ExpiredCode(ref cause) => write!(f, "{}", cause),
ConfirmSignUpError::InternalError(ref cause) => write!(f, "{}", cause),
ConfirmSignUpError::InvalidLambdaResponse(ref cause) => write!(f, "{}", cause),
ConfirmSignUpError::InvalidParameter(ref cause) => write!(f, "{}", cause),
ConfirmSignUpError::LimitExceeded(ref cause) => write!(f, "{}", cause),
ConfirmSignUpError::NotAuthorized(ref cause) => write!(f, "{}", cause),
ConfirmSignUpError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ConfirmSignUpError::TooManyFailedAttempts(ref cause) => write!(f, "{}", cause),
ConfirmSignUpError::TooManyRequests(ref cause) => write!(f, "{}", cause),
ConfirmSignUpError::UnexpectedLambda(ref cause) => write!(f, "{}", cause),
ConfirmSignUpError::UserLambdaValidation(ref cause) => write!(f, "{}", cause),
ConfirmSignUpError::UserNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ConfirmSignUpError {}
#[derive(Debug, PartialEq)]
pub enum CreateGroupError {
GroupExists(String),
InternalError(String),
InvalidParameter(String),
LimitExceeded(String),
NotAuthorized(String),
ResourceNotFound(String),
TooManyRequests(String),
}
impl CreateGroupError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateGroupError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"GroupExistsException" => {
return RusotoError::Service(CreateGroupError::GroupExists(err.msg))
}
"InternalErrorException" => {
return RusotoError::Service(CreateGroupError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(CreateGroupError::InvalidParameter(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(CreateGroupError::LimitExceeded(err.msg))
}
"NotAuthorizedException" => {
return RusotoError::Service(CreateGroupError::NotAuthorized(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(CreateGroupError::ResourceNotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(CreateGroupError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateGroupError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateGroupError::GroupExists(ref cause) => write!(f, "{}", cause),
CreateGroupError::InternalError(ref cause) => write!(f, "{}", cause),
CreateGroupError::InvalidParameter(ref cause) => write!(f, "{}", cause),
CreateGroupError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreateGroupError::NotAuthorized(ref cause) => write!(f, "{}", cause),
CreateGroupError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
CreateGroupError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateGroupError {}
#[derive(Debug, PartialEq)]
pub enum CreateIdentityProviderError {
DuplicateProvider(String),
InternalError(String),
InvalidParameter(String),
LimitExceeded(String),
NotAuthorized(String),
ResourceNotFound(String),
TooManyRequests(String),
}
impl CreateIdentityProviderError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateIdentityProviderError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"DuplicateProviderException" => {
return RusotoError::Service(CreateIdentityProviderError::DuplicateProvider(
err.msg,
))
}
"InternalErrorException" => {
return RusotoError::Service(CreateIdentityProviderError::InternalError(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(CreateIdentityProviderError::InvalidParameter(
err.msg,
))
}
"LimitExceededException" => {
return RusotoError::Service(CreateIdentityProviderError::LimitExceeded(
err.msg,
))
}
"NotAuthorizedException" => {
return RusotoError::Service(CreateIdentityProviderError::NotAuthorized(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(CreateIdentityProviderError::ResourceNotFound(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(CreateIdentityProviderError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateIdentityProviderError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateIdentityProviderError::DuplicateProvider(ref cause) => write!(f, "{}", cause),
CreateIdentityProviderError::InternalError(ref cause) => write!(f, "{}", cause),
CreateIdentityProviderError::InvalidParameter(ref cause) => write!(f, "{}", cause),
CreateIdentityProviderError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreateIdentityProviderError::NotAuthorized(ref cause) => write!(f, "{}", cause),
CreateIdentityProviderError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
CreateIdentityProviderError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateIdentityProviderError {}
#[derive(Debug, PartialEq)]
pub enum CreateResourceServerError {
InternalError(String),
InvalidParameter(String),
LimitExceeded(String),
NotAuthorized(String),
ResourceNotFound(String),
TooManyRequests(String),
}
impl CreateResourceServerError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateResourceServerError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(CreateResourceServerError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(CreateResourceServerError::InvalidParameter(
err.msg,
))
}
"LimitExceededException" => {
return RusotoError::Service(CreateResourceServerError::LimitExceeded(err.msg))
}
"NotAuthorizedException" => {
return RusotoError::Service(CreateResourceServerError::NotAuthorized(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(CreateResourceServerError::ResourceNotFound(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(CreateResourceServerError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateResourceServerError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateResourceServerError::InternalError(ref cause) => write!(f, "{}", cause),
CreateResourceServerError::InvalidParameter(ref cause) => write!(f, "{}", cause),
CreateResourceServerError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreateResourceServerError::NotAuthorized(ref cause) => write!(f, "{}", cause),
CreateResourceServerError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
CreateResourceServerError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateResourceServerError {}
#[derive(Debug, PartialEq)]
pub enum CreateUserImportJobError {
InternalError(String),
InvalidParameter(String),
LimitExceeded(String),
NotAuthorized(String),
PreconditionNotMet(String),
ResourceNotFound(String),
TooManyRequests(String),
}
impl CreateUserImportJobError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateUserImportJobError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(CreateUserImportJobError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(CreateUserImportJobError::InvalidParameter(
err.msg,
))
}
"LimitExceededException" => {
return RusotoError::Service(CreateUserImportJobError::LimitExceeded(err.msg))
}
"NotAuthorizedException" => {
return RusotoError::Service(CreateUserImportJobError::NotAuthorized(err.msg))
}
"PreconditionNotMetException" => {
return RusotoError::Service(CreateUserImportJobError::PreconditionNotMet(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(CreateUserImportJobError::ResourceNotFound(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(CreateUserImportJobError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateUserImportJobError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateUserImportJobError::InternalError(ref cause) => write!(f, "{}", cause),
CreateUserImportJobError::InvalidParameter(ref cause) => write!(f, "{}", cause),
CreateUserImportJobError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreateUserImportJobError::NotAuthorized(ref cause) => write!(f, "{}", cause),
CreateUserImportJobError::PreconditionNotMet(ref cause) => write!(f, "{}", cause),
CreateUserImportJobError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
CreateUserImportJobError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateUserImportJobError {}
#[derive(Debug, PartialEq)]
pub enum CreateUserPoolError {
InternalError(String),
InvalidEmailRoleAccessPolicy(String),
InvalidParameter(String),
InvalidSmsRoleAccessPolicy(String),
InvalidSmsRoleTrustRelationship(String),
LimitExceeded(String),
NotAuthorized(String),
TooManyRequests(String),
UserPoolTagging(String),
}
impl CreateUserPoolError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateUserPoolError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(CreateUserPoolError::InternalError(err.msg))
}
"InvalidEmailRoleAccessPolicyException" => {
return RusotoError::Service(CreateUserPoolError::InvalidEmailRoleAccessPolicy(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(CreateUserPoolError::InvalidParameter(err.msg))
}
"InvalidSmsRoleAccessPolicyException" => {
return RusotoError::Service(CreateUserPoolError::InvalidSmsRoleAccessPolicy(
err.msg,
))
}
"InvalidSmsRoleTrustRelationshipException" => {
return RusotoError::Service(
CreateUserPoolError::InvalidSmsRoleTrustRelationship(err.msg),
)
}
"LimitExceededException" => {
return RusotoError::Service(CreateUserPoolError::LimitExceeded(err.msg))
}
"NotAuthorizedException" => {
return RusotoError::Service(CreateUserPoolError::NotAuthorized(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(CreateUserPoolError::TooManyRequests(err.msg))
}
"UserPoolTaggingException" => {
return RusotoError::Service(CreateUserPoolError::UserPoolTagging(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateUserPoolError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateUserPoolError::InternalError(ref cause) => write!(f, "{}", cause),
CreateUserPoolError::InvalidEmailRoleAccessPolicy(ref cause) => write!(f, "{}", cause),
CreateUserPoolError::InvalidParameter(ref cause) => write!(f, "{}", cause),
CreateUserPoolError::InvalidSmsRoleAccessPolicy(ref cause) => write!(f, "{}", cause),
CreateUserPoolError::InvalidSmsRoleTrustRelationship(ref cause) => {
write!(f, "{}", cause)
}
CreateUserPoolError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreateUserPoolError::NotAuthorized(ref cause) => write!(f, "{}", cause),
CreateUserPoolError::TooManyRequests(ref cause) => write!(f, "{}", cause),
CreateUserPoolError::UserPoolTagging(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateUserPoolError {}
#[derive(Debug, PartialEq)]
pub enum CreateUserPoolClientError {
InternalError(String),
InvalidOAuthFlow(String),
InvalidParameter(String),
LimitExceeded(String),
NotAuthorized(String),
ResourceNotFound(String),
ScopeDoesNotExist(String),
TooManyRequests(String),
}
impl CreateUserPoolClientError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateUserPoolClientError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(CreateUserPoolClientError::InternalError(err.msg))
}
"InvalidOAuthFlowException" => {
return RusotoError::Service(CreateUserPoolClientError::InvalidOAuthFlow(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(CreateUserPoolClientError::InvalidParameter(
err.msg,
))
}
"LimitExceededException" => {
return RusotoError::Service(CreateUserPoolClientError::LimitExceeded(err.msg))
}
"NotAuthorizedException" => {
return RusotoError::Service(CreateUserPoolClientError::NotAuthorized(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(CreateUserPoolClientError::ResourceNotFound(
err.msg,
))
}
"ScopeDoesNotExistException" => {
return RusotoError::Service(CreateUserPoolClientError::ScopeDoesNotExist(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(CreateUserPoolClientError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateUserPoolClientError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateUserPoolClientError::InternalError(ref cause) => write!(f, "{}", cause),
CreateUserPoolClientError::InvalidOAuthFlow(ref cause) => write!(f, "{}", cause),
CreateUserPoolClientError::InvalidParameter(ref cause) => write!(f, "{}", cause),
CreateUserPoolClientError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreateUserPoolClientError::NotAuthorized(ref cause) => write!(f, "{}", cause),
CreateUserPoolClientError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
CreateUserPoolClientError::ScopeDoesNotExist(ref cause) => write!(f, "{}", cause),
CreateUserPoolClientError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateUserPoolClientError {}
#[derive(Debug, PartialEq)]
pub enum CreateUserPoolDomainError {
InternalError(String),
InvalidParameter(String),
LimitExceeded(String),
NotAuthorized(String),
ResourceNotFound(String),
}
impl CreateUserPoolDomainError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateUserPoolDomainError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(CreateUserPoolDomainError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(CreateUserPoolDomainError::InvalidParameter(
err.msg,
))
}
"LimitExceededException" => {
return RusotoError::Service(CreateUserPoolDomainError::LimitExceeded(err.msg))
}
"NotAuthorizedException" => {
return RusotoError::Service(CreateUserPoolDomainError::NotAuthorized(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(CreateUserPoolDomainError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateUserPoolDomainError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateUserPoolDomainError::InternalError(ref cause) => write!(f, "{}", cause),
CreateUserPoolDomainError::InvalidParameter(ref cause) => write!(f, "{}", cause),
CreateUserPoolDomainError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreateUserPoolDomainError::NotAuthorized(ref cause) => write!(f, "{}", cause),
CreateUserPoolDomainError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateUserPoolDomainError {}
#[derive(Debug, PartialEq)]
pub enum DeleteGroupError {
InternalError(String),
InvalidParameter(String),
NotAuthorized(String),
ResourceNotFound(String),
TooManyRequests(String),
}
impl DeleteGroupError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteGroupError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(DeleteGroupError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(DeleteGroupError::InvalidParameter(err.msg))
}
"NotAuthorizedException" => {
return RusotoError::Service(DeleteGroupError::NotAuthorized(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DeleteGroupError::ResourceNotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(DeleteGroupError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteGroupError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteGroupError::InternalError(ref cause) => write!(f, "{}", cause),
DeleteGroupError::InvalidParameter(ref cause) => write!(f, "{}", cause),
DeleteGroupError::NotAuthorized(ref cause) => write!(f, "{}", cause),
DeleteGroupError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DeleteGroupError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteGroupError {}
#[derive(Debug, PartialEq)]
pub enum DeleteIdentityProviderError {
InternalError(String),
InvalidParameter(String),
NotAuthorized(String),
ResourceNotFound(String),
TooManyRequests(String),
UnsupportedIdentityProvider(String),
}
impl DeleteIdentityProviderError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteIdentityProviderError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(DeleteIdentityProviderError::InternalError(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(DeleteIdentityProviderError::InvalidParameter(
err.msg,
))
}
"NotAuthorizedException" => {
return RusotoError::Service(DeleteIdentityProviderError::NotAuthorized(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DeleteIdentityProviderError::ResourceNotFound(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(DeleteIdentityProviderError::TooManyRequests(
err.msg,
))
}
"UnsupportedIdentityProviderException" => {
return RusotoError::Service(
DeleteIdentityProviderError::UnsupportedIdentityProvider(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteIdentityProviderError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteIdentityProviderError::InternalError(ref cause) => write!(f, "{}", cause),
DeleteIdentityProviderError::InvalidParameter(ref cause) => write!(f, "{}", cause),
DeleteIdentityProviderError::NotAuthorized(ref cause) => write!(f, "{}", cause),
DeleteIdentityProviderError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DeleteIdentityProviderError::TooManyRequests(ref cause) => write!(f, "{}", cause),
DeleteIdentityProviderError::UnsupportedIdentityProvider(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DeleteIdentityProviderError {}
#[derive(Debug, PartialEq)]
pub enum DeleteResourceServerError {
InternalError(String),
InvalidParameter(String),
NotAuthorized(String),
ResourceNotFound(String),
TooManyRequests(String),
}
impl DeleteResourceServerError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteResourceServerError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(DeleteResourceServerError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(DeleteResourceServerError::InvalidParameter(
err.msg,
))
}
"NotAuthorizedException" => {
return RusotoError::Service(DeleteResourceServerError::NotAuthorized(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DeleteResourceServerError::ResourceNotFound(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(DeleteResourceServerError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteResourceServerError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteResourceServerError::InternalError(ref cause) => write!(f, "{}", cause),
DeleteResourceServerError::InvalidParameter(ref cause) => write!(f, "{}", cause),
DeleteResourceServerError::NotAuthorized(ref cause) => write!(f, "{}", cause),
DeleteResourceServerError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DeleteResourceServerError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteResourceServerError {}
#[derive(Debug, PartialEq)]
pub enum DeleteUserError {
InternalError(String),
InvalidParameter(String),
NotAuthorized(String),
PasswordResetRequired(String),
ResourceNotFound(String),
TooManyRequests(String),
UserNotConfirmed(String),
UserNotFound(String),
}
impl DeleteUserError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteUserError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(DeleteUserError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(DeleteUserError::InvalidParameter(err.msg))
}
"NotAuthorizedException" => {
return RusotoError::Service(DeleteUserError::NotAuthorized(err.msg))
}
"PasswordResetRequiredException" => {
return RusotoError::Service(DeleteUserError::PasswordResetRequired(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DeleteUserError::ResourceNotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(DeleteUserError::TooManyRequests(err.msg))
}
"UserNotConfirmedException" => {
return RusotoError::Service(DeleteUserError::UserNotConfirmed(err.msg))
}
"UserNotFoundException" => {
return RusotoError::Service(DeleteUserError::UserNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteUserError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteUserError::InternalError(ref cause) => write!(f, "{}", cause),
DeleteUserError::InvalidParameter(ref cause) => write!(f, "{}", cause),
DeleteUserError::NotAuthorized(ref cause) => write!(f, "{}", cause),
DeleteUserError::PasswordResetRequired(ref cause) => write!(f, "{}", cause),
DeleteUserError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DeleteUserError::TooManyRequests(ref cause) => write!(f, "{}", cause),
DeleteUserError::UserNotConfirmed(ref cause) => write!(f, "{}", cause),
DeleteUserError::UserNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteUserError {}
#[derive(Debug, PartialEq)]
pub enum DeleteUserAttributesError {
InternalError(String),
InvalidParameter(String),
NotAuthorized(String),
PasswordResetRequired(String),
ResourceNotFound(String),
TooManyRequests(String),
UserNotConfirmed(String),
UserNotFound(String),
}
impl DeleteUserAttributesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteUserAttributesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(DeleteUserAttributesError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(DeleteUserAttributesError::InvalidParameter(
err.msg,
))
}
"NotAuthorizedException" => {
return RusotoError::Service(DeleteUserAttributesError::NotAuthorized(err.msg))
}
"PasswordResetRequiredException" => {
return RusotoError::Service(DeleteUserAttributesError::PasswordResetRequired(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DeleteUserAttributesError::ResourceNotFound(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(DeleteUserAttributesError::TooManyRequests(
err.msg,
))
}
"UserNotConfirmedException" => {
return RusotoError::Service(DeleteUserAttributesError::UserNotConfirmed(
err.msg,
))
}
"UserNotFoundException" => {
return RusotoError::Service(DeleteUserAttributesError::UserNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteUserAttributesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteUserAttributesError::InternalError(ref cause) => write!(f, "{}", cause),
DeleteUserAttributesError::InvalidParameter(ref cause) => write!(f, "{}", cause),
DeleteUserAttributesError::NotAuthorized(ref cause) => write!(f, "{}", cause),
DeleteUserAttributesError::PasswordResetRequired(ref cause) => write!(f, "{}", cause),
DeleteUserAttributesError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DeleteUserAttributesError::TooManyRequests(ref cause) => write!(f, "{}", cause),
DeleteUserAttributesError::UserNotConfirmed(ref cause) => write!(f, "{}", cause),
DeleteUserAttributesError::UserNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteUserAttributesError {}
#[derive(Debug, PartialEq)]
pub enum DeleteUserPoolError {
InternalError(String),
InvalidParameter(String),
NotAuthorized(String),
ResourceNotFound(String),
TooManyRequests(String),
UserImportInProgress(String),
}
impl DeleteUserPoolError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteUserPoolError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(DeleteUserPoolError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(DeleteUserPoolError::InvalidParameter(err.msg))
}
"NotAuthorizedException" => {
return RusotoError::Service(DeleteUserPoolError::NotAuthorized(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DeleteUserPoolError::ResourceNotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(DeleteUserPoolError::TooManyRequests(err.msg))
}
"UserImportInProgressException" => {
return RusotoError::Service(DeleteUserPoolError::UserImportInProgress(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteUserPoolError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteUserPoolError::InternalError(ref cause) => write!(f, "{}", cause),
DeleteUserPoolError::InvalidParameter(ref cause) => write!(f, "{}", cause),
DeleteUserPoolError::NotAuthorized(ref cause) => write!(f, "{}", cause),
DeleteUserPoolError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DeleteUserPoolError::TooManyRequests(ref cause) => write!(f, "{}", cause),
DeleteUserPoolError::UserImportInProgress(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteUserPoolError {}
#[derive(Debug, PartialEq)]
pub enum DeleteUserPoolClientError {
InternalError(String),
InvalidParameter(String),
NotAuthorized(String),
ResourceNotFound(String),
TooManyRequests(String),
}
impl DeleteUserPoolClientError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteUserPoolClientError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(DeleteUserPoolClientError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(DeleteUserPoolClientError::InvalidParameter(
err.msg,
))
}
"NotAuthorizedException" => {
return RusotoError::Service(DeleteUserPoolClientError::NotAuthorized(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DeleteUserPoolClientError::ResourceNotFound(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(DeleteUserPoolClientError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteUserPoolClientError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteUserPoolClientError::InternalError(ref cause) => write!(f, "{}", cause),
DeleteUserPoolClientError::InvalidParameter(ref cause) => write!(f, "{}", cause),
DeleteUserPoolClientError::NotAuthorized(ref cause) => write!(f, "{}", cause),
DeleteUserPoolClientError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DeleteUserPoolClientError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteUserPoolClientError {}
#[derive(Debug, PartialEq)]
pub enum DeleteUserPoolDomainError {
InternalError(String),
InvalidParameter(String),
NotAuthorized(String),
ResourceNotFound(String),
}
impl DeleteUserPoolDomainError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteUserPoolDomainError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(DeleteUserPoolDomainError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(DeleteUserPoolDomainError::InvalidParameter(
err.msg,
))
}
"NotAuthorizedException" => {
return RusotoError::Service(DeleteUserPoolDomainError::NotAuthorized(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DeleteUserPoolDomainError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteUserPoolDomainError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteUserPoolDomainError::InternalError(ref cause) => write!(f, "{}", cause),
DeleteUserPoolDomainError::InvalidParameter(ref cause) => write!(f, "{}", cause),
DeleteUserPoolDomainError::NotAuthorized(ref cause) => write!(f, "{}", cause),
DeleteUserPoolDomainError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteUserPoolDomainError {}
#[derive(Debug, PartialEq)]
pub enum DescribeIdentityProviderError {
InternalError(String),
InvalidParameter(String),
NotAuthorized(String),
ResourceNotFound(String),
TooManyRequests(String),
}
impl DescribeIdentityProviderError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeIdentityProviderError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(DescribeIdentityProviderError::InternalError(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(DescribeIdentityProviderError::InvalidParameter(
err.msg,
))
}
"NotAuthorizedException" => {
return RusotoError::Service(DescribeIdentityProviderError::NotAuthorized(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeIdentityProviderError::ResourceNotFound(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(DescribeIdentityProviderError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeIdentityProviderError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeIdentityProviderError::InternalError(ref cause) => write!(f, "{}", cause),
DescribeIdentityProviderError::InvalidParameter(ref cause) => write!(f, "{}", cause),
DescribeIdentityProviderError::NotAuthorized(ref cause) => write!(f, "{}", cause),
DescribeIdentityProviderError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DescribeIdentityProviderError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeIdentityProviderError {}
#[derive(Debug, PartialEq)]
pub enum DescribeResourceServerError {
InternalError(String),
InvalidParameter(String),
NotAuthorized(String),
ResourceNotFound(String),
TooManyRequests(String),
}
impl DescribeResourceServerError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeResourceServerError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(DescribeResourceServerError::InternalError(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(DescribeResourceServerError::InvalidParameter(
err.msg,
))
}
"NotAuthorizedException" => {
return RusotoError::Service(DescribeResourceServerError::NotAuthorized(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeResourceServerError::ResourceNotFound(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(DescribeResourceServerError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeResourceServerError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeResourceServerError::InternalError(ref cause) => write!(f, "{}", cause),
DescribeResourceServerError::InvalidParameter(ref cause) => write!(f, "{}", cause),
DescribeResourceServerError::NotAuthorized(ref cause) => write!(f, "{}", cause),
DescribeResourceServerError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DescribeResourceServerError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeResourceServerError {}
#[derive(Debug, PartialEq)]
pub enum DescribeRiskConfigurationError {
InternalError(String),
InvalidParameter(String),
NotAuthorized(String),
ResourceNotFound(String),
TooManyRequests(String),
UserPoolAddOnNotEnabled(String),
}
impl DescribeRiskConfigurationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeRiskConfigurationError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(DescribeRiskConfigurationError::InternalError(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(DescribeRiskConfigurationError::InvalidParameter(
err.msg,
))
}
"NotAuthorizedException" => {
return RusotoError::Service(DescribeRiskConfigurationError::NotAuthorized(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeRiskConfigurationError::ResourceNotFound(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(DescribeRiskConfigurationError::TooManyRequests(
err.msg,
))
}
"UserPoolAddOnNotEnabledException" => {
return RusotoError::Service(
DescribeRiskConfigurationError::UserPoolAddOnNotEnabled(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeRiskConfigurationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeRiskConfigurationError::InternalError(ref cause) => write!(f, "{}", cause),
DescribeRiskConfigurationError::InvalidParameter(ref cause) => write!(f, "{}", cause),
DescribeRiskConfigurationError::NotAuthorized(ref cause) => write!(f, "{}", cause),
DescribeRiskConfigurationError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DescribeRiskConfigurationError::TooManyRequests(ref cause) => write!(f, "{}", cause),
DescribeRiskConfigurationError::UserPoolAddOnNotEnabled(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeRiskConfigurationError {}
#[derive(Debug, PartialEq)]
pub enum DescribeUserImportJobError {
InternalError(String),
InvalidParameter(String),
NotAuthorized(String),
ResourceNotFound(String),
TooManyRequests(String),
}
impl DescribeUserImportJobError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeUserImportJobError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(DescribeUserImportJobError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(DescribeUserImportJobError::InvalidParameter(
err.msg,
))
}
"NotAuthorizedException" => {
return RusotoError::Service(DescribeUserImportJobError::NotAuthorized(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeUserImportJobError::ResourceNotFound(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(DescribeUserImportJobError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeUserImportJobError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeUserImportJobError::InternalError(ref cause) => write!(f, "{}", cause),
DescribeUserImportJobError::InvalidParameter(ref cause) => write!(f, "{}", cause),
DescribeUserImportJobError::NotAuthorized(ref cause) => write!(f, "{}", cause),
DescribeUserImportJobError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DescribeUserImportJobError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeUserImportJobError {}
#[derive(Debug, PartialEq)]
pub enum DescribeUserPoolError {
InternalError(String),
InvalidParameter(String),
NotAuthorized(String),
ResourceNotFound(String),
TooManyRequests(String),
UserPoolTagging(String),
}
impl DescribeUserPoolError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeUserPoolError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(DescribeUserPoolError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(DescribeUserPoolError::InvalidParameter(err.msg))
}
"NotAuthorizedException" => {
return RusotoError::Service(DescribeUserPoolError::NotAuthorized(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeUserPoolError::ResourceNotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(DescribeUserPoolError::TooManyRequests(err.msg))
}
"UserPoolTaggingException" => {
return RusotoError::Service(DescribeUserPoolError::UserPoolTagging(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeUserPoolError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeUserPoolError::InternalError(ref cause) => write!(f, "{}", cause),
DescribeUserPoolError::InvalidParameter(ref cause) => write!(f, "{}", cause),
DescribeUserPoolError::NotAuthorized(ref cause) => write!(f, "{}", cause),
DescribeUserPoolError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DescribeUserPoolError::TooManyRequests(ref cause) => write!(f, "{}", cause),
DescribeUserPoolError::UserPoolTagging(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeUserPoolError {}
#[derive(Debug, PartialEq)]
pub enum DescribeUserPoolClientError {
InternalError(String),
InvalidParameter(String),
NotAuthorized(String),
ResourceNotFound(String),
TooManyRequests(String),
}
impl DescribeUserPoolClientError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeUserPoolClientError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(DescribeUserPoolClientError::InternalError(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(DescribeUserPoolClientError::InvalidParameter(
err.msg,
))
}
"NotAuthorizedException" => {
return RusotoError::Service(DescribeUserPoolClientError::NotAuthorized(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeUserPoolClientError::ResourceNotFound(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(DescribeUserPoolClientError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeUserPoolClientError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeUserPoolClientError::InternalError(ref cause) => write!(f, "{}", cause),
DescribeUserPoolClientError::InvalidParameter(ref cause) => write!(f, "{}", cause),
DescribeUserPoolClientError::NotAuthorized(ref cause) => write!(f, "{}", cause),
DescribeUserPoolClientError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DescribeUserPoolClientError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeUserPoolClientError {}
#[derive(Debug, PartialEq)]
pub enum DescribeUserPoolDomainError {
InternalError(String),
InvalidParameter(String),
NotAuthorized(String),
ResourceNotFound(String),
}
impl DescribeUserPoolDomainError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeUserPoolDomainError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(DescribeUserPoolDomainError::InternalError(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(DescribeUserPoolDomainError::InvalidParameter(
err.msg,
))
}
"NotAuthorizedException" => {
return RusotoError::Service(DescribeUserPoolDomainError::NotAuthorized(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeUserPoolDomainError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeUserPoolDomainError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeUserPoolDomainError::InternalError(ref cause) => write!(f, "{}", cause),
DescribeUserPoolDomainError::InvalidParameter(ref cause) => write!(f, "{}", cause),
DescribeUserPoolDomainError::NotAuthorized(ref cause) => write!(f, "{}", cause),
DescribeUserPoolDomainError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeUserPoolDomainError {}
#[derive(Debug, PartialEq)]
pub enum ForgetDeviceError {
InternalError(String),
InvalidParameter(String),
InvalidUserPoolConfiguration(String),
NotAuthorized(String),
PasswordResetRequired(String),
ResourceNotFound(String),
TooManyRequests(String),
UserNotConfirmed(String),
UserNotFound(String),
}
impl ForgetDeviceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ForgetDeviceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(ForgetDeviceError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(ForgetDeviceError::InvalidParameter(err.msg))
}
"InvalidUserPoolConfigurationException" => {
return RusotoError::Service(ForgetDeviceError::InvalidUserPoolConfiguration(
err.msg,
))
}
"NotAuthorizedException" => {
return RusotoError::Service(ForgetDeviceError::NotAuthorized(err.msg))
}
"PasswordResetRequiredException" => {
return RusotoError::Service(ForgetDeviceError::PasswordResetRequired(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ForgetDeviceError::ResourceNotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(ForgetDeviceError::TooManyRequests(err.msg))
}
"UserNotConfirmedException" => {
return RusotoError::Service(ForgetDeviceError::UserNotConfirmed(err.msg))
}
"UserNotFoundException" => {
return RusotoError::Service(ForgetDeviceError::UserNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ForgetDeviceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ForgetDeviceError::InternalError(ref cause) => write!(f, "{}", cause),
ForgetDeviceError::InvalidParameter(ref cause) => write!(f, "{}", cause),
ForgetDeviceError::InvalidUserPoolConfiguration(ref cause) => write!(f, "{}", cause),
ForgetDeviceError::NotAuthorized(ref cause) => write!(f, "{}", cause),
ForgetDeviceError::PasswordResetRequired(ref cause) => write!(f, "{}", cause),
ForgetDeviceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ForgetDeviceError::TooManyRequests(ref cause) => write!(f, "{}", cause),
ForgetDeviceError::UserNotConfirmed(ref cause) => write!(f, "{}", cause),
ForgetDeviceError::UserNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ForgetDeviceError {}
#[derive(Debug, PartialEq)]
pub enum ForgotPasswordError {
CodeDeliveryFailure(String),
InternalError(String),
InvalidEmailRoleAccessPolicy(String),
InvalidLambdaResponse(String),
InvalidParameter(String),
InvalidSmsRoleAccessPolicy(String),
InvalidSmsRoleTrustRelationship(String),
LimitExceeded(String),
NotAuthorized(String),
ResourceNotFound(String),
TooManyRequests(String),
UnexpectedLambda(String),
UserLambdaValidation(String),
UserNotConfirmed(String),
UserNotFound(String),
}
impl ForgotPasswordError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ForgotPasswordError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"CodeDeliveryFailureException" => {
return RusotoError::Service(ForgotPasswordError::CodeDeliveryFailure(err.msg))
}
"InternalErrorException" => {
return RusotoError::Service(ForgotPasswordError::InternalError(err.msg))
}
"InvalidEmailRoleAccessPolicyException" => {
return RusotoError::Service(ForgotPasswordError::InvalidEmailRoleAccessPolicy(
err.msg,
))
}
"InvalidLambdaResponseException" => {
return RusotoError::Service(ForgotPasswordError::InvalidLambdaResponse(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(ForgotPasswordError::InvalidParameter(err.msg))
}
"InvalidSmsRoleAccessPolicyException" => {
return RusotoError::Service(ForgotPasswordError::InvalidSmsRoleAccessPolicy(
err.msg,
))
}
"InvalidSmsRoleTrustRelationshipException" => {
return RusotoError::Service(
ForgotPasswordError::InvalidSmsRoleTrustRelationship(err.msg),
)
}
"LimitExceededException" => {
return RusotoError::Service(ForgotPasswordError::LimitExceeded(err.msg))
}
"NotAuthorizedException" => {
return RusotoError::Service(ForgotPasswordError::NotAuthorized(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ForgotPasswordError::ResourceNotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(ForgotPasswordError::TooManyRequests(err.msg))
}
"UnexpectedLambdaException" => {
return RusotoError::Service(ForgotPasswordError::UnexpectedLambda(err.msg))
}
"UserLambdaValidationException" => {
return RusotoError::Service(ForgotPasswordError::UserLambdaValidation(err.msg))
}
"UserNotConfirmedException" => {
return RusotoError::Service(ForgotPasswordError::UserNotConfirmed(err.msg))
}
"UserNotFoundException" => {
return RusotoError::Service(ForgotPasswordError::UserNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ForgotPasswordError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ForgotPasswordError::CodeDeliveryFailure(ref cause) => write!(f, "{}", cause),
ForgotPasswordError::InternalError(ref cause) => write!(f, "{}", cause),
ForgotPasswordError::InvalidEmailRoleAccessPolicy(ref cause) => write!(f, "{}", cause),
ForgotPasswordError::InvalidLambdaResponse(ref cause) => write!(f, "{}", cause),
ForgotPasswordError::InvalidParameter(ref cause) => write!(f, "{}", cause),
ForgotPasswordError::InvalidSmsRoleAccessPolicy(ref cause) => write!(f, "{}", cause),
ForgotPasswordError::InvalidSmsRoleTrustRelationship(ref cause) => {
write!(f, "{}", cause)
}
ForgotPasswordError::LimitExceeded(ref cause) => write!(f, "{}", cause),
ForgotPasswordError::NotAuthorized(ref cause) => write!(f, "{}", cause),
ForgotPasswordError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ForgotPasswordError::TooManyRequests(ref cause) => write!(f, "{}", cause),
ForgotPasswordError::UnexpectedLambda(ref cause) => write!(f, "{}", cause),
ForgotPasswordError::UserLambdaValidation(ref cause) => write!(f, "{}", cause),
ForgotPasswordError::UserNotConfirmed(ref cause) => write!(f, "{}", cause),
ForgotPasswordError::UserNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ForgotPasswordError {}
#[derive(Debug, PartialEq)]
pub enum GetCSVHeaderError {
InternalError(String),
InvalidParameter(String),
NotAuthorized(String),
ResourceNotFound(String),
TooManyRequests(String),
}
impl GetCSVHeaderError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetCSVHeaderError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(GetCSVHeaderError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(GetCSVHeaderError::InvalidParameter(err.msg))
}
"NotAuthorizedException" => {
return RusotoError::Service(GetCSVHeaderError::NotAuthorized(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(GetCSVHeaderError::ResourceNotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(GetCSVHeaderError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetCSVHeaderError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetCSVHeaderError::InternalError(ref cause) => write!(f, "{}", cause),
GetCSVHeaderError::InvalidParameter(ref cause) => write!(f, "{}", cause),
GetCSVHeaderError::NotAuthorized(ref cause) => write!(f, "{}", cause),
GetCSVHeaderError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
GetCSVHeaderError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetCSVHeaderError {}
#[derive(Debug, PartialEq)]
pub enum GetDeviceError {
InternalError(String),
InvalidParameter(String),
InvalidUserPoolConfiguration(String),
NotAuthorized(String),
PasswordResetRequired(String),
ResourceNotFound(String),
TooManyRequests(String),
UserNotConfirmed(String),
UserNotFound(String),
}
impl GetDeviceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetDeviceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(GetDeviceError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(GetDeviceError::InvalidParameter(err.msg))
}
"InvalidUserPoolConfigurationException" => {
return RusotoError::Service(GetDeviceError::InvalidUserPoolConfiguration(
err.msg,
))
}
"NotAuthorizedException" => {
return RusotoError::Service(GetDeviceError::NotAuthorized(err.msg))
}
"PasswordResetRequiredException" => {
return RusotoError::Service(GetDeviceError::PasswordResetRequired(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(GetDeviceError::ResourceNotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(GetDeviceError::TooManyRequests(err.msg))
}
"UserNotConfirmedException" => {
return RusotoError::Service(GetDeviceError::UserNotConfirmed(err.msg))
}
"UserNotFoundException" => {
return RusotoError::Service(GetDeviceError::UserNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetDeviceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetDeviceError::InternalError(ref cause) => write!(f, "{}", cause),
GetDeviceError::InvalidParameter(ref cause) => write!(f, "{}", cause),
GetDeviceError::InvalidUserPoolConfiguration(ref cause) => write!(f, "{}", cause),
GetDeviceError::NotAuthorized(ref cause) => write!(f, "{}", cause),
GetDeviceError::PasswordResetRequired(ref cause) => write!(f, "{}", cause),
GetDeviceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
GetDeviceError::TooManyRequests(ref cause) => write!(f, "{}", cause),
GetDeviceError::UserNotConfirmed(ref cause) => write!(f, "{}", cause),
GetDeviceError::UserNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetDeviceError {}
#[derive(Debug, PartialEq)]
pub enum GetGroupError {
InternalError(String),
InvalidParameter(String),
NotAuthorized(String),
ResourceNotFound(String),
TooManyRequests(String),
}
impl GetGroupError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetGroupError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(GetGroupError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(GetGroupError::InvalidParameter(err.msg))
}
"NotAuthorizedException" => {
return RusotoError::Service(GetGroupError::NotAuthorized(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(GetGroupError::ResourceNotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(GetGroupError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetGroupError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetGroupError::InternalError(ref cause) => write!(f, "{}", cause),
GetGroupError::InvalidParameter(ref cause) => write!(f, "{}", cause),
GetGroupError::NotAuthorized(ref cause) => write!(f, "{}", cause),
GetGroupError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
GetGroupError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetGroupError {}
#[derive(Debug, PartialEq)]
pub enum GetIdentityProviderByIdentifierError {
InternalError(String),
InvalidParameter(String),
NotAuthorized(String),
ResourceNotFound(String),
TooManyRequests(String),
}
impl GetIdentityProviderByIdentifierError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetIdentityProviderByIdentifierError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(
GetIdentityProviderByIdentifierError::InternalError(err.msg),
)
}
"InvalidParameterException" => {
return RusotoError::Service(
GetIdentityProviderByIdentifierError::InvalidParameter(err.msg),
)
}
"NotAuthorizedException" => {
return RusotoError::Service(
GetIdentityProviderByIdentifierError::NotAuthorized(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
GetIdentityProviderByIdentifierError::ResourceNotFound(err.msg),
)
}
"TooManyRequestsException" => {
return RusotoError::Service(
GetIdentityProviderByIdentifierError::TooManyRequests(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetIdentityProviderByIdentifierError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetIdentityProviderByIdentifierError::InternalError(ref cause) => {
write!(f, "{}", cause)
}
GetIdentityProviderByIdentifierError::InvalidParameter(ref cause) => {
write!(f, "{}", cause)
}
GetIdentityProviderByIdentifierError::NotAuthorized(ref cause) => {
write!(f, "{}", cause)
}
GetIdentityProviderByIdentifierError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
GetIdentityProviderByIdentifierError::TooManyRequests(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for GetIdentityProviderByIdentifierError {}
#[derive(Debug, PartialEq)]
pub enum GetSigningCertificateError {
InternalError(String),
InvalidParameter(String),
ResourceNotFound(String),
}
impl GetSigningCertificateError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetSigningCertificateError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(GetSigningCertificateError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(GetSigningCertificateError::InvalidParameter(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(GetSigningCertificateError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetSigningCertificateError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetSigningCertificateError::InternalError(ref cause) => write!(f, "{}", cause),
GetSigningCertificateError::InvalidParameter(ref cause) => write!(f, "{}", cause),
GetSigningCertificateError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetSigningCertificateError {}
#[derive(Debug, PartialEq)]
pub enum GetUICustomizationError {
InternalError(String),
InvalidParameter(String),
NotAuthorized(String),
ResourceNotFound(String),
TooManyRequests(String),
}
impl GetUICustomizationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetUICustomizationError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(GetUICustomizationError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(GetUICustomizationError::InvalidParameter(err.msg))
}
"NotAuthorizedException" => {
return RusotoError::Service(GetUICustomizationError::NotAuthorized(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(GetUICustomizationError::ResourceNotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(GetUICustomizationError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetUICustomizationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetUICustomizationError::InternalError(ref cause) => write!(f, "{}", cause),
GetUICustomizationError::InvalidParameter(ref cause) => write!(f, "{}", cause),
GetUICustomizationError::NotAuthorized(ref cause) => write!(f, "{}", cause),
GetUICustomizationError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
GetUICustomizationError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetUICustomizationError {}
#[derive(Debug, PartialEq)]
pub enum GetUserError {
InternalError(String),
InvalidParameter(String),
NotAuthorized(String),
PasswordResetRequired(String),
ResourceNotFound(String),
TooManyRequests(String),
UserNotConfirmed(String),
UserNotFound(String),
}
impl GetUserError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetUserError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(GetUserError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(GetUserError::InvalidParameter(err.msg))
}
"NotAuthorizedException" => {
return RusotoError::Service(GetUserError::NotAuthorized(err.msg))
}
"PasswordResetRequiredException" => {
return RusotoError::Service(GetUserError::PasswordResetRequired(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(GetUserError::ResourceNotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(GetUserError::TooManyRequests(err.msg))
}
"UserNotConfirmedException" => {
return RusotoError::Service(GetUserError::UserNotConfirmed(err.msg))
}
"UserNotFoundException" => {
return RusotoError::Service(GetUserError::UserNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetUserError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetUserError::InternalError(ref cause) => write!(f, "{}", cause),
GetUserError::InvalidParameter(ref cause) => write!(f, "{}", cause),
GetUserError::NotAuthorized(ref cause) => write!(f, "{}", cause),
GetUserError::PasswordResetRequired(ref cause) => write!(f, "{}", cause),
GetUserError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
GetUserError::TooManyRequests(ref cause) => write!(f, "{}", cause),
GetUserError::UserNotConfirmed(ref cause) => write!(f, "{}", cause),
GetUserError::UserNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetUserError {}
#[derive(Debug, PartialEq)]
pub enum GetUserAttributeVerificationCodeError {
CodeDeliveryFailure(String),
InternalError(String),
InvalidEmailRoleAccessPolicy(String),
InvalidLambdaResponse(String),
InvalidParameter(String),
InvalidSmsRoleAccessPolicy(String),
InvalidSmsRoleTrustRelationship(String),
LimitExceeded(String),
NotAuthorized(String),
PasswordResetRequired(String),
ResourceNotFound(String),
TooManyRequests(String),
UnexpectedLambda(String),
UserLambdaValidation(String),
UserNotConfirmed(String),
UserNotFound(String),
}
impl GetUserAttributeVerificationCodeError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetUserAttributeVerificationCodeError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"CodeDeliveryFailureException" => {
return RusotoError::Service(
GetUserAttributeVerificationCodeError::CodeDeliveryFailure(err.msg),
)
}
"InternalErrorException" => {
return RusotoError::Service(
GetUserAttributeVerificationCodeError::InternalError(err.msg),
)
}
"InvalidEmailRoleAccessPolicyException" => {
return RusotoError::Service(
GetUserAttributeVerificationCodeError::InvalidEmailRoleAccessPolicy(
err.msg,
),
)
}
"InvalidLambdaResponseException" => {
return RusotoError::Service(
GetUserAttributeVerificationCodeError::InvalidLambdaResponse(err.msg),
)
}
"InvalidParameterException" => {
return RusotoError::Service(
GetUserAttributeVerificationCodeError::InvalidParameter(err.msg),
)
}
"InvalidSmsRoleAccessPolicyException" => {
return RusotoError::Service(
GetUserAttributeVerificationCodeError::InvalidSmsRoleAccessPolicy(err.msg),
)
}
"InvalidSmsRoleTrustRelationshipException" => {
return RusotoError::Service(
GetUserAttributeVerificationCodeError::InvalidSmsRoleTrustRelationship(
err.msg,
),
)
}
"LimitExceededException" => {
return RusotoError::Service(
GetUserAttributeVerificationCodeError::LimitExceeded(err.msg),
)
}
"NotAuthorizedException" => {
return RusotoError::Service(
GetUserAttributeVerificationCodeError::NotAuthorized(err.msg),
)
}
"PasswordResetRequiredException" => {
return RusotoError::Service(
GetUserAttributeVerificationCodeError::PasswordResetRequired(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
GetUserAttributeVerificationCodeError::ResourceNotFound(err.msg),
)
}
"TooManyRequestsException" => {
return RusotoError::Service(
GetUserAttributeVerificationCodeError::TooManyRequests(err.msg),
)
}
"UnexpectedLambdaException" => {
return RusotoError::Service(
GetUserAttributeVerificationCodeError::UnexpectedLambda(err.msg),
)
}
"UserLambdaValidationException" => {
return RusotoError::Service(
GetUserAttributeVerificationCodeError::UserLambdaValidation(err.msg),
)
}
"UserNotConfirmedException" => {
return RusotoError::Service(
GetUserAttributeVerificationCodeError::UserNotConfirmed(err.msg),
)
}
"UserNotFoundException" => {
return RusotoError::Service(
GetUserAttributeVerificationCodeError::UserNotFound(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetUserAttributeVerificationCodeError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetUserAttributeVerificationCodeError::CodeDeliveryFailure(ref cause) => {
write!(f, "{}", cause)
}
GetUserAttributeVerificationCodeError::InternalError(ref cause) => {
write!(f, "{}", cause)
}
GetUserAttributeVerificationCodeError::InvalidEmailRoleAccessPolicy(ref cause) => {
write!(f, "{}", cause)
}
GetUserAttributeVerificationCodeError::InvalidLambdaResponse(ref cause) => {
write!(f, "{}", cause)
}
GetUserAttributeVerificationCodeError::InvalidParameter(ref cause) => {
write!(f, "{}", cause)
}
GetUserAttributeVerificationCodeError::InvalidSmsRoleAccessPolicy(ref cause) => {
write!(f, "{}", cause)
}
GetUserAttributeVerificationCodeError::InvalidSmsRoleTrustRelationship(ref cause) => {
write!(f, "{}", cause)
}
GetUserAttributeVerificationCodeError::LimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
GetUserAttributeVerificationCodeError::NotAuthorized(ref cause) => {
write!(f, "{}", cause)
}
GetUserAttributeVerificationCodeError::PasswordResetRequired(ref cause) => {
write!(f, "{}", cause)
}
GetUserAttributeVerificationCodeError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
GetUserAttributeVerificationCodeError::TooManyRequests(ref cause) => {
write!(f, "{}", cause)
}
GetUserAttributeVerificationCodeError::UnexpectedLambda(ref cause) => {
write!(f, "{}", cause)
}
GetUserAttributeVerificationCodeError::UserLambdaValidation(ref cause) => {
write!(f, "{}", cause)
}
GetUserAttributeVerificationCodeError::UserNotConfirmed(ref cause) => {
write!(f, "{}", cause)
}
GetUserAttributeVerificationCodeError::UserNotFound(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for GetUserAttributeVerificationCodeError {}
#[derive(Debug, PartialEq)]
pub enum GetUserPoolMfaConfigError {
InternalError(String),
InvalidParameter(String),
NotAuthorized(String),
ResourceNotFound(String),
TooManyRequests(String),
}
impl GetUserPoolMfaConfigError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetUserPoolMfaConfigError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(GetUserPoolMfaConfigError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(GetUserPoolMfaConfigError::InvalidParameter(
err.msg,
))
}
"NotAuthorizedException" => {
return RusotoError::Service(GetUserPoolMfaConfigError::NotAuthorized(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(GetUserPoolMfaConfigError::ResourceNotFound(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(GetUserPoolMfaConfigError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetUserPoolMfaConfigError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetUserPoolMfaConfigError::InternalError(ref cause) => write!(f, "{}", cause),
GetUserPoolMfaConfigError::InvalidParameter(ref cause) => write!(f, "{}", cause),
GetUserPoolMfaConfigError::NotAuthorized(ref cause) => write!(f, "{}", cause),
GetUserPoolMfaConfigError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
GetUserPoolMfaConfigError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetUserPoolMfaConfigError {}
#[derive(Debug, PartialEq)]
pub enum GlobalSignOutError {
InternalError(String),
InvalidParameter(String),
NotAuthorized(String),
PasswordResetRequired(String),
ResourceNotFound(String),
TooManyRequests(String),
UserNotConfirmed(String),
}
impl GlobalSignOutError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GlobalSignOutError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(GlobalSignOutError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(GlobalSignOutError::InvalidParameter(err.msg))
}
"NotAuthorizedException" => {
return RusotoError::Service(GlobalSignOutError::NotAuthorized(err.msg))
}
"PasswordResetRequiredException" => {
return RusotoError::Service(GlobalSignOutError::PasswordResetRequired(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(GlobalSignOutError::ResourceNotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(GlobalSignOutError::TooManyRequests(err.msg))
}
"UserNotConfirmedException" => {
return RusotoError::Service(GlobalSignOutError::UserNotConfirmed(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GlobalSignOutError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GlobalSignOutError::InternalError(ref cause) => write!(f, "{}", cause),
GlobalSignOutError::InvalidParameter(ref cause) => write!(f, "{}", cause),
GlobalSignOutError::NotAuthorized(ref cause) => write!(f, "{}", cause),
GlobalSignOutError::PasswordResetRequired(ref cause) => write!(f, "{}", cause),
GlobalSignOutError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
GlobalSignOutError::TooManyRequests(ref cause) => write!(f, "{}", cause),
GlobalSignOutError::UserNotConfirmed(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GlobalSignOutError {}
#[derive(Debug, PartialEq)]
pub enum InitiateAuthError {
InternalError(String),
InvalidLambdaResponse(String),
InvalidParameter(String),
InvalidSmsRoleAccessPolicy(String),
InvalidSmsRoleTrustRelationship(String),
InvalidUserPoolConfiguration(String),
NotAuthorized(String),
PasswordResetRequired(String),
ResourceNotFound(String),
TooManyRequests(String),
UnexpectedLambda(String),
UserLambdaValidation(String),
UserNotConfirmed(String),
UserNotFound(String),
}
impl InitiateAuthError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<InitiateAuthError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(InitiateAuthError::InternalError(err.msg))
}
"InvalidLambdaResponseException" => {
return RusotoError::Service(InitiateAuthError::InvalidLambdaResponse(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(InitiateAuthError::InvalidParameter(err.msg))
}
"InvalidSmsRoleAccessPolicyException" => {
return RusotoError::Service(InitiateAuthError::InvalidSmsRoleAccessPolicy(
err.msg,
))
}
"InvalidSmsRoleTrustRelationshipException" => {
return RusotoError::Service(
InitiateAuthError::InvalidSmsRoleTrustRelationship(err.msg),
)
}
"InvalidUserPoolConfigurationException" => {
return RusotoError::Service(InitiateAuthError::InvalidUserPoolConfiguration(
err.msg,
))
}
"NotAuthorizedException" => {
return RusotoError::Service(InitiateAuthError::NotAuthorized(err.msg))
}
"PasswordResetRequiredException" => {
return RusotoError::Service(InitiateAuthError::PasswordResetRequired(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(InitiateAuthError::ResourceNotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(InitiateAuthError::TooManyRequests(err.msg))
}
"UnexpectedLambdaException" => {
return RusotoError::Service(InitiateAuthError::UnexpectedLambda(err.msg))
}
"UserLambdaValidationException" => {
return RusotoError::Service(InitiateAuthError::UserLambdaValidation(err.msg))
}
"UserNotConfirmedException" => {
return RusotoError::Service(InitiateAuthError::UserNotConfirmed(err.msg))
}
"UserNotFoundException" => {
return RusotoError::Service(InitiateAuthError::UserNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for InitiateAuthError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
InitiateAuthError::InternalError(ref cause) => write!(f, "{}", cause),
InitiateAuthError::InvalidLambdaResponse(ref cause) => write!(f, "{}", cause),
InitiateAuthError::InvalidParameter(ref cause) => write!(f, "{}", cause),
InitiateAuthError::InvalidSmsRoleAccessPolicy(ref cause) => write!(f, "{}", cause),
InitiateAuthError::InvalidSmsRoleTrustRelationship(ref cause) => write!(f, "{}", cause),
InitiateAuthError::InvalidUserPoolConfiguration(ref cause) => write!(f, "{}", cause),
InitiateAuthError::NotAuthorized(ref cause) => write!(f, "{}", cause),
InitiateAuthError::PasswordResetRequired(ref cause) => write!(f, "{}", cause),
InitiateAuthError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
InitiateAuthError::TooManyRequests(ref cause) => write!(f, "{}", cause),
InitiateAuthError::UnexpectedLambda(ref cause) => write!(f, "{}", cause),
InitiateAuthError::UserLambdaValidation(ref cause) => write!(f, "{}", cause),
InitiateAuthError::UserNotConfirmed(ref cause) => write!(f, "{}", cause),
InitiateAuthError::UserNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for InitiateAuthError {}
#[derive(Debug, PartialEq)]
pub enum ListDevicesError {
InternalError(String),
InvalidParameter(String),
InvalidUserPoolConfiguration(String),
NotAuthorized(String),
PasswordResetRequired(String),
ResourceNotFound(String),
TooManyRequests(String),
UserNotConfirmed(String),
UserNotFound(String),
}
impl ListDevicesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListDevicesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(ListDevicesError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(ListDevicesError::InvalidParameter(err.msg))
}
"InvalidUserPoolConfigurationException" => {
return RusotoError::Service(ListDevicesError::InvalidUserPoolConfiguration(
err.msg,
))
}
"NotAuthorizedException" => {
return RusotoError::Service(ListDevicesError::NotAuthorized(err.msg))
}
"PasswordResetRequiredException" => {
return RusotoError::Service(ListDevicesError::PasswordResetRequired(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListDevicesError::ResourceNotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(ListDevicesError::TooManyRequests(err.msg))
}
"UserNotConfirmedException" => {
return RusotoError::Service(ListDevicesError::UserNotConfirmed(err.msg))
}
"UserNotFoundException" => {
return RusotoError::Service(ListDevicesError::UserNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListDevicesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListDevicesError::InternalError(ref cause) => write!(f, "{}", cause),
ListDevicesError::InvalidParameter(ref cause) => write!(f, "{}", cause),
ListDevicesError::InvalidUserPoolConfiguration(ref cause) => write!(f, "{}", cause),
ListDevicesError::NotAuthorized(ref cause) => write!(f, "{}", cause),
ListDevicesError::PasswordResetRequired(ref cause) => write!(f, "{}", cause),
ListDevicesError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ListDevicesError::TooManyRequests(ref cause) => write!(f, "{}", cause),
ListDevicesError::UserNotConfirmed(ref cause) => write!(f, "{}", cause),
ListDevicesError::UserNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListDevicesError {}
#[derive(Debug, PartialEq)]
pub enum ListGroupsError {
InternalError(String),
InvalidParameter(String),
NotAuthorized(String),
ResourceNotFound(String),
TooManyRequests(String),
}
impl ListGroupsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListGroupsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(ListGroupsError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(ListGroupsError::InvalidParameter(err.msg))
}
"NotAuthorizedException" => {
return RusotoError::Service(ListGroupsError::NotAuthorized(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListGroupsError::ResourceNotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(ListGroupsError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListGroupsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListGroupsError::InternalError(ref cause) => write!(f, "{}", cause),
ListGroupsError::InvalidParameter(ref cause) => write!(f, "{}", cause),
ListGroupsError::NotAuthorized(ref cause) => write!(f, "{}", cause),
ListGroupsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ListGroupsError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListGroupsError {}
#[derive(Debug, PartialEq)]
pub enum ListIdentityProvidersError {
InternalError(String),
InvalidParameter(String),
NotAuthorized(String),
ResourceNotFound(String),
TooManyRequests(String),
}
impl ListIdentityProvidersError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListIdentityProvidersError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(ListIdentityProvidersError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(ListIdentityProvidersError::InvalidParameter(
err.msg,
))
}
"NotAuthorizedException" => {
return RusotoError::Service(ListIdentityProvidersError::NotAuthorized(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListIdentityProvidersError::ResourceNotFound(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(ListIdentityProvidersError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListIdentityProvidersError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListIdentityProvidersError::InternalError(ref cause) => write!(f, "{}", cause),
ListIdentityProvidersError::InvalidParameter(ref cause) => write!(f, "{}", cause),
ListIdentityProvidersError::NotAuthorized(ref cause) => write!(f, "{}", cause),
ListIdentityProvidersError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ListIdentityProvidersError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListIdentityProvidersError {}
#[derive(Debug, PartialEq)]
pub enum ListResourceServersError {
InternalError(String),
InvalidParameter(String),
NotAuthorized(String),
ResourceNotFound(String),
TooManyRequests(String),
}
impl ListResourceServersError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListResourceServersError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(ListResourceServersError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(ListResourceServersError::InvalidParameter(
err.msg,
))
}
"NotAuthorizedException" => {
return RusotoError::Service(ListResourceServersError::NotAuthorized(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListResourceServersError::ResourceNotFound(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(ListResourceServersError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListResourceServersError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListResourceServersError::InternalError(ref cause) => write!(f, "{}", cause),
ListResourceServersError::InvalidParameter(ref cause) => write!(f, "{}", cause),
ListResourceServersError::NotAuthorized(ref cause) => write!(f, "{}", cause),
ListResourceServersError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ListResourceServersError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListResourceServersError {}
#[derive(Debug, PartialEq)]
pub enum ListTagsForResourceError {
InternalError(String),
InvalidParameter(String),
NotAuthorized(String),
ResourceNotFound(String),
TooManyRequests(String),
}
impl ListTagsForResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListTagsForResourceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(ListTagsForResourceError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(ListTagsForResourceError::InvalidParameter(
err.msg,
))
}
"NotAuthorizedException" => {
return RusotoError::Service(ListTagsForResourceError::NotAuthorized(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListTagsForResourceError::ResourceNotFound(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(ListTagsForResourceError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListTagsForResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListTagsForResourceError::InternalError(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::InvalidParameter(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::NotAuthorized(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListTagsForResourceError {}
#[derive(Debug, PartialEq)]
pub enum ListUserImportJobsError {
InternalError(String),
InvalidParameter(String),
NotAuthorized(String),
ResourceNotFound(String),
TooManyRequests(String),
}
impl ListUserImportJobsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListUserImportJobsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(ListUserImportJobsError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(ListUserImportJobsError::InvalidParameter(err.msg))
}
"NotAuthorizedException" => {
return RusotoError::Service(ListUserImportJobsError::NotAuthorized(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListUserImportJobsError::ResourceNotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(ListUserImportJobsError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListUserImportJobsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListUserImportJobsError::InternalError(ref cause) => write!(f, "{}", cause),
ListUserImportJobsError::InvalidParameter(ref cause) => write!(f, "{}", cause),
ListUserImportJobsError::NotAuthorized(ref cause) => write!(f, "{}", cause),
ListUserImportJobsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ListUserImportJobsError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListUserImportJobsError {}
#[derive(Debug, PartialEq)]
pub enum ListUserPoolClientsError {
InternalError(String),
InvalidParameter(String),
NotAuthorized(String),
ResourceNotFound(String),
TooManyRequests(String),
}
impl ListUserPoolClientsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListUserPoolClientsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(ListUserPoolClientsError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(ListUserPoolClientsError::InvalidParameter(
err.msg,
))
}
"NotAuthorizedException" => {
return RusotoError::Service(ListUserPoolClientsError::NotAuthorized(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListUserPoolClientsError::ResourceNotFound(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(ListUserPoolClientsError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListUserPoolClientsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListUserPoolClientsError::InternalError(ref cause) => write!(f, "{}", cause),
ListUserPoolClientsError::InvalidParameter(ref cause) => write!(f, "{}", cause),
ListUserPoolClientsError::NotAuthorized(ref cause) => write!(f, "{}", cause),
ListUserPoolClientsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ListUserPoolClientsError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListUserPoolClientsError {}
#[derive(Debug, PartialEq)]
pub enum ListUserPoolsError {
InternalError(String),
InvalidParameter(String),
NotAuthorized(String),
TooManyRequests(String),
}
impl ListUserPoolsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListUserPoolsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(ListUserPoolsError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(ListUserPoolsError::InvalidParameter(err.msg))
}
"NotAuthorizedException" => {
return RusotoError::Service(ListUserPoolsError::NotAuthorized(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(ListUserPoolsError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListUserPoolsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListUserPoolsError::InternalError(ref cause) => write!(f, "{}", cause),
ListUserPoolsError::InvalidParameter(ref cause) => write!(f, "{}", cause),
ListUserPoolsError::NotAuthorized(ref cause) => write!(f, "{}", cause),
ListUserPoolsError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListUserPoolsError {}
#[derive(Debug, PartialEq)]
pub enum ListUsersError {
InternalError(String),
InvalidParameter(String),
NotAuthorized(String),
ResourceNotFound(String),
TooManyRequests(String),
}
impl ListUsersError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListUsersError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(ListUsersError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(ListUsersError::InvalidParameter(err.msg))
}
"NotAuthorizedException" => {
return RusotoError::Service(ListUsersError::NotAuthorized(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListUsersError::ResourceNotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(ListUsersError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListUsersError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListUsersError::InternalError(ref cause) => write!(f, "{}", cause),
ListUsersError::InvalidParameter(ref cause) => write!(f, "{}", cause),
ListUsersError::NotAuthorized(ref cause) => write!(f, "{}", cause),
ListUsersError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ListUsersError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListUsersError {}
#[derive(Debug, PartialEq)]
pub enum ListUsersInGroupError {
InternalError(String),
InvalidParameter(String),
NotAuthorized(String),
ResourceNotFound(String),
TooManyRequests(String),
}
impl ListUsersInGroupError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListUsersInGroupError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(ListUsersInGroupError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(ListUsersInGroupError::InvalidParameter(err.msg))
}
"NotAuthorizedException" => {
return RusotoError::Service(ListUsersInGroupError::NotAuthorized(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListUsersInGroupError::ResourceNotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(ListUsersInGroupError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListUsersInGroupError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListUsersInGroupError::InternalError(ref cause) => write!(f, "{}", cause),
ListUsersInGroupError::InvalidParameter(ref cause) => write!(f, "{}", cause),
ListUsersInGroupError::NotAuthorized(ref cause) => write!(f, "{}", cause),
ListUsersInGroupError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ListUsersInGroupError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListUsersInGroupError {}
#[derive(Debug, PartialEq)]
pub enum ResendConfirmationCodeError {
CodeDeliveryFailure(String),
InternalError(String),
InvalidEmailRoleAccessPolicy(String),
InvalidLambdaResponse(String),
InvalidParameter(String),
InvalidSmsRoleAccessPolicy(String),
InvalidSmsRoleTrustRelationship(String),
LimitExceeded(String),
NotAuthorized(String),
ResourceNotFound(String),
TooManyRequests(String),
UnexpectedLambda(String),
UserLambdaValidation(String),
UserNotFound(String),
}
impl ResendConfirmationCodeError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ResendConfirmationCodeError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"CodeDeliveryFailureException" => {
return RusotoError::Service(ResendConfirmationCodeError::CodeDeliveryFailure(
err.msg,
))
}
"InternalErrorException" => {
return RusotoError::Service(ResendConfirmationCodeError::InternalError(
err.msg,
))
}
"InvalidEmailRoleAccessPolicyException" => {
return RusotoError::Service(
ResendConfirmationCodeError::InvalidEmailRoleAccessPolicy(err.msg),
)
}
"InvalidLambdaResponseException" => {
return RusotoError::Service(
ResendConfirmationCodeError::InvalidLambdaResponse(err.msg),
)
}
"InvalidParameterException" => {
return RusotoError::Service(ResendConfirmationCodeError::InvalidParameter(
err.msg,
))
}
"InvalidSmsRoleAccessPolicyException" => {
return RusotoError::Service(
ResendConfirmationCodeError::InvalidSmsRoleAccessPolicy(err.msg),
)
}
"InvalidSmsRoleTrustRelationshipException" => {
return RusotoError::Service(
ResendConfirmationCodeError::InvalidSmsRoleTrustRelationship(err.msg),
)
}
"LimitExceededException" => {
return RusotoError::Service(ResendConfirmationCodeError::LimitExceeded(
err.msg,
))
}
"NotAuthorizedException" => {
return RusotoError::Service(ResendConfirmationCodeError::NotAuthorized(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ResendConfirmationCodeError::ResourceNotFound(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(ResendConfirmationCodeError::TooManyRequests(
err.msg,
))
}
"UnexpectedLambdaException" => {
return RusotoError::Service(ResendConfirmationCodeError::UnexpectedLambda(
err.msg,
))
}
"UserLambdaValidationException" => {
return RusotoError::Service(ResendConfirmationCodeError::UserLambdaValidation(
err.msg,
))
}
"UserNotFoundException" => {
return RusotoError::Service(ResendConfirmationCodeError::UserNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ResendConfirmationCodeError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ResendConfirmationCodeError::CodeDeliveryFailure(ref cause) => write!(f, "{}", cause),
ResendConfirmationCodeError::InternalError(ref cause) => write!(f, "{}", cause),
ResendConfirmationCodeError::InvalidEmailRoleAccessPolicy(ref cause) => {
write!(f, "{}", cause)
}
ResendConfirmationCodeError::InvalidLambdaResponse(ref cause) => write!(f, "{}", cause),
ResendConfirmationCodeError::InvalidParameter(ref cause) => write!(f, "{}", cause),
ResendConfirmationCodeError::InvalidSmsRoleAccessPolicy(ref cause) => {
write!(f, "{}", cause)
}
ResendConfirmationCodeError::InvalidSmsRoleTrustRelationship(ref cause) => {
write!(f, "{}", cause)
}
ResendConfirmationCodeError::LimitExceeded(ref cause) => write!(f, "{}", cause),
ResendConfirmationCodeError::NotAuthorized(ref cause) => write!(f, "{}", cause),
ResendConfirmationCodeError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ResendConfirmationCodeError::TooManyRequests(ref cause) => write!(f, "{}", cause),
ResendConfirmationCodeError::UnexpectedLambda(ref cause) => write!(f, "{}", cause),
ResendConfirmationCodeError::UserLambdaValidation(ref cause) => write!(f, "{}", cause),
ResendConfirmationCodeError::UserNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ResendConfirmationCodeError {}
#[derive(Debug, PartialEq)]
pub enum RespondToAuthChallengeError {
AliasExists(String),
CodeMismatch(String),
ExpiredCode(String),
InternalError(String),
InvalidLambdaResponse(String),
InvalidParameter(String),
InvalidPassword(String),
InvalidSmsRoleAccessPolicy(String),
InvalidSmsRoleTrustRelationship(String),
InvalidUserPoolConfiguration(String),
MFAMethodNotFound(String),
NotAuthorized(String),
PasswordResetRequired(String),
ResourceNotFound(String),
SoftwareTokenMFANotFound(String),
TooManyRequests(String),
UnexpectedLambda(String),
UserLambdaValidation(String),
UserNotConfirmed(String),
UserNotFound(String),
}
impl RespondToAuthChallengeError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<RespondToAuthChallengeError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AliasExistsException" => {
return RusotoError::Service(RespondToAuthChallengeError::AliasExists(err.msg))
}
"CodeMismatchException" => {
return RusotoError::Service(RespondToAuthChallengeError::CodeMismatch(err.msg))
}
"ExpiredCodeException" => {
return RusotoError::Service(RespondToAuthChallengeError::ExpiredCode(err.msg))
}
"InternalErrorException" => {
return RusotoError::Service(RespondToAuthChallengeError::InternalError(
err.msg,
))
}
"InvalidLambdaResponseException" => {
return RusotoError::Service(
RespondToAuthChallengeError::InvalidLambdaResponse(err.msg),
)
}
"InvalidParameterException" => {
return RusotoError::Service(RespondToAuthChallengeError::InvalidParameter(
err.msg,
))
}
"InvalidPasswordException" => {
return RusotoError::Service(RespondToAuthChallengeError::InvalidPassword(
err.msg,
))
}
"InvalidSmsRoleAccessPolicyException" => {
return RusotoError::Service(
RespondToAuthChallengeError::InvalidSmsRoleAccessPolicy(err.msg),
)
}
"InvalidSmsRoleTrustRelationshipException" => {
return RusotoError::Service(
RespondToAuthChallengeError::InvalidSmsRoleTrustRelationship(err.msg),
)
}
"InvalidUserPoolConfigurationException" => {
return RusotoError::Service(
RespondToAuthChallengeError::InvalidUserPoolConfiguration(err.msg),
)
}
"MFAMethodNotFoundException" => {
return RusotoError::Service(RespondToAuthChallengeError::MFAMethodNotFound(
err.msg,
))
}
"NotAuthorizedException" => {
return RusotoError::Service(RespondToAuthChallengeError::NotAuthorized(
err.msg,
))
}
"PasswordResetRequiredException" => {
return RusotoError::Service(
RespondToAuthChallengeError::PasswordResetRequired(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(RespondToAuthChallengeError::ResourceNotFound(
err.msg,
))
}
"SoftwareTokenMFANotFoundException" => {
return RusotoError::Service(
RespondToAuthChallengeError::SoftwareTokenMFANotFound(err.msg),
)
}
"TooManyRequestsException" => {
return RusotoError::Service(RespondToAuthChallengeError::TooManyRequests(
err.msg,
))
}
"UnexpectedLambdaException" => {
return RusotoError::Service(RespondToAuthChallengeError::UnexpectedLambda(
err.msg,
))
}
"UserLambdaValidationException" => {
return RusotoError::Service(RespondToAuthChallengeError::UserLambdaValidation(
err.msg,
))
}
"UserNotConfirmedException" => {
return RusotoError::Service(RespondToAuthChallengeError::UserNotConfirmed(
err.msg,
))
}
"UserNotFoundException" => {
return RusotoError::Service(RespondToAuthChallengeError::UserNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for RespondToAuthChallengeError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
RespondToAuthChallengeError::AliasExists(ref cause) => write!(f, "{}", cause),
RespondToAuthChallengeError::CodeMismatch(ref cause) => write!(f, "{}", cause),
RespondToAuthChallengeError::ExpiredCode(ref cause) => write!(f, "{}", cause),
RespondToAuthChallengeError::InternalError(ref cause) => write!(f, "{}", cause),
RespondToAuthChallengeError::InvalidLambdaResponse(ref cause) => write!(f, "{}", cause),
RespondToAuthChallengeError::InvalidParameter(ref cause) => write!(f, "{}", cause),
RespondToAuthChallengeError::InvalidPassword(ref cause) => write!(f, "{}", cause),
RespondToAuthChallengeError::InvalidSmsRoleAccessPolicy(ref cause) => {
write!(f, "{}", cause)
}
RespondToAuthChallengeError::InvalidSmsRoleTrustRelationship(ref cause) => {
write!(f, "{}", cause)
}
RespondToAuthChallengeError::InvalidUserPoolConfiguration(ref cause) => {
write!(f, "{}", cause)
}
RespondToAuthChallengeError::MFAMethodNotFound(ref cause) => write!(f, "{}", cause),
RespondToAuthChallengeError::NotAuthorized(ref cause) => write!(f, "{}", cause),
RespondToAuthChallengeError::PasswordResetRequired(ref cause) => write!(f, "{}", cause),
RespondToAuthChallengeError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
RespondToAuthChallengeError::SoftwareTokenMFANotFound(ref cause) => {
write!(f, "{}", cause)
}
RespondToAuthChallengeError::TooManyRequests(ref cause) => write!(f, "{}", cause),
RespondToAuthChallengeError::UnexpectedLambda(ref cause) => write!(f, "{}", cause),
RespondToAuthChallengeError::UserLambdaValidation(ref cause) => write!(f, "{}", cause),
RespondToAuthChallengeError::UserNotConfirmed(ref cause) => write!(f, "{}", cause),
RespondToAuthChallengeError::UserNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for RespondToAuthChallengeError {}
#[derive(Debug, PartialEq)]
pub enum SetRiskConfigurationError {
CodeDeliveryFailure(String),
InternalError(String),
InvalidEmailRoleAccessPolicy(String),
InvalidParameter(String),
NotAuthorized(String),
ResourceNotFound(String),
TooManyRequests(String),
UserPoolAddOnNotEnabled(String),
}
impl SetRiskConfigurationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<SetRiskConfigurationError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"CodeDeliveryFailureException" => {
return RusotoError::Service(SetRiskConfigurationError::CodeDeliveryFailure(
err.msg,
))
}
"InternalErrorException" => {
return RusotoError::Service(SetRiskConfigurationError::InternalError(err.msg))
}
"InvalidEmailRoleAccessPolicyException" => {
return RusotoError::Service(
SetRiskConfigurationError::InvalidEmailRoleAccessPolicy(err.msg),
)
}
"InvalidParameterException" => {
return RusotoError::Service(SetRiskConfigurationError::InvalidParameter(
err.msg,
))
}
"NotAuthorizedException" => {
return RusotoError::Service(SetRiskConfigurationError::NotAuthorized(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(SetRiskConfigurationError::ResourceNotFound(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(SetRiskConfigurationError::TooManyRequests(
err.msg,
))
}
"UserPoolAddOnNotEnabledException" => {
return RusotoError::Service(
SetRiskConfigurationError::UserPoolAddOnNotEnabled(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for SetRiskConfigurationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
SetRiskConfigurationError::CodeDeliveryFailure(ref cause) => write!(f, "{}", cause),
SetRiskConfigurationError::InternalError(ref cause) => write!(f, "{}", cause),
SetRiskConfigurationError::InvalidEmailRoleAccessPolicy(ref cause) => {
write!(f, "{}", cause)
}
SetRiskConfigurationError::InvalidParameter(ref cause) => write!(f, "{}", cause),
SetRiskConfigurationError::NotAuthorized(ref cause) => write!(f, "{}", cause),
SetRiskConfigurationError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
SetRiskConfigurationError::TooManyRequests(ref cause) => write!(f, "{}", cause),
SetRiskConfigurationError::UserPoolAddOnNotEnabled(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for SetRiskConfigurationError {}
#[derive(Debug, PartialEq)]
pub enum SetUICustomizationError {
InternalError(String),
InvalidParameter(String),
NotAuthorized(String),
ResourceNotFound(String),
TooManyRequests(String),
}
impl SetUICustomizationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<SetUICustomizationError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(SetUICustomizationError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(SetUICustomizationError::InvalidParameter(err.msg))
}
"NotAuthorizedException" => {
return RusotoError::Service(SetUICustomizationError::NotAuthorized(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(SetUICustomizationError::ResourceNotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(SetUICustomizationError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for SetUICustomizationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
SetUICustomizationError::InternalError(ref cause) => write!(f, "{}", cause),
SetUICustomizationError::InvalidParameter(ref cause) => write!(f, "{}", cause),
SetUICustomizationError::NotAuthorized(ref cause) => write!(f, "{}", cause),
SetUICustomizationError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
SetUICustomizationError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for SetUICustomizationError {}
#[derive(Debug, PartialEq)]
pub enum SetUserMFAPreferenceError {
InternalError(String),
InvalidParameter(String),
NotAuthorized(String),
PasswordResetRequired(String),
ResourceNotFound(String),
UserNotConfirmed(String),
UserNotFound(String),
}
impl SetUserMFAPreferenceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<SetUserMFAPreferenceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(SetUserMFAPreferenceError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(SetUserMFAPreferenceError::InvalidParameter(
err.msg,
))
}
"NotAuthorizedException" => {
return RusotoError::Service(SetUserMFAPreferenceError::NotAuthorized(err.msg))
}
"PasswordResetRequiredException" => {
return RusotoError::Service(SetUserMFAPreferenceError::PasswordResetRequired(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(SetUserMFAPreferenceError::ResourceNotFound(
err.msg,
))
}
"UserNotConfirmedException" => {
return RusotoError::Service(SetUserMFAPreferenceError::UserNotConfirmed(
err.msg,
))
}
"UserNotFoundException" => {
return RusotoError::Service(SetUserMFAPreferenceError::UserNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for SetUserMFAPreferenceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
SetUserMFAPreferenceError::InternalError(ref cause) => write!(f, "{}", cause),
SetUserMFAPreferenceError::InvalidParameter(ref cause) => write!(f, "{}", cause),
SetUserMFAPreferenceError::NotAuthorized(ref cause) => write!(f, "{}", cause),
SetUserMFAPreferenceError::PasswordResetRequired(ref cause) => write!(f, "{}", cause),
SetUserMFAPreferenceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
SetUserMFAPreferenceError::UserNotConfirmed(ref cause) => write!(f, "{}", cause),
SetUserMFAPreferenceError::UserNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for SetUserMFAPreferenceError {}
#[derive(Debug, PartialEq)]
pub enum SetUserPoolMfaConfigError {
InternalError(String),
InvalidParameter(String),
InvalidSmsRoleAccessPolicy(String),
InvalidSmsRoleTrustRelationship(String),
NotAuthorized(String),
ResourceNotFound(String),
TooManyRequests(String),
}
impl SetUserPoolMfaConfigError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<SetUserPoolMfaConfigError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(SetUserPoolMfaConfigError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(SetUserPoolMfaConfigError::InvalidParameter(
err.msg,
))
}
"InvalidSmsRoleAccessPolicyException" => {
return RusotoError::Service(
SetUserPoolMfaConfigError::InvalidSmsRoleAccessPolicy(err.msg),
)
}
"InvalidSmsRoleTrustRelationshipException" => {
return RusotoError::Service(
SetUserPoolMfaConfigError::InvalidSmsRoleTrustRelationship(err.msg),
)
}
"NotAuthorizedException" => {
return RusotoError::Service(SetUserPoolMfaConfigError::NotAuthorized(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(SetUserPoolMfaConfigError::ResourceNotFound(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(SetUserPoolMfaConfigError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for SetUserPoolMfaConfigError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
SetUserPoolMfaConfigError::InternalError(ref cause) => write!(f, "{}", cause),
SetUserPoolMfaConfigError::InvalidParameter(ref cause) => write!(f, "{}", cause),
SetUserPoolMfaConfigError::InvalidSmsRoleAccessPolicy(ref cause) => {
write!(f, "{}", cause)
}
SetUserPoolMfaConfigError::InvalidSmsRoleTrustRelationship(ref cause) => {
write!(f, "{}", cause)
}
SetUserPoolMfaConfigError::NotAuthorized(ref cause) => write!(f, "{}", cause),
SetUserPoolMfaConfigError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
SetUserPoolMfaConfigError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for SetUserPoolMfaConfigError {}
#[derive(Debug, PartialEq)]
pub enum SetUserSettingsError {
InternalError(String),
InvalidParameter(String),
NotAuthorized(String),
PasswordResetRequired(String),
ResourceNotFound(String),
UserNotConfirmed(String),
UserNotFound(String),
}
impl SetUserSettingsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<SetUserSettingsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(SetUserSettingsError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(SetUserSettingsError::InvalidParameter(err.msg))
}
"NotAuthorizedException" => {
return RusotoError::Service(SetUserSettingsError::NotAuthorized(err.msg))
}
"PasswordResetRequiredException" => {
return RusotoError::Service(SetUserSettingsError::PasswordResetRequired(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(SetUserSettingsError::ResourceNotFound(err.msg))
}
"UserNotConfirmedException" => {
return RusotoError::Service(SetUserSettingsError::UserNotConfirmed(err.msg))
}
"UserNotFoundException" => {
return RusotoError::Service(SetUserSettingsError::UserNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for SetUserSettingsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
SetUserSettingsError::InternalError(ref cause) => write!(f, "{}", cause),
SetUserSettingsError::InvalidParameter(ref cause) => write!(f, "{}", cause),
SetUserSettingsError::NotAuthorized(ref cause) => write!(f, "{}", cause),
SetUserSettingsError::PasswordResetRequired(ref cause) => write!(f, "{}", cause),
SetUserSettingsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
SetUserSettingsError::UserNotConfirmed(ref cause) => write!(f, "{}", cause),
SetUserSettingsError::UserNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for SetUserSettingsError {}
#[derive(Debug, PartialEq)]
pub enum SignUpError {
CodeDeliveryFailure(String),
InternalError(String),
InvalidEmailRoleAccessPolicy(String),
InvalidLambdaResponse(String),
InvalidParameter(String),
InvalidPassword(String),
InvalidSmsRoleAccessPolicy(String),
InvalidSmsRoleTrustRelationship(String),
NotAuthorized(String),
ResourceNotFound(String),
TooManyRequests(String),
UnexpectedLambda(String),
UserLambdaValidation(String),
UsernameExists(String),
}
impl SignUpError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<SignUpError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"CodeDeliveryFailureException" => {
return RusotoError::Service(SignUpError::CodeDeliveryFailure(err.msg))
}
"InternalErrorException" => {
return RusotoError::Service(SignUpError::InternalError(err.msg))
}
"InvalidEmailRoleAccessPolicyException" => {
return RusotoError::Service(SignUpError::InvalidEmailRoleAccessPolicy(err.msg))
}
"InvalidLambdaResponseException" => {
return RusotoError::Service(SignUpError::InvalidLambdaResponse(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(SignUpError::InvalidParameter(err.msg))
}
"InvalidPasswordException" => {
return RusotoError::Service(SignUpError::InvalidPassword(err.msg))
}
"InvalidSmsRoleAccessPolicyException" => {
return RusotoError::Service(SignUpError::InvalidSmsRoleAccessPolicy(err.msg))
}
"InvalidSmsRoleTrustRelationshipException" => {
return RusotoError::Service(SignUpError::InvalidSmsRoleTrustRelationship(
err.msg,
))
}
"NotAuthorizedException" => {
return RusotoError::Service(SignUpError::NotAuthorized(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(SignUpError::ResourceNotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(SignUpError::TooManyRequests(err.msg))
}
"UnexpectedLambdaException" => {
return RusotoError::Service(SignUpError::UnexpectedLambda(err.msg))
}
"UserLambdaValidationException" => {
return RusotoError::Service(SignUpError::UserLambdaValidation(err.msg))
}
"UsernameExistsException" => {
return RusotoError::Service(SignUpError::UsernameExists(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for SignUpError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
SignUpError::CodeDeliveryFailure(ref cause) => write!(f, "{}", cause),
SignUpError::InternalError(ref cause) => write!(f, "{}", cause),
SignUpError::InvalidEmailRoleAccessPolicy(ref cause) => write!(f, "{}", cause),
SignUpError::InvalidLambdaResponse(ref cause) => write!(f, "{}", cause),
SignUpError::InvalidParameter(ref cause) => write!(f, "{}", cause),
SignUpError::InvalidPassword(ref cause) => write!(f, "{}", cause),
SignUpError::InvalidSmsRoleAccessPolicy(ref cause) => write!(f, "{}", cause),
SignUpError::InvalidSmsRoleTrustRelationship(ref cause) => write!(f, "{}", cause),
SignUpError::NotAuthorized(ref cause) => write!(f, "{}", cause),
SignUpError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
SignUpError::TooManyRequests(ref cause) => write!(f, "{}", cause),
SignUpError::UnexpectedLambda(ref cause) => write!(f, "{}", cause),
SignUpError::UserLambdaValidation(ref cause) => write!(f, "{}", cause),
SignUpError::UsernameExists(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for SignUpError {}
#[derive(Debug, PartialEq)]
pub enum StartUserImportJobError {
InternalError(String),
InvalidParameter(String),
NotAuthorized(String),
PreconditionNotMet(String),
ResourceNotFound(String),
TooManyRequests(String),
}
impl StartUserImportJobError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StartUserImportJobError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(StartUserImportJobError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(StartUserImportJobError::InvalidParameter(err.msg))
}
"NotAuthorizedException" => {
return RusotoError::Service(StartUserImportJobError::NotAuthorized(err.msg))
}
"PreconditionNotMetException" => {
return RusotoError::Service(StartUserImportJobError::PreconditionNotMet(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(StartUserImportJobError::ResourceNotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(StartUserImportJobError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for StartUserImportJobError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
StartUserImportJobError::InternalError(ref cause) => write!(f, "{}", cause),
StartUserImportJobError::InvalidParameter(ref cause) => write!(f, "{}", cause),
StartUserImportJobError::NotAuthorized(ref cause) => write!(f, "{}", cause),
StartUserImportJobError::PreconditionNotMet(ref cause) => write!(f, "{}", cause),
StartUserImportJobError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
StartUserImportJobError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for StartUserImportJobError {}
#[derive(Debug, PartialEq)]
pub enum StopUserImportJobError {
InternalError(String),
InvalidParameter(String),
NotAuthorized(String),
PreconditionNotMet(String),
ResourceNotFound(String),
TooManyRequests(String),
}
impl StopUserImportJobError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StopUserImportJobError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(StopUserImportJobError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(StopUserImportJobError::InvalidParameter(err.msg))
}
"NotAuthorizedException" => {
return RusotoError::Service(StopUserImportJobError::NotAuthorized(err.msg))
}
"PreconditionNotMetException" => {
return RusotoError::Service(StopUserImportJobError::PreconditionNotMet(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(StopUserImportJobError::ResourceNotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(StopUserImportJobError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for StopUserImportJobError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
StopUserImportJobError::InternalError(ref cause) => write!(f, "{}", cause),
StopUserImportJobError::InvalidParameter(ref cause) => write!(f, "{}", cause),
StopUserImportJobError::NotAuthorized(ref cause) => write!(f, "{}", cause),
StopUserImportJobError::PreconditionNotMet(ref cause) => write!(f, "{}", cause),
StopUserImportJobError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
StopUserImportJobError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for StopUserImportJobError {}
#[derive(Debug, PartialEq)]
pub enum TagResourceError {
InternalError(String),
InvalidParameter(String),
NotAuthorized(String),
ResourceNotFound(String),
TooManyRequests(String),
}
impl TagResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<TagResourceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(TagResourceError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(TagResourceError::InvalidParameter(err.msg))
}
"NotAuthorizedException" => {
return RusotoError::Service(TagResourceError::NotAuthorized(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(TagResourceError::ResourceNotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(TagResourceError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for TagResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
TagResourceError::InternalError(ref cause) => write!(f, "{}", cause),
TagResourceError::InvalidParameter(ref cause) => write!(f, "{}", cause),
TagResourceError::NotAuthorized(ref cause) => write!(f, "{}", cause),
TagResourceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
TagResourceError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for TagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UntagResourceError {
InternalError(String),
InvalidParameter(String),
NotAuthorized(String),
ResourceNotFound(String),
TooManyRequests(String),
}
impl UntagResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UntagResourceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(UntagResourceError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(UntagResourceError::InvalidParameter(err.msg))
}
"NotAuthorizedException" => {
return RusotoError::Service(UntagResourceError::NotAuthorized(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UntagResourceError::ResourceNotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(UntagResourceError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UntagResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UntagResourceError::InternalError(ref cause) => write!(f, "{}", cause),
UntagResourceError::InvalidParameter(ref cause) => write!(f, "{}", cause),
UntagResourceError::NotAuthorized(ref cause) => write!(f, "{}", cause),
UntagResourceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
UntagResourceError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UntagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UpdateAuthEventFeedbackError {
InternalError(String),
InvalidParameter(String),
NotAuthorized(String),
ResourceNotFound(String),
TooManyRequests(String),
UserNotFound(String),
UserPoolAddOnNotEnabled(String),
}
impl UpdateAuthEventFeedbackError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateAuthEventFeedbackError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(UpdateAuthEventFeedbackError::InternalError(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(UpdateAuthEventFeedbackError::InvalidParameter(
err.msg,
))
}
"NotAuthorizedException" => {
return RusotoError::Service(UpdateAuthEventFeedbackError::NotAuthorized(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UpdateAuthEventFeedbackError::ResourceNotFound(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(UpdateAuthEventFeedbackError::TooManyRequests(
err.msg,
))
}
"UserNotFoundException" => {
return RusotoError::Service(UpdateAuthEventFeedbackError::UserNotFound(
err.msg,
))
}
"UserPoolAddOnNotEnabledException" => {
return RusotoError::Service(
UpdateAuthEventFeedbackError::UserPoolAddOnNotEnabled(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateAuthEventFeedbackError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateAuthEventFeedbackError::InternalError(ref cause) => write!(f, "{}", cause),
UpdateAuthEventFeedbackError::InvalidParameter(ref cause) => write!(f, "{}", cause),
UpdateAuthEventFeedbackError::NotAuthorized(ref cause) => write!(f, "{}", cause),
UpdateAuthEventFeedbackError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
UpdateAuthEventFeedbackError::TooManyRequests(ref cause) => write!(f, "{}", cause),
UpdateAuthEventFeedbackError::UserNotFound(ref cause) => write!(f, "{}", cause),
UpdateAuthEventFeedbackError::UserPoolAddOnNotEnabled(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for UpdateAuthEventFeedbackError {}
#[derive(Debug, PartialEq)]
pub enum UpdateDeviceStatusError {
InternalError(String),
InvalidParameter(String),
InvalidUserPoolConfiguration(String),
NotAuthorized(String),
PasswordResetRequired(String),
ResourceNotFound(String),
TooManyRequests(String),
UserNotConfirmed(String),
UserNotFound(String),
}
impl UpdateDeviceStatusError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateDeviceStatusError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(UpdateDeviceStatusError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(UpdateDeviceStatusError::InvalidParameter(err.msg))
}
"InvalidUserPoolConfigurationException" => {
return RusotoError::Service(
UpdateDeviceStatusError::InvalidUserPoolConfiguration(err.msg),
)
}
"NotAuthorizedException" => {
return RusotoError::Service(UpdateDeviceStatusError::NotAuthorized(err.msg))
}
"PasswordResetRequiredException" => {
return RusotoError::Service(UpdateDeviceStatusError::PasswordResetRequired(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UpdateDeviceStatusError::ResourceNotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(UpdateDeviceStatusError::TooManyRequests(err.msg))
}
"UserNotConfirmedException" => {
return RusotoError::Service(UpdateDeviceStatusError::UserNotConfirmed(err.msg))
}
"UserNotFoundException" => {
return RusotoError::Service(UpdateDeviceStatusError::UserNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateDeviceStatusError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateDeviceStatusError::InternalError(ref cause) => write!(f, "{}", cause),
UpdateDeviceStatusError::InvalidParameter(ref cause) => write!(f, "{}", cause),
UpdateDeviceStatusError::InvalidUserPoolConfiguration(ref cause) => {
write!(f, "{}", cause)
}
UpdateDeviceStatusError::NotAuthorized(ref cause) => write!(f, "{}", cause),
UpdateDeviceStatusError::PasswordResetRequired(ref cause) => write!(f, "{}", cause),
UpdateDeviceStatusError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
UpdateDeviceStatusError::TooManyRequests(ref cause) => write!(f, "{}", cause),
UpdateDeviceStatusError::UserNotConfirmed(ref cause) => write!(f, "{}", cause),
UpdateDeviceStatusError::UserNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateDeviceStatusError {}
#[derive(Debug, PartialEq)]
pub enum UpdateGroupError {
InternalError(String),
InvalidParameter(String),
NotAuthorized(String),
ResourceNotFound(String),
TooManyRequests(String),
}
impl UpdateGroupError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateGroupError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(UpdateGroupError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(UpdateGroupError::InvalidParameter(err.msg))
}
"NotAuthorizedException" => {
return RusotoError::Service(UpdateGroupError::NotAuthorized(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UpdateGroupError::ResourceNotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(UpdateGroupError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateGroupError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateGroupError::InternalError(ref cause) => write!(f, "{}", cause),
UpdateGroupError::InvalidParameter(ref cause) => write!(f, "{}", cause),
UpdateGroupError::NotAuthorized(ref cause) => write!(f, "{}", cause),
UpdateGroupError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
UpdateGroupError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateGroupError {}
#[derive(Debug, PartialEq)]
pub enum UpdateIdentityProviderError {
InternalError(String),
InvalidParameter(String),
NotAuthorized(String),
ResourceNotFound(String),
TooManyRequests(String),
UnsupportedIdentityProvider(String),
}
impl UpdateIdentityProviderError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateIdentityProviderError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(UpdateIdentityProviderError::InternalError(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(UpdateIdentityProviderError::InvalidParameter(
err.msg,
))
}
"NotAuthorizedException" => {
return RusotoError::Service(UpdateIdentityProviderError::NotAuthorized(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UpdateIdentityProviderError::ResourceNotFound(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(UpdateIdentityProviderError::TooManyRequests(
err.msg,
))
}
"UnsupportedIdentityProviderException" => {
return RusotoError::Service(
UpdateIdentityProviderError::UnsupportedIdentityProvider(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateIdentityProviderError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateIdentityProviderError::InternalError(ref cause) => write!(f, "{}", cause),
UpdateIdentityProviderError::InvalidParameter(ref cause) => write!(f, "{}", cause),
UpdateIdentityProviderError::NotAuthorized(ref cause) => write!(f, "{}", cause),
UpdateIdentityProviderError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
UpdateIdentityProviderError::TooManyRequests(ref cause) => write!(f, "{}", cause),
UpdateIdentityProviderError::UnsupportedIdentityProvider(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for UpdateIdentityProviderError {}
#[derive(Debug, PartialEq)]
pub enum UpdateResourceServerError {
InternalError(String),
InvalidParameter(String),
NotAuthorized(String),
ResourceNotFound(String),
TooManyRequests(String),
}
impl UpdateResourceServerError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateResourceServerError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(UpdateResourceServerError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(UpdateResourceServerError::InvalidParameter(
err.msg,
))
}
"NotAuthorizedException" => {
return RusotoError::Service(UpdateResourceServerError::NotAuthorized(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UpdateResourceServerError::ResourceNotFound(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(UpdateResourceServerError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateResourceServerError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateResourceServerError::InternalError(ref cause) => write!(f, "{}", cause),
UpdateResourceServerError::InvalidParameter(ref cause) => write!(f, "{}", cause),
UpdateResourceServerError::NotAuthorized(ref cause) => write!(f, "{}", cause),
UpdateResourceServerError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
UpdateResourceServerError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateResourceServerError {}
#[derive(Debug, PartialEq)]
pub enum UpdateUserAttributesError {
AliasExists(String),
CodeDeliveryFailure(String),
CodeMismatch(String),
ExpiredCode(String),
InternalError(String),
InvalidEmailRoleAccessPolicy(String),
InvalidLambdaResponse(String),
InvalidParameter(String),
InvalidSmsRoleAccessPolicy(String),
InvalidSmsRoleTrustRelationship(String),
NotAuthorized(String),
PasswordResetRequired(String),
ResourceNotFound(String),
TooManyRequests(String),
UnexpectedLambda(String),
UserLambdaValidation(String),
UserNotConfirmed(String),
UserNotFound(String),
}
impl UpdateUserAttributesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateUserAttributesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AliasExistsException" => {
return RusotoError::Service(UpdateUserAttributesError::AliasExists(err.msg))
}
"CodeDeliveryFailureException" => {
return RusotoError::Service(UpdateUserAttributesError::CodeDeliveryFailure(
err.msg,
))
}
"CodeMismatchException" => {
return RusotoError::Service(UpdateUserAttributesError::CodeMismatch(err.msg))
}
"ExpiredCodeException" => {
return RusotoError::Service(UpdateUserAttributesError::ExpiredCode(err.msg))
}
"InternalErrorException" => {
return RusotoError::Service(UpdateUserAttributesError::InternalError(err.msg))
}
"InvalidEmailRoleAccessPolicyException" => {
return RusotoError::Service(
UpdateUserAttributesError::InvalidEmailRoleAccessPolicy(err.msg),
)
}
"InvalidLambdaResponseException" => {
return RusotoError::Service(UpdateUserAttributesError::InvalidLambdaResponse(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(UpdateUserAttributesError::InvalidParameter(
err.msg,
))
}
"InvalidSmsRoleAccessPolicyException" => {
return RusotoError::Service(
UpdateUserAttributesError::InvalidSmsRoleAccessPolicy(err.msg),
)
}
"InvalidSmsRoleTrustRelationshipException" => {
return RusotoError::Service(
UpdateUserAttributesError::InvalidSmsRoleTrustRelationship(err.msg),
)
}
"NotAuthorizedException" => {
return RusotoError::Service(UpdateUserAttributesError::NotAuthorized(err.msg))
}
"PasswordResetRequiredException" => {
return RusotoError::Service(UpdateUserAttributesError::PasswordResetRequired(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UpdateUserAttributesError::ResourceNotFound(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(UpdateUserAttributesError::TooManyRequests(
err.msg,
))
}
"UnexpectedLambdaException" => {
return RusotoError::Service(UpdateUserAttributesError::UnexpectedLambda(
err.msg,
))
}
"UserLambdaValidationException" => {
return RusotoError::Service(UpdateUserAttributesError::UserLambdaValidation(
err.msg,
))
}
"UserNotConfirmedException" => {
return RusotoError::Service(UpdateUserAttributesError::UserNotConfirmed(
err.msg,
))
}
"UserNotFoundException" => {
return RusotoError::Service(UpdateUserAttributesError::UserNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateUserAttributesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateUserAttributesError::AliasExists(ref cause) => write!(f, "{}", cause),
UpdateUserAttributesError::CodeDeliveryFailure(ref cause) => write!(f, "{}", cause),
UpdateUserAttributesError::CodeMismatch(ref cause) => write!(f, "{}", cause),
UpdateUserAttributesError::ExpiredCode(ref cause) => write!(f, "{}", cause),
UpdateUserAttributesError::InternalError(ref cause) => write!(f, "{}", cause),
UpdateUserAttributesError::InvalidEmailRoleAccessPolicy(ref cause) => {
write!(f, "{}", cause)
}
UpdateUserAttributesError::InvalidLambdaResponse(ref cause) => write!(f, "{}", cause),
UpdateUserAttributesError::InvalidParameter(ref cause) => write!(f, "{}", cause),
UpdateUserAttributesError::InvalidSmsRoleAccessPolicy(ref cause) => {
write!(f, "{}", cause)
}
UpdateUserAttributesError::InvalidSmsRoleTrustRelationship(ref cause) => {
write!(f, "{}", cause)
}
UpdateUserAttributesError::NotAuthorized(ref cause) => write!(f, "{}", cause),
UpdateUserAttributesError::PasswordResetRequired(ref cause) => write!(f, "{}", cause),
UpdateUserAttributesError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
UpdateUserAttributesError::TooManyRequests(ref cause) => write!(f, "{}", cause),
UpdateUserAttributesError::UnexpectedLambda(ref cause) => write!(f, "{}", cause),
UpdateUserAttributesError::UserLambdaValidation(ref cause) => write!(f, "{}", cause),
UpdateUserAttributesError::UserNotConfirmed(ref cause) => write!(f, "{}", cause),
UpdateUserAttributesError::UserNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateUserAttributesError {}
#[derive(Debug, PartialEq)]
pub enum UpdateUserPoolError {
ConcurrentModification(String),
InternalError(String),
InvalidEmailRoleAccessPolicy(String),
InvalidParameter(String),
InvalidSmsRoleAccessPolicy(String),
InvalidSmsRoleTrustRelationship(String),
NotAuthorized(String),
ResourceNotFound(String),
TooManyRequests(String),
UserImportInProgress(String),
UserPoolTagging(String),
}
impl UpdateUserPoolError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateUserPoolError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ConcurrentModificationException" => {
return RusotoError::Service(UpdateUserPoolError::ConcurrentModification(
err.msg,
))
}
"InternalErrorException" => {
return RusotoError::Service(UpdateUserPoolError::InternalError(err.msg))
}
"InvalidEmailRoleAccessPolicyException" => {
return RusotoError::Service(UpdateUserPoolError::InvalidEmailRoleAccessPolicy(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(UpdateUserPoolError::InvalidParameter(err.msg))
}
"InvalidSmsRoleAccessPolicyException" => {
return RusotoError::Service(UpdateUserPoolError::InvalidSmsRoleAccessPolicy(
err.msg,
))
}
"InvalidSmsRoleTrustRelationshipException" => {
return RusotoError::Service(
UpdateUserPoolError::InvalidSmsRoleTrustRelationship(err.msg),
)
}
"NotAuthorizedException" => {
return RusotoError::Service(UpdateUserPoolError::NotAuthorized(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UpdateUserPoolError::ResourceNotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(UpdateUserPoolError::TooManyRequests(err.msg))
}
"UserImportInProgressException" => {
return RusotoError::Service(UpdateUserPoolError::UserImportInProgress(err.msg))
}
"UserPoolTaggingException" => {
return RusotoError::Service(UpdateUserPoolError::UserPoolTagging(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateUserPoolError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateUserPoolError::ConcurrentModification(ref cause) => write!(f, "{}", cause),
UpdateUserPoolError::InternalError(ref cause) => write!(f, "{}", cause),
UpdateUserPoolError::InvalidEmailRoleAccessPolicy(ref cause) => write!(f, "{}", cause),
UpdateUserPoolError::InvalidParameter(ref cause) => write!(f, "{}", cause),
UpdateUserPoolError::InvalidSmsRoleAccessPolicy(ref cause) => write!(f, "{}", cause),
UpdateUserPoolError::InvalidSmsRoleTrustRelationship(ref cause) => {
write!(f, "{}", cause)
}
UpdateUserPoolError::NotAuthorized(ref cause) => write!(f, "{}", cause),
UpdateUserPoolError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
UpdateUserPoolError::TooManyRequests(ref cause) => write!(f, "{}", cause),
UpdateUserPoolError::UserImportInProgress(ref cause) => write!(f, "{}", cause),
UpdateUserPoolError::UserPoolTagging(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateUserPoolError {}
#[derive(Debug, PartialEq)]
pub enum UpdateUserPoolClientError {
ConcurrentModification(String),
InternalError(String),
InvalidOAuthFlow(String),
InvalidParameter(String),
NotAuthorized(String),
ResourceNotFound(String),
ScopeDoesNotExist(String),
TooManyRequests(String),
}
impl UpdateUserPoolClientError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateUserPoolClientError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ConcurrentModificationException" => {
return RusotoError::Service(UpdateUserPoolClientError::ConcurrentModification(
err.msg,
))
}
"InternalErrorException" => {
return RusotoError::Service(UpdateUserPoolClientError::InternalError(err.msg))
}
"InvalidOAuthFlowException" => {
return RusotoError::Service(UpdateUserPoolClientError::InvalidOAuthFlow(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(UpdateUserPoolClientError::InvalidParameter(
err.msg,
))
}
"NotAuthorizedException" => {
return RusotoError::Service(UpdateUserPoolClientError::NotAuthorized(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UpdateUserPoolClientError::ResourceNotFound(
err.msg,
))
}
"ScopeDoesNotExistException" => {
return RusotoError::Service(UpdateUserPoolClientError::ScopeDoesNotExist(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(UpdateUserPoolClientError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateUserPoolClientError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateUserPoolClientError::ConcurrentModification(ref cause) => write!(f, "{}", cause),
UpdateUserPoolClientError::InternalError(ref cause) => write!(f, "{}", cause),
UpdateUserPoolClientError::InvalidOAuthFlow(ref cause) => write!(f, "{}", cause),
UpdateUserPoolClientError::InvalidParameter(ref cause) => write!(f, "{}", cause),
UpdateUserPoolClientError::NotAuthorized(ref cause) => write!(f, "{}", cause),
UpdateUserPoolClientError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
UpdateUserPoolClientError::ScopeDoesNotExist(ref cause) => write!(f, "{}", cause),
UpdateUserPoolClientError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateUserPoolClientError {}
#[derive(Debug, PartialEq)]
pub enum UpdateUserPoolDomainError {
InternalError(String),
InvalidParameter(String),
NotAuthorized(String),
ResourceNotFound(String),
TooManyRequests(String),
}
impl UpdateUserPoolDomainError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateUserPoolDomainError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(UpdateUserPoolDomainError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(UpdateUserPoolDomainError::InvalidParameter(
err.msg,
))
}
"NotAuthorizedException" => {
return RusotoError::Service(UpdateUserPoolDomainError::NotAuthorized(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UpdateUserPoolDomainError::ResourceNotFound(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(UpdateUserPoolDomainError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateUserPoolDomainError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateUserPoolDomainError::InternalError(ref cause) => write!(f, "{}", cause),
UpdateUserPoolDomainError::InvalidParameter(ref cause) => write!(f, "{}", cause),
UpdateUserPoolDomainError::NotAuthorized(ref cause) => write!(f, "{}", cause),
UpdateUserPoolDomainError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
UpdateUserPoolDomainError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateUserPoolDomainError {}
#[derive(Debug, PartialEq)]
pub enum VerifySoftwareTokenError {
CodeMismatch(String),
EnableSoftwareTokenMFA(String),
InternalError(String),
InvalidParameter(String),
InvalidUserPoolConfiguration(String),
NotAuthorized(String),
PasswordResetRequired(String),
ResourceNotFound(String),
SoftwareTokenMFANotFound(String),
TooManyRequests(String),
UserNotConfirmed(String),
UserNotFound(String),
}
impl VerifySoftwareTokenError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<VerifySoftwareTokenError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"CodeMismatchException" => {
return RusotoError::Service(VerifySoftwareTokenError::CodeMismatch(err.msg))
}
"EnableSoftwareTokenMFAException" => {
return RusotoError::Service(VerifySoftwareTokenError::EnableSoftwareTokenMFA(
err.msg,
))
}
"InternalErrorException" => {
return RusotoError::Service(VerifySoftwareTokenError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(VerifySoftwareTokenError::InvalidParameter(
err.msg,
))
}
"InvalidUserPoolConfigurationException" => {
return RusotoError::Service(
VerifySoftwareTokenError::InvalidUserPoolConfiguration(err.msg),
)
}
"NotAuthorizedException" => {
return RusotoError::Service(VerifySoftwareTokenError::NotAuthorized(err.msg))
}
"PasswordResetRequiredException" => {
return RusotoError::Service(VerifySoftwareTokenError::PasswordResetRequired(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(VerifySoftwareTokenError::ResourceNotFound(
err.msg,
))
}
"SoftwareTokenMFANotFoundException" => {
return RusotoError::Service(
VerifySoftwareTokenError::SoftwareTokenMFANotFound(err.msg),
)
}
"TooManyRequestsException" => {
return RusotoError::Service(VerifySoftwareTokenError::TooManyRequests(err.msg))
}
"UserNotConfirmedException" => {
return RusotoError::Service(VerifySoftwareTokenError::UserNotConfirmed(
err.msg,
))
}
"UserNotFoundException" => {
return RusotoError::Service(VerifySoftwareTokenError::UserNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for VerifySoftwareTokenError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
VerifySoftwareTokenError::CodeMismatch(ref cause) => write!(f, "{}", cause),
VerifySoftwareTokenError::EnableSoftwareTokenMFA(ref cause) => write!(f, "{}", cause),
VerifySoftwareTokenError::InternalError(ref cause) => write!(f, "{}", cause),
VerifySoftwareTokenError::InvalidParameter(ref cause) => write!(f, "{}", cause),
VerifySoftwareTokenError::InvalidUserPoolConfiguration(ref cause) => {
write!(f, "{}", cause)
}
VerifySoftwareTokenError::NotAuthorized(ref cause) => write!(f, "{}", cause),
VerifySoftwareTokenError::PasswordResetRequired(ref cause) => write!(f, "{}", cause),
VerifySoftwareTokenError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
VerifySoftwareTokenError::SoftwareTokenMFANotFound(ref cause) => write!(f, "{}", cause),
VerifySoftwareTokenError::TooManyRequests(ref cause) => write!(f, "{}", cause),
VerifySoftwareTokenError::UserNotConfirmed(ref cause) => write!(f, "{}", cause),
VerifySoftwareTokenError::UserNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for VerifySoftwareTokenError {}
#[derive(Debug, PartialEq)]
pub enum VerifyUserAttributeError {
CodeMismatch(String),
ExpiredCode(String),
InternalError(String),
InvalidParameter(String),
LimitExceeded(String),
NotAuthorized(String),
PasswordResetRequired(String),
ResourceNotFound(String),
TooManyRequests(String),
UserNotConfirmed(String),
UserNotFound(String),
}
impl VerifyUserAttributeError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<VerifyUserAttributeError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"CodeMismatchException" => {
return RusotoError::Service(VerifyUserAttributeError::CodeMismatch(err.msg))
}
"ExpiredCodeException" => {
return RusotoError::Service(VerifyUserAttributeError::ExpiredCode(err.msg))
}
"InternalErrorException" => {
return RusotoError::Service(VerifyUserAttributeError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(VerifyUserAttributeError::InvalidParameter(
err.msg,
))
}
"LimitExceededException" => {
return RusotoError::Service(VerifyUserAttributeError::LimitExceeded(err.msg))
}
"NotAuthorizedException" => {
return RusotoError::Service(VerifyUserAttributeError::NotAuthorized(err.msg))
}
"PasswordResetRequiredException" => {
return RusotoError::Service(VerifyUserAttributeError::PasswordResetRequired(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(VerifyUserAttributeError::ResourceNotFound(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(VerifyUserAttributeError::TooManyRequests(err.msg))
}
"UserNotConfirmedException" => {
return RusotoError::Service(VerifyUserAttributeError::UserNotConfirmed(
err.msg,
))
}
"UserNotFoundException" => {
return RusotoError::Service(VerifyUserAttributeError::UserNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for VerifyUserAttributeError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
VerifyUserAttributeError::CodeMismatch(ref cause) => write!(f, "{}", cause),
VerifyUserAttributeError::ExpiredCode(ref cause) => write!(f, "{}", cause),
VerifyUserAttributeError::InternalError(ref cause) => write!(f, "{}", cause),
VerifyUserAttributeError::InvalidParameter(ref cause) => write!(f, "{}", cause),
VerifyUserAttributeError::LimitExceeded(ref cause) => write!(f, "{}", cause),
VerifyUserAttributeError::NotAuthorized(ref cause) => write!(f, "{}", cause),
VerifyUserAttributeError::PasswordResetRequired(ref cause) => write!(f, "{}", cause),
VerifyUserAttributeError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
VerifyUserAttributeError::TooManyRequests(ref cause) => write!(f, "{}", cause),
VerifyUserAttributeError::UserNotConfirmed(ref cause) => write!(f, "{}", cause),
VerifyUserAttributeError::UserNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for VerifyUserAttributeError {}
#[async_trait]
pub trait CognitoIdentityProvider {
async fn add_custom_attributes(
&self,
input: AddCustomAttributesRequest,
) -> Result<AddCustomAttributesResponse, RusotoError<AddCustomAttributesError>>;
async fn admin_add_user_to_group(
&self,
input: AdminAddUserToGroupRequest,
) -> Result<(), RusotoError<AdminAddUserToGroupError>>;
async fn admin_confirm_sign_up(
&self,
input: AdminConfirmSignUpRequest,
) -> Result<AdminConfirmSignUpResponse, RusotoError<AdminConfirmSignUpError>>;
async fn admin_create_user(
&self,
input: AdminCreateUserRequest,
) -> Result<AdminCreateUserResponse, RusotoError<AdminCreateUserError>>;
async fn admin_delete_user(
&self,
input: AdminDeleteUserRequest,
) -> Result<(), RusotoError<AdminDeleteUserError>>;
async fn admin_delete_user_attributes(
&self,
input: AdminDeleteUserAttributesRequest,
) -> Result<AdminDeleteUserAttributesResponse, RusotoError<AdminDeleteUserAttributesError>>;
async fn admin_disable_provider_for_user(
&self,
input: AdminDisableProviderForUserRequest,
) -> Result<AdminDisableProviderForUserResponse, RusotoError<AdminDisableProviderForUserError>>;
async fn admin_disable_user(
&self,
input: AdminDisableUserRequest,
) -> Result<AdminDisableUserResponse, RusotoError<AdminDisableUserError>>;
async fn admin_enable_user(
&self,
input: AdminEnableUserRequest,
) -> Result<AdminEnableUserResponse, RusotoError<AdminEnableUserError>>;
async fn admin_forget_device(
&self,
input: AdminForgetDeviceRequest,
) -> Result<(), RusotoError<AdminForgetDeviceError>>;
async fn admin_get_device(
&self,
input: AdminGetDeviceRequest,
) -> Result<AdminGetDeviceResponse, RusotoError<AdminGetDeviceError>>;
async fn admin_get_user(
&self,
input: AdminGetUserRequest,
) -> Result<AdminGetUserResponse, RusotoError<AdminGetUserError>>;
async fn admin_initiate_auth(
&self,
input: AdminInitiateAuthRequest,
) -> Result<AdminInitiateAuthResponse, RusotoError<AdminInitiateAuthError>>;
async fn admin_link_provider_for_user(
&self,
input: AdminLinkProviderForUserRequest,
) -> Result<AdminLinkProviderForUserResponse, RusotoError<AdminLinkProviderForUserError>>;
async fn admin_list_devices(
&self,
input: AdminListDevicesRequest,
) -> Result<AdminListDevicesResponse, RusotoError<AdminListDevicesError>>;
async fn admin_list_groups_for_user(
&self,
input: AdminListGroupsForUserRequest,
) -> Result<AdminListGroupsForUserResponse, RusotoError<AdminListGroupsForUserError>>;
async fn admin_list_user_auth_events(
&self,
input: AdminListUserAuthEventsRequest,
) -> Result<AdminListUserAuthEventsResponse, RusotoError<AdminListUserAuthEventsError>>;
async fn admin_remove_user_from_group(
&self,
input: AdminRemoveUserFromGroupRequest,
) -> Result<(), RusotoError<AdminRemoveUserFromGroupError>>;
async fn admin_reset_user_password(
&self,
input: AdminResetUserPasswordRequest,
) -> Result<AdminResetUserPasswordResponse, RusotoError<AdminResetUserPasswordError>>;
async fn admin_respond_to_auth_challenge(
&self,
input: AdminRespondToAuthChallengeRequest,
) -> Result<AdminRespondToAuthChallengeResponse, RusotoError<AdminRespondToAuthChallengeError>>;
async fn admin_set_user_mfa_preference(
&self,
input: AdminSetUserMFAPreferenceRequest,
) -> Result<AdminSetUserMFAPreferenceResponse, RusotoError<AdminSetUserMFAPreferenceError>>;
async fn admin_set_user_password(
&self,
input: AdminSetUserPasswordRequest,
) -> Result<AdminSetUserPasswordResponse, RusotoError<AdminSetUserPasswordError>>;
async fn admin_set_user_settings(
&self,
input: AdminSetUserSettingsRequest,
) -> Result<AdminSetUserSettingsResponse, RusotoError<AdminSetUserSettingsError>>;
async fn admin_update_auth_event_feedback(
&self,
input: AdminUpdateAuthEventFeedbackRequest,
) -> Result<AdminUpdateAuthEventFeedbackResponse, RusotoError<AdminUpdateAuthEventFeedbackError>>;
async fn admin_update_device_status(
&self,
input: AdminUpdateDeviceStatusRequest,
) -> Result<AdminUpdateDeviceStatusResponse, RusotoError<AdminUpdateDeviceStatusError>>;
async fn admin_update_user_attributes(
&self,
input: AdminUpdateUserAttributesRequest,
) -> Result<AdminUpdateUserAttributesResponse, RusotoError<AdminUpdateUserAttributesError>>;
async fn admin_user_global_sign_out(
&self,
input: AdminUserGlobalSignOutRequest,
) -> Result<AdminUserGlobalSignOutResponse, RusotoError<AdminUserGlobalSignOutError>>;
async fn associate_software_token(
&self,
input: AssociateSoftwareTokenRequest,
) -> Result<AssociateSoftwareTokenResponse, RusotoError<AssociateSoftwareTokenError>>;
async fn change_password(
&self,
input: ChangePasswordRequest,
) -> Result<ChangePasswordResponse, RusotoError<ChangePasswordError>>;
async fn confirm_device(
&self,
input: ConfirmDeviceRequest,
) -> Result<ConfirmDeviceResponse, RusotoError<ConfirmDeviceError>>;
async fn confirm_forgot_password(
&self,
input: ConfirmForgotPasswordRequest,
) -> Result<ConfirmForgotPasswordResponse, RusotoError<ConfirmForgotPasswordError>>;
async fn confirm_sign_up(
&self,
input: ConfirmSignUpRequest,
) -> Result<ConfirmSignUpResponse, RusotoError<ConfirmSignUpError>>;
async fn create_group(
&self,
input: CreateGroupRequest,
) -> Result<CreateGroupResponse, RusotoError<CreateGroupError>>;
async fn create_identity_provider(
&self,
input: CreateIdentityProviderRequest,
) -> Result<CreateIdentityProviderResponse, RusotoError<CreateIdentityProviderError>>;
async fn create_resource_server(
&self,
input: CreateResourceServerRequest,
) -> Result<CreateResourceServerResponse, RusotoError<CreateResourceServerError>>;
async fn create_user_import_job(
&self,
input: CreateUserImportJobRequest,
) -> Result<CreateUserImportJobResponse, RusotoError<CreateUserImportJobError>>;
async fn create_user_pool(
&self,
input: CreateUserPoolRequest,
) -> Result<CreateUserPoolResponse, RusotoError<CreateUserPoolError>>;
async fn create_user_pool_client(
&self,
input: CreateUserPoolClientRequest,
) -> Result<CreateUserPoolClientResponse, RusotoError<CreateUserPoolClientError>>;
async fn create_user_pool_domain(
&self,
input: CreateUserPoolDomainRequest,
) -> Result<CreateUserPoolDomainResponse, RusotoError<CreateUserPoolDomainError>>;
async fn delete_group(
&self,
input: DeleteGroupRequest,
) -> Result<(), RusotoError<DeleteGroupError>>;
async fn delete_identity_provider(
&self,
input: DeleteIdentityProviderRequest,
) -> Result<(), RusotoError<DeleteIdentityProviderError>>;
async fn delete_resource_server(
&self,
input: DeleteResourceServerRequest,
) -> Result<(), RusotoError<DeleteResourceServerError>>;
async fn delete_user(
&self,
input: DeleteUserRequest,
) -> Result<(), RusotoError<DeleteUserError>>;
async fn delete_user_attributes(
&self,
input: DeleteUserAttributesRequest,
) -> Result<DeleteUserAttributesResponse, RusotoError<DeleteUserAttributesError>>;
async fn delete_user_pool(
&self,
input: DeleteUserPoolRequest,
) -> Result<(), RusotoError<DeleteUserPoolError>>;
async fn delete_user_pool_client(
&self,
input: DeleteUserPoolClientRequest,
) -> Result<(), RusotoError<DeleteUserPoolClientError>>;
async fn delete_user_pool_domain(
&self,
input: DeleteUserPoolDomainRequest,
) -> Result<DeleteUserPoolDomainResponse, RusotoError<DeleteUserPoolDomainError>>;
async fn describe_identity_provider(
&self,
input: DescribeIdentityProviderRequest,
) -> Result<DescribeIdentityProviderResponse, RusotoError<DescribeIdentityProviderError>>;
async fn describe_resource_server(
&self,
input: DescribeResourceServerRequest,
) -> Result<DescribeResourceServerResponse, RusotoError<DescribeResourceServerError>>;
async fn describe_risk_configuration(
&self,
input: DescribeRiskConfigurationRequest,
) -> Result<DescribeRiskConfigurationResponse, RusotoError<DescribeRiskConfigurationError>>;
async fn describe_user_import_job(
&self,
input: DescribeUserImportJobRequest,
) -> Result<DescribeUserImportJobResponse, RusotoError<DescribeUserImportJobError>>;
async fn describe_user_pool(
&self,
input: DescribeUserPoolRequest,
) -> Result<DescribeUserPoolResponse, RusotoError<DescribeUserPoolError>>;
async fn describe_user_pool_client(
&self,
input: DescribeUserPoolClientRequest,
) -> Result<DescribeUserPoolClientResponse, RusotoError<DescribeUserPoolClientError>>;
async fn describe_user_pool_domain(
&self,
input: DescribeUserPoolDomainRequest,
) -> Result<DescribeUserPoolDomainResponse, RusotoError<DescribeUserPoolDomainError>>;
async fn forget_device(
&self,
input: ForgetDeviceRequest,
) -> Result<(), RusotoError<ForgetDeviceError>>;
async fn forgot_password(
&self,
input: ForgotPasswordRequest,
) -> Result<ForgotPasswordResponse, RusotoError<ForgotPasswordError>>;
async fn get_csv_header(
&self,
input: GetCSVHeaderRequest,
) -> Result<GetCSVHeaderResponse, RusotoError<GetCSVHeaderError>>;
async fn get_device(
&self,
input: GetDeviceRequest,
) -> Result<GetDeviceResponse, RusotoError<GetDeviceError>>;
async fn get_group(
&self,
input: GetGroupRequest,
) -> Result<GetGroupResponse, RusotoError<GetGroupError>>;
async fn get_identity_provider_by_identifier(
&self,
input: GetIdentityProviderByIdentifierRequest,
) -> Result<
GetIdentityProviderByIdentifierResponse,
RusotoError<GetIdentityProviderByIdentifierError>,
>;
async fn get_signing_certificate(
&self,
input: GetSigningCertificateRequest,
) -> Result<GetSigningCertificateResponse, RusotoError<GetSigningCertificateError>>;
async fn get_ui_customization(
&self,
input: GetUICustomizationRequest,
) -> Result<GetUICustomizationResponse, RusotoError<GetUICustomizationError>>;
async fn get_user(
&self,
input: GetUserRequest,
) -> Result<GetUserResponse, RusotoError<GetUserError>>;
async fn get_user_attribute_verification_code(
&self,
input: GetUserAttributeVerificationCodeRequest,
) -> Result<
GetUserAttributeVerificationCodeResponse,
RusotoError<GetUserAttributeVerificationCodeError>,
>;
async fn get_user_pool_mfa_config(
&self,
input: GetUserPoolMfaConfigRequest,
) -> Result<GetUserPoolMfaConfigResponse, RusotoError<GetUserPoolMfaConfigError>>;
async fn global_sign_out(
&self,
input: GlobalSignOutRequest,
) -> Result<GlobalSignOutResponse, RusotoError<GlobalSignOutError>>;
async fn initiate_auth(
&self,
input: InitiateAuthRequest,
) -> Result<InitiateAuthResponse, RusotoError<InitiateAuthError>>;
async fn list_devices(
&self,
input: ListDevicesRequest,
) -> Result<ListDevicesResponse, RusotoError<ListDevicesError>>;
async fn list_groups(
&self,
input: ListGroupsRequest,
) -> Result<ListGroupsResponse, RusotoError<ListGroupsError>>;
async fn list_identity_providers(
&self,
input: ListIdentityProvidersRequest,
) -> Result<ListIdentityProvidersResponse, RusotoError<ListIdentityProvidersError>>;
async fn list_resource_servers(
&self,
input: ListResourceServersRequest,
) -> Result<ListResourceServersResponse, RusotoError<ListResourceServersError>>;
async fn list_tags_for_resource(
&self,
input: ListTagsForResourceRequest,
) -> Result<ListTagsForResourceResponse, RusotoError<ListTagsForResourceError>>;
async fn list_user_import_jobs(
&self,
input: ListUserImportJobsRequest,
) -> Result<ListUserImportJobsResponse, RusotoError<ListUserImportJobsError>>;
async fn list_user_pool_clients(
&self,
input: ListUserPoolClientsRequest,
) -> Result<ListUserPoolClientsResponse, RusotoError<ListUserPoolClientsError>>;
async fn list_user_pools(
&self,
input: ListUserPoolsRequest,
) -> Result<ListUserPoolsResponse, RusotoError<ListUserPoolsError>>;
async fn list_users(
&self,
input: ListUsersRequest,
) -> Result<ListUsersResponse, RusotoError<ListUsersError>>;
async fn list_users_in_group(
&self,
input: ListUsersInGroupRequest,
) -> Result<ListUsersInGroupResponse, RusotoError<ListUsersInGroupError>>;
async fn resend_confirmation_code(
&self,
input: ResendConfirmationCodeRequest,
) -> Result<ResendConfirmationCodeResponse, RusotoError<ResendConfirmationCodeError>>;
async fn respond_to_auth_challenge(
&self,
input: RespondToAuthChallengeRequest,
) -> Result<RespondToAuthChallengeResponse, RusotoError<RespondToAuthChallengeError>>;
async fn set_risk_configuration(
&self,
input: SetRiskConfigurationRequest,
) -> Result<SetRiskConfigurationResponse, RusotoError<SetRiskConfigurationError>>;
async fn set_ui_customization(
&self,
input: SetUICustomizationRequest,
) -> Result<SetUICustomizationResponse, RusotoError<SetUICustomizationError>>;
async fn set_user_mfa_preference(
&self,
input: SetUserMFAPreferenceRequest,
) -> Result<SetUserMFAPreferenceResponse, RusotoError<SetUserMFAPreferenceError>>;
async fn set_user_pool_mfa_config(
&self,
input: SetUserPoolMfaConfigRequest,
) -> Result<SetUserPoolMfaConfigResponse, RusotoError<SetUserPoolMfaConfigError>>;
async fn set_user_settings(
&self,
input: SetUserSettingsRequest,
) -> Result<SetUserSettingsResponse, RusotoError<SetUserSettingsError>>;
async fn sign_up(
&self,
input: SignUpRequest,
) -> Result<SignUpResponse, RusotoError<SignUpError>>;
async fn start_user_import_job(
&self,
input: StartUserImportJobRequest,
) -> Result<StartUserImportJobResponse, RusotoError<StartUserImportJobError>>;
async fn stop_user_import_job(
&self,
input: StopUserImportJobRequest,
) -> Result<StopUserImportJobResponse, RusotoError<StopUserImportJobError>>;
async fn tag_resource(
&self,
input: TagResourceRequest,
) -> Result<TagResourceResponse, RusotoError<TagResourceError>>;
async fn untag_resource(
&self,
input: UntagResourceRequest,
) -> Result<UntagResourceResponse, RusotoError<UntagResourceError>>;
async fn update_auth_event_feedback(
&self,
input: UpdateAuthEventFeedbackRequest,
) -> Result<UpdateAuthEventFeedbackResponse, RusotoError<UpdateAuthEventFeedbackError>>;
async fn update_device_status(
&self,
input: UpdateDeviceStatusRequest,
) -> Result<UpdateDeviceStatusResponse, RusotoError<UpdateDeviceStatusError>>;
async fn update_group(
&self,
input: UpdateGroupRequest,
) -> Result<UpdateGroupResponse, RusotoError<UpdateGroupError>>;
async fn update_identity_provider(
&self,
input: UpdateIdentityProviderRequest,
) -> Result<UpdateIdentityProviderResponse, RusotoError<UpdateIdentityProviderError>>;
async fn update_resource_server(
&self,
input: UpdateResourceServerRequest,
) -> Result<UpdateResourceServerResponse, RusotoError<UpdateResourceServerError>>;
async fn update_user_attributes(
&self,
input: UpdateUserAttributesRequest,
) -> Result<UpdateUserAttributesResponse, RusotoError<UpdateUserAttributesError>>;
async fn update_user_pool(
&self,
input: UpdateUserPoolRequest,
) -> Result<UpdateUserPoolResponse, RusotoError<UpdateUserPoolError>>;
async fn update_user_pool_client(
&self,
input: UpdateUserPoolClientRequest,
) -> Result<UpdateUserPoolClientResponse, RusotoError<UpdateUserPoolClientError>>;
async fn update_user_pool_domain(
&self,
input: UpdateUserPoolDomainRequest,
) -> Result<UpdateUserPoolDomainResponse, RusotoError<UpdateUserPoolDomainError>>;
async fn verify_software_token(
&self,
input: VerifySoftwareTokenRequest,
) -> Result<VerifySoftwareTokenResponse, RusotoError<VerifySoftwareTokenError>>;
async fn verify_user_attribute(
&self,
input: VerifyUserAttributeRequest,
) -> Result<VerifyUserAttributeResponse, RusotoError<VerifyUserAttributeError>>;
}
#[derive(Clone)]
pub struct CognitoIdentityProviderClient {
client: Client,
region: region::Region,
}
impl CognitoIdentityProviderClient {
pub fn new(region: region::Region) -> CognitoIdentityProviderClient {
CognitoIdentityProviderClient {
client: Client::shared(),
region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> CognitoIdentityProviderClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
D: DispatchSignedRequest + Send + Sync + 'static,
{
CognitoIdentityProviderClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region,
}
}
pub fn new_with_client(
client: Client,
region: region::Region,
) -> CognitoIdentityProviderClient {
CognitoIdentityProviderClient { client, region }
}
}
#[async_trait]
impl CognitoIdentityProvider for CognitoIdentityProviderClient {
async fn add_custom_attributes(
&self,
input: AddCustomAttributesRequest,
) -> Result<AddCustomAttributesResponse, RusotoError<AddCustomAttributesError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.AddCustomAttributes",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, AddCustomAttributesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<AddCustomAttributesResponse, _>()
}
async fn admin_add_user_to_group(
&self,
input: AdminAddUserToGroupRequest,
) -> Result<(), RusotoError<AdminAddUserToGroupError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.AdminAddUserToGroup",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, AdminAddUserToGroupError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn admin_confirm_sign_up(
&self,
input: AdminConfirmSignUpRequest,
) -> Result<AdminConfirmSignUpResponse, RusotoError<AdminConfirmSignUpError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.AdminConfirmSignUp",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, AdminConfirmSignUpError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<AdminConfirmSignUpResponse, _>()
}
async fn admin_create_user(
&self,
input: AdminCreateUserRequest,
) -> Result<AdminCreateUserResponse, RusotoError<AdminCreateUserError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.AdminCreateUser",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, AdminCreateUserError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<AdminCreateUserResponse, _>()
}
async fn admin_delete_user(
&self,
input: AdminDeleteUserRequest,
) -> Result<(), RusotoError<AdminDeleteUserError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.AdminDeleteUser",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, AdminDeleteUserError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn admin_delete_user_attributes(
&self,
input: AdminDeleteUserAttributesRequest,
) -> Result<AdminDeleteUserAttributesResponse, RusotoError<AdminDeleteUserAttributesError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.AdminDeleteUserAttributes",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, AdminDeleteUserAttributesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<AdminDeleteUserAttributesResponse, _>()
}
async fn admin_disable_provider_for_user(
&self,
input: AdminDisableProviderForUserRequest,
) -> Result<AdminDisableProviderForUserResponse, RusotoError<AdminDisableProviderForUserError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.AdminDisableProviderForUser",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, AdminDisableProviderForUserError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<AdminDisableProviderForUserResponse, _>()
}
async fn admin_disable_user(
&self,
input: AdminDisableUserRequest,
) -> Result<AdminDisableUserResponse, RusotoError<AdminDisableUserError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.AdminDisableUser",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, AdminDisableUserError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<AdminDisableUserResponse, _>()
}
async fn admin_enable_user(
&self,
input: AdminEnableUserRequest,
) -> Result<AdminEnableUserResponse, RusotoError<AdminEnableUserError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.AdminEnableUser",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, AdminEnableUserError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<AdminEnableUserResponse, _>()
}
async fn admin_forget_device(
&self,
input: AdminForgetDeviceRequest,
) -> Result<(), RusotoError<AdminForgetDeviceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.AdminForgetDevice",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, AdminForgetDeviceError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn admin_get_device(
&self,
input: AdminGetDeviceRequest,
) -> Result<AdminGetDeviceResponse, RusotoError<AdminGetDeviceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.AdminGetDevice",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, AdminGetDeviceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<AdminGetDeviceResponse, _>()
}
async fn admin_get_user(
&self,
input: AdminGetUserRequest,
) -> Result<AdminGetUserResponse, RusotoError<AdminGetUserError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.AdminGetUser",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, AdminGetUserError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<AdminGetUserResponse, _>()
}
async fn admin_initiate_auth(
&self,
input: AdminInitiateAuthRequest,
) -> Result<AdminInitiateAuthResponse, RusotoError<AdminInitiateAuthError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.AdminInitiateAuth",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, AdminInitiateAuthError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<AdminInitiateAuthResponse, _>()
}
async fn admin_link_provider_for_user(
&self,
input: AdminLinkProviderForUserRequest,
) -> Result<AdminLinkProviderForUserResponse, RusotoError<AdminLinkProviderForUserError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.AdminLinkProviderForUser",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, AdminLinkProviderForUserError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<AdminLinkProviderForUserResponse, _>()
}
async fn admin_list_devices(
&self,
input: AdminListDevicesRequest,
) -> Result<AdminListDevicesResponse, RusotoError<AdminListDevicesError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.AdminListDevices",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, AdminListDevicesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<AdminListDevicesResponse, _>()
}
async fn admin_list_groups_for_user(
&self,
input: AdminListGroupsForUserRequest,
) -> Result<AdminListGroupsForUserResponse, RusotoError<AdminListGroupsForUserError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.AdminListGroupsForUser",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, AdminListGroupsForUserError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<AdminListGroupsForUserResponse, _>()
}
async fn admin_list_user_auth_events(
&self,
input: AdminListUserAuthEventsRequest,
) -> Result<AdminListUserAuthEventsResponse, RusotoError<AdminListUserAuthEventsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.AdminListUserAuthEvents",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, AdminListUserAuthEventsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<AdminListUserAuthEventsResponse, _>()
}
async fn admin_remove_user_from_group(
&self,
input: AdminRemoveUserFromGroupRequest,
) -> Result<(), RusotoError<AdminRemoveUserFromGroupError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.AdminRemoveUserFromGroup",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, AdminRemoveUserFromGroupError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn admin_reset_user_password(
&self,
input: AdminResetUserPasswordRequest,
) -> Result<AdminResetUserPasswordResponse, RusotoError<AdminResetUserPasswordError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.AdminResetUserPassword",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, AdminResetUserPasswordError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<AdminResetUserPasswordResponse, _>()
}
async fn admin_respond_to_auth_challenge(
&self,
input: AdminRespondToAuthChallengeRequest,
) -> Result<AdminRespondToAuthChallengeResponse, RusotoError<AdminRespondToAuthChallengeError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.AdminRespondToAuthChallenge",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, AdminRespondToAuthChallengeError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<AdminRespondToAuthChallengeResponse, _>()
}
async fn admin_set_user_mfa_preference(
&self,
input: AdminSetUserMFAPreferenceRequest,
) -> Result<AdminSetUserMFAPreferenceResponse, RusotoError<AdminSetUserMFAPreferenceError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.AdminSetUserMFAPreference",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, AdminSetUserMFAPreferenceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<AdminSetUserMFAPreferenceResponse, _>()
}
async fn admin_set_user_password(
&self,
input: AdminSetUserPasswordRequest,
) -> Result<AdminSetUserPasswordResponse, RusotoError<AdminSetUserPasswordError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.AdminSetUserPassword",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, AdminSetUserPasswordError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<AdminSetUserPasswordResponse, _>()
}
async fn admin_set_user_settings(
&self,
input: AdminSetUserSettingsRequest,
) -> Result<AdminSetUserSettingsResponse, RusotoError<AdminSetUserSettingsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.AdminSetUserSettings",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, AdminSetUserSettingsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<AdminSetUserSettingsResponse, _>()
}
async fn admin_update_auth_event_feedback(
&self,
input: AdminUpdateAuthEventFeedbackRequest,
) -> Result<AdminUpdateAuthEventFeedbackResponse, RusotoError<AdminUpdateAuthEventFeedbackError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.AdminUpdateAuthEventFeedback",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, AdminUpdateAuthEventFeedbackError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<AdminUpdateAuthEventFeedbackResponse, _>()
}
async fn admin_update_device_status(
&self,
input: AdminUpdateDeviceStatusRequest,
) -> Result<AdminUpdateDeviceStatusResponse, RusotoError<AdminUpdateDeviceStatusError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.AdminUpdateDeviceStatus",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, AdminUpdateDeviceStatusError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<AdminUpdateDeviceStatusResponse, _>()
}
async fn admin_update_user_attributes(
&self,
input: AdminUpdateUserAttributesRequest,
) -> Result<AdminUpdateUserAttributesResponse, RusotoError<AdminUpdateUserAttributesError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.AdminUpdateUserAttributes",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, AdminUpdateUserAttributesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<AdminUpdateUserAttributesResponse, _>()
}
async fn admin_user_global_sign_out(
&self,
input: AdminUserGlobalSignOutRequest,
) -> Result<AdminUserGlobalSignOutResponse, RusotoError<AdminUserGlobalSignOutError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.AdminUserGlobalSignOut",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, AdminUserGlobalSignOutError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<AdminUserGlobalSignOutResponse, _>()
}
async fn associate_software_token(
&self,
input: AssociateSoftwareTokenRequest,
) -> Result<AssociateSoftwareTokenResponse, RusotoError<AssociateSoftwareTokenError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.AssociateSoftwareToken",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, AssociateSoftwareTokenError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<AssociateSoftwareTokenResponse, _>()
}
async fn change_password(
&self,
input: ChangePasswordRequest,
) -> Result<ChangePasswordResponse, RusotoError<ChangePasswordError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.ChangePassword",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ChangePasswordError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ChangePasswordResponse, _>()
}
async fn confirm_device(
&self,
input: ConfirmDeviceRequest,
) -> Result<ConfirmDeviceResponse, RusotoError<ConfirmDeviceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.ConfirmDevice",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ConfirmDeviceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ConfirmDeviceResponse, _>()
}
async fn confirm_forgot_password(
&self,
input: ConfirmForgotPasswordRequest,
) -> Result<ConfirmForgotPasswordResponse, RusotoError<ConfirmForgotPasswordError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.ConfirmForgotPassword",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ConfirmForgotPasswordError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ConfirmForgotPasswordResponse, _>()
}
async fn confirm_sign_up(
&self,
input: ConfirmSignUpRequest,
) -> Result<ConfirmSignUpResponse, RusotoError<ConfirmSignUpError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.ConfirmSignUp",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ConfirmSignUpError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ConfirmSignUpResponse, _>()
}
async fn create_group(
&self,
input: CreateGroupRequest,
) -> Result<CreateGroupResponse, RusotoError<CreateGroupError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.CreateGroup",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateGroupError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateGroupResponse, _>()
}
async fn create_identity_provider(
&self,
input: CreateIdentityProviderRequest,
) -> Result<CreateIdentityProviderResponse, RusotoError<CreateIdentityProviderError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.CreateIdentityProvider",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateIdentityProviderError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<CreateIdentityProviderResponse, _>()
}
async fn create_resource_server(
&self,
input: CreateResourceServerRequest,
) -> Result<CreateResourceServerResponse, RusotoError<CreateResourceServerError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.CreateResourceServer",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateResourceServerError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<CreateResourceServerResponse, _>()
}
async fn create_user_import_job(
&self,
input: CreateUserImportJobRequest,
) -> Result<CreateUserImportJobResponse, RusotoError<CreateUserImportJobError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.CreateUserImportJob",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateUserImportJobError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateUserImportJobResponse, _>()
}
async fn create_user_pool(
&self,
input: CreateUserPoolRequest,
) -> Result<CreateUserPoolResponse, RusotoError<CreateUserPoolError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.CreateUserPool",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateUserPoolError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateUserPoolResponse, _>()
}
async fn create_user_pool_client(
&self,
input: CreateUserPoolClientRequest,
) -> Result<CreateUserPoolClientResponse, RusotoError<CreateUserPoolClientError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.CreateUserPoolClient",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateUserPoolClientError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<CreateUserPoolClientResponse, _>()
}
async fn create_user_pool_domain(
&self,
input: CreateUserPoolDomainRequest,
) -> Result<CreateUserPoolDomainResponse, RusotoError<CreateUserPoolDomainError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.CreateUserPoolDomain",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateUserPoolDomainError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<CreateUserPoolDomainResponse, _>()
}
async fn delete_group(
&self,
input: DeleteGroupRequest,
) -> Result<(), RusotoError<DeleteGroupError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.DeleteGroup",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteGroupError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn delete_identity_provider(
&self,
input: DeleteIdentityProviderRequest,
) -> Result<(), RusotoError<DeleteIdentityProviderError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.DeleteIdentityProvider",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteIdentityProviderError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn delete_resource_server(
&self,
input: DeleteResourceServerRequest,
) -> Result<(), RusotoError<DeleteResourceServerError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.DeleteResourceServer",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteResourceServerError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn delete_user(
&self,
input: DeleteUserRequest,
) -> Result<(), RusotoError<DeleteUserError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.DeleteUser",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteUserError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn delete_user_attributes(
&self,
input: DeleteUserAttributesRequest,
) -> Result<DeleteUserAttributesResponse, RusotoError<DeleteUserAttributesError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.DeleteUserAttributes",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteUserAttributesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteUserAttributesResponse, _>()
}
async fn delete_user_pool(
&self,
input: DeleteUserPoolRequest,
) -> Result<(), RusotoError<DeleteUserPoolError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.DeleteUserPool",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteUserPoolError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn delete_user_pool_client(
&self,
input: DeleteUserPoolClientRequest,
) -> Result<(), RusotoError<DeleteUserPoolClientError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.DeleteUserPoolClient",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteUserPoolClientError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn delete_user_pool_domain(
&self,
input: DeleteUserPoolDomainRequest,
) -> Result<DeleteUserPoolDomainResponse, RusotoError<DeleteUserPoolDomainError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.DeleteUserPoolDomain",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteUserPoolDomainError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteUserPoolDomainResponse, _>()
}
async fn describe_identity_provider(
&self,
input: DescribeIdentityProviderRequest,
) -> Result<DescribeIdentityProviderResponse, RusotoError<DescribeIdentityProviderError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.DescribeIdentityProvider",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeIdentityProviderError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeIdentityProviderResponse, _>()
}
async fn describe_resource_server(
&self,
input: DescribeResourceServerRequest,
) -> Result<DescribeResourceServerResponse, RusotoError<DescribeResourceServerError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.DescribeResourceServer",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeResourceServerError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeResourceServerResponse, _>()
}
async fn describe_risk_configuration(
&self,
input: DescribeRiskConfigurationRequest,
) -> Result<DescribeRiskConfigurationResponse, RusotoError<DescribeRiskConfigurationError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.DescribeRiskConfiguration",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeRiskConfigurationError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeRiskConfigurationResponse, _>()
}
async fn describe_user_import_job(
&self,
input: DescribeUserImportJobRequest,
) -> Result<DescribeUserImportJobResponse, RusotoError<DescribeUserImportJobError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.DescribeUserImportJob",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeUserImportJobError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeUserImportJobResponse, _>()
}
async fn describe_user_pool(
&self,
input: DescribeUserPoolRequest,
) -> Result<DescribeUserPoolResponse, RusotoError<DescribeUserPoolError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.DescribeUserPool",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeUserPoolError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DescribeUserPoolResponse, _>()
}
async fn describe_user_pool_client(
&self,
input: DescribeUserPoolClientRequest,
) -> Result<DescribeUserPoolClientResponse, RusotoError<DescribeUserPoolClientError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.DescribeUserPoolClient",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeUserPoolClientError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeUserPoolClientResponse, _>()
}
async fn describe_user_pool_domain(
&self,
input: DescribeUserPoolDomainRequest,
) -> Result<DescribeUserPoolDomainResponse, RusotoError<DescribeUserPoolDomainError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.DescribeUserPoolDomain",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeUserPoolDomainError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeUserPoolDomainResponse, _>()
}
async fn forget_device(
&self,
input: ForgetDeviceRequest,
) -> Result<(), RusotoError<ForgetDeviceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.ForgetDevice",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ForgetDeviceError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn forgot_password(
&self,
input: ForgotPasswordRequest,
) -> Result<ForgotPasswordResponse, RusotoError<ForgotPasswordError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.ForgotPassword",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ForgotPasswordError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ForgotPasswordResponse, _>()
}
async fn get_csv_header(
&self,
input: GetCSVHeaderRequest,
) -> Result<GetCSVHeaderResponse, RusotoError<GetCSVHeaderError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.GetCSVHeader",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetCSVHeaderError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetCSVHeaderResponse, _>()
}
async fn get_device(
&self,
input: GetDeviceRequest,
) -> Result<GetDeviceResponse, RusotoError<GetDeviceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.GetDevice",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetDeviceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetDeviceResponse, _>()
}
async fn get_group(
&self,
input: GetGroupRequest,
) -> Result<GetGroupResponse, RusotoError<GetGroupError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSCognitoIdentityProviderService.GetGroup");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetGroupError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetGroupResponse, _>()
}
async fn get_identity_provider_by_identifier(
&self,
input: GetIdentityProviderByIdentifierRequest,
) -> Result<
GetIdentityProviderByIdentifierResponse,
RusotoError<GetIdentityProviderByIdentifierError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.GetIdentityProviderByIdentifier",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetIdentityProviderByIdentifierError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<GetIdentityProviderByIdentifierResponse, _>()
}
async fn get_signing_certificate(
&self,
input: GetSigningCertificateRequest,
) -> Result<GetSigningCertificateResponse, RusotoError<GetSigningCertificateError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.GetSigningCertificate",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetSigningCertificateError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<GetSigningCertificateResponse, _>()
}
async fn get_ui_customization(
&self,
input: GetUICustomizationRequest,
) -> Result<GetUICustomizationResponse, RusotoError<GetUICustomizationError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.GetUICustomization",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetUICustomizationError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetUICustomizationResponse, _>()
}
async fn get_user(
&self,
input: GetUserRequest,
) -> Result<GetUserResponse, RusotoError<GetUserError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSCognitoIdentityProviderService.GetUser");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetUserError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetUserResponse, _>()
}
async fn get_user_attribute_verification_code(
&self,
input: GetUserAttributeVerificationCodeRequest,
) -> Result<
GetUserAttributeVerificationCodeResponse,
RusotoError<GetUserAttributeVerificationCodeError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.GetUserAttributeVerificationCode",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
GetUserAttributeVerificationCodeError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<GetUserAttributeVerificationCodeResponse, _>()
}
async fn get_user_pool_mfa_config(
&self,
input: GetUserPoolMfaConfigRequest,
) -> Result<GetUserPoolMfaConfigResponse, RusotoError<GetUserPoolMfaConfigError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.GetUserPoolMfaConfig",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetUserPoolMfaConfigError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<GetUserPoolMfaConfigResponse, _>()
}
async fn global_sign_out(
&self,
input: GlobalSignOutRequest,
) -> Result<GlobalSignOutResponse, RusotoError<GlobalSignOutError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.GlobalSignOut",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GlobalSignOutError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GlobalSignOutResponse, _>()
}
async fn initiate_auth(
&self,
input: InitiateAuthRequest,
) -> Result<InitiateAuthResponse, RusotoError<InitiateAuthError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.InitiateAuth",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, InitiateAuthError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<InitiateAuthResponse, _>()
}
async fn list_devices(
&self,
input: ListDevicesRequest,
) -> Result<ListDevicesResponse, RusotoError<ListDevicesError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.ListDevices",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListDevicesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListDevicesResponse, _>()
}
async fn list_groups(
&self,
input: ListGroupsRequest,
) -> Result<ListGroupsResponse, RusotoError<ListGroupsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.ListGroups",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListGroupsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListGroupsResponse, _>()
}
async fn list_identity_providers(
&self,
input: ListIdentityProvidersRequest,
) -> Result<ListIdentityProvidersResponse, RusotoError<ListIdentityProvidersError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.ListIdentityProviders",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListIdentityProvidersError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListIdentityProvidersResponse, _>()
}
async fn list_resource_servers(
&self,
input: ListResourceServersRequest,
) -> Result<ListResourceServersResponse, RusotoError<ListResourceServersError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.ListResourceServers",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListResourceServersError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListResourceServersResponse, _>()
}
async fn list_tags_for_resource(
&self,
input: ListTagsForResourceRequest,
) -> Result<ListTagsForResourceResponse, RusotoError<ListTagsForResourceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.ListTagsForResource",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListTagsForResourceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListTagsForResourceResponse, _>()
}
async fn list_user_import_jobs(
&self,
input: ListUserImportJobsRequest,
) -> Result<ListUserImportJobsResponse, RusotoError<ListUserImportJobsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.ListUserImportJobs",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListUserImportJobsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListUserImportJobsResponse, _>()
}
async fn list_user_pool_clients(
&self,
input: ListUserPoolClientsRequest,
) -> Result<ListUserPoolClientsResponse, RusotoError<ListUserPoolClientsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.ListUserPoolClients",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListUserPoolClientsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListUserPoolClientsResponse, _>()
}
async fn list_user_pools(
&self,
input: ListUserPoolsRequest,
) -> Result<ListUserPoolsResponse, RusotoError<ListUserPoolsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.ListUserPools",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListUserPoolsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListUserPoolsResponse, _>()
}
async fn list_users(
&self,
input: ListUsersRequest,
) -> Result<ListUsersResponse, RusotoError<ListUsersError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.ListUsers",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListUsersError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListUsersResponse, _>()
}
async fn list_users_in_group(
&self,
input: ListUsersInGroupRequest,
) -> Result<ListUsersInGroupResponse, RusotoError<ListUsersInGroupError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.ListUsersInGroup",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListUsersInGroupError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListUsersInGroupResponse, _>()
}
async fn resend_confirmation_code(
&self,
input: ResendConfirmationCodeRequest,
) -> Result<ResendConfirmationCodeResponse, RusotoError<ResendConfirmationCodeError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.ResendConfirmationCode",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ResendConfirmationCodeError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ResendConfirmationCodeResponse, _>()
}
async fn respond_to_auth_challenge(
&self,
input: RespondToAuthChallengeRequest,
) -> Result<RespondToAuthChallengeResponse, RusotoError<RespondToAuthChallengeError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.RespondToAuthChallenge",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, RespondToAuthChallengeError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<RespondToAuthChallengeResponse, _>()
}
async fn set_risk_configuration(
&self,
input: SetRiskConfigurationRequest,
) -> Result<SetRiskConfigurationResponse, RusotoError<SetRiskConfigurationError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.SetRiskConfiguration",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, SetRiskConfigurationError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<SetRiskConfigurationResponse, _>()
}
async fn set_ui_customization(
&self,
input: SetUICustomizationRequest,
) -> Result<SetUICustomizationResponse, RusotoError<SetUICustomizationError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.SetUICustomization",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, SetUICustomizationError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<SetUICustomizationResponse, _>()
}
async fn set_user_mfa_preference(
&self,
input: SetUserMFAPreferenceRequest,
) -> Result<SetUserMFAPreferenceResponse, RusotoError<SetUserMFAPreferenceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.SetUserMFAPreference",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, SetUserMFAPreferenceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<SetUserMFAPreferenceResponse, _>()
}
async fn set_user_pool_mfa_config(
&self,
input: SetUserPoolMfaConfigRequest,
) -> Result<SetUserPoolMfaConfigResponse, RusotoError<SetUserPoolMfaConfigError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.SetUserPoolMfaConfig",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, SetUserPoolMfaConfigError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<SetUserPoolMfaConfigResponse, _>()
}
async fn set_user_settings(
&self,
input: SetUserSettingsRequest,
) -> Result<SetUserSettingsResponse, RusotoError<SetUserSettingsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.SetUserSettings",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, SetUserSettingsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<SetUserSettingsResponse, _>()
}
async fn sign_up(
&self,
input: SignUpRequest,
) -> Result<SignUpResponse, RusotoError<SignUpError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSCognitoIdentityProviderService.SignUp");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, SignUpError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<SignUpResponse, _>()
}
async fn start_user_import_job(
&self,
input: StartUserImportJobRequest,
) -> Result<StartUserImportJobResponse, RusotoError<StartUserImportJobError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.StartUserImportJob",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, StartUserImportJobError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<StartUserImportJobResponse, _>()
}
async fn stop_user_import_job(
&self,
input: StopUserImportJobRequest,
) -> Result<StopUserImportJobResponse, RusotoError<StopUserImportJobError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.StopUserImportJob",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, StopUserImportJobError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<StopUserImportJobResponse, _>()
}
async fn tag_resource(
&self,
input: TagResourceRequest,
) -> Result<TagResourceResponse, RusotoError<TagResourceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.TagResource",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, TagResourceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<TagResourceResponse, _>()
}
async fn untag_resource(
&self,
input: UntagResourceRequest,
) -> Result<UntagResourceResponse, RusotoError<UntagResourceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.UntagResource",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UntagResourceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<UntagResourceResponse, _>()
}
async fn update_auth_event_feedback(
&self,
input: UpdateAuthEventFeedbackRequest,
) -> Result<UpdateAuthEventFeedbackResponse, RusotoError<UpdateAuthEventFeedbackError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.UpdateAuthEventFeedback",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UpdateAuthEventFeedbackError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateAuthEventFeedbackResponse, _>()
}
async fn update_device_status(
&self,
input: UpdateDeviceStatusRequest,
) -> Result<UpdateDeviceStatusResponse, RusotoError<UpdateDeviceStatusError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.UpdateDeviceStatus",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UpdateDeviceStatusError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<UpdateDeviceStatusResponse, _>()
}
async fn update_group(
&self,
input: UpdateGroupRequest,
) -> Result<UpdateGroupResponse, RusotoError<UpdateGroupError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.UpdateGroup",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UpdateGroupError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<UpdateGroupResponse, _>()
}
async fn update_identity_provider(
&self,
input: UpdateIdentityProviderRequest,
) -> Result<UpdateIdentityProviderResponse, RusotoError<UpdateIdentityProviderError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.UpdateIdentityProvider",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UpdateIdentityProviderError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateIdentityProviderResponse, _>()
}
async fn update_resource_server(
&self,
input: UpdateResourceServerRequest,
) -> Result<UpdateResourceServerResponse, RusotoError<UpdateResourceServerError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.UpdateResourceServer",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UpdateResourceServerError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateResourceServerResponse, _>()
}
async fn update_user_attributes(
&self,
input: UpdateUserAttributesRequest,
) -> Result<UpdateUserAttributesResponse, RusotoError<UpdateUserAttributesError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.UpdateUserAttributes",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UpdateUserAttributesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateUserAttributesResponse, _>()
}
async fn update_user_pool(
&self,
input: UpdateUserPoolRequest,
) -> Result<UpdateUserPoolResponse, RusotoError<UpdateUserPoolError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.UpdateUserPool",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UpdateUserPoolError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<UpdateUserPoolResponse, _>()
}
async fn update_user_pool_client(
&self,
input: UpdateUserPoolClientRequest,
) -> Result<UpdateUserPoolClientResponse, RusotoError<UpdateUserPoolClientError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.UpdateUserPoolClient",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UpdateUserPoolClientError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateUserPoolClientResponse, _>()
}
async fn update_user_pool_domain(
&self,
input: UpdateUserPoolDomainRequest,
) -> Result<UpdateUserPoolDomainResponse, RusotoError<UpdateUserPoolDomainError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.UpdateUserPoolDomain",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UpdateUserPoolDomainError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateUserPoolDomainResponse, _>()
}
async fn verify_software_token(
&self,
input: VerifySoftwareTokenRequest,
) -> Result<VerifySoftwareTokenResponse, RusotoError<VerifySoftwareTokenError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.VerifySoftwareToken",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, VerifySoftwareTokenError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<VerifySoftwareTokenResponse, _>()
}
async fn verify_user_attribute(
&self,
input: VerifyUserAttributeRequest,
) -> Result<VerifyUserAttributeResponse, RusotoError<VerifyUserAttributeError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSCognitoIdentityProviderService.VerifyUserAttribute",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, VerifyUserAttributeError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<VerifyUserAttributeResponse, _>()
}
}