use std::error::Error;
use std::fmt;
use async_trait::async_trait;
use rusoto_core::credential::ProvideAwsCredentials;
use rusoto_core::region;
use rusoto_core::request::{BufferedHttpResponse, DispatchSignedRequest};
use rusoto_core::{Client, RusotoError};
use rusoto_core::param::{Params, ServiceParams};
use rusoto_core::proto;
use rusoto_core::signature::SignedRequest;
#[allow(unused_imports)]
use serde::{Deserialize, Serialize};
use serde_json;
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct BulkPublishRequest {
#[serde(rename = "IdentityPoolId")]
pub identity_pool_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BulkPublishResponse {
#[serde(rename = "IdentityPoolId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub identity_pool_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct CognitoStreams {
#[serde(rename = "RoleArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub role_arn: Option<String>,
#[serde(rename = "StreamName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stream_name: Option<String>,
#[serde(rename = "StreamingStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub streaming_status: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Dataset {
#[serde(rename = "CreationDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_date: Option<f64>,
#[serde(rename = "DataStorage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub data_storage: Option<i64>,
#[serde(rename = "DatasetName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dataset_name: Option<String>,
#[serde(rename = "IdentityId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub identity_id: Option<String>,
#[serde(rename = "LastModifiedBy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_modified_by: Option<String>,
#[serde(rename = "LastModifiedDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_modified_date: Option<f64>,
#[serde(rename = "NumRecords")]
#[serde(skip_serializing_if = "Option::is_none")]
pub num_records: Option<i64>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteDatasetRequest {
#[serde(rename = "DatasetName")]
pub dataset_name: String,
#[serde(rename = "IdentityId")]
pub identity_id: String,
#[serde(rename = "IdentityPoolId")]
pub identity_pool_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteDatasetResponse {
#[serde(rename = "Dataset")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dataset: Option<Dataset>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeDatasetRequest {
#[serde(rename = "DatasetName")]
pub dataset_name: String,
#[serde(rename = "IdentityId")]
pub identity_id: String,
#[serde(rename = "IdentityPoolId")]
pub identity_pool_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeDatasetResponse {
#[serde(rename = "Dataset")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dataset: Option<Dataset>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeIdentityPoolUsageRequest {
#[serde(rename = "IdentityPoolId")]
pub identity_pool_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeIdentityPoolUsageResponse {
#[serde(rename = "IdentityPoolUsage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub identity_pool_usage: Option<IdentityPoolUsage>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeIdentityUsageRequest {
#[serde(rename = "IdentityId")]
pub identity_id: String,
#[serde(rename = "IdentityPoolId")]
pub identity_pool_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeIdentityUsageResponse {
#[serde(rename = "IdentityUsage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub identity_usage: Option<IdentityUsage>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetBulkPublishDetailsRequest {
#[serde(rename = "IdentityPoolId")]
pub identity_pool_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetBulkPublishDetailsResponse {
#[serde(rename = "BulkPublishCompleteTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bulk_publish_complete_time: Option<f64>,
#[serde(rename = "BulkPublishStartTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bulk_publish_start_time: Option<f64>,
#[serde(rename = "BulkPublishStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bulk_publish_status: Option<String>,
#[serde(rename = "FailureMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_message: Option<String>,
#[serde(rename = "IdentityPoolId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub identity_pool_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetCognitoEventsRequest {
#[serde(rename = "IdentityPoolId")]
pub identity_pool_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetCognitoEventsResponse {
#[serde(rename = "Events")]
#[serde(skip_serializing_if = "Option::is_none")]
pub events: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetIdentityPoolConfigurationRequest {
#[serde(rename = "IdentityPoolId")]
pub identity_pool_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetIdentityPoolConfigurationResponse {
#[serde(rename = "CognitoStreams")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cognito_streams: Option<CognitoStreams>,
#[serde(rename = "IdentityPoolId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub identity_pool_id: Option<String>,
#[serde(rename = "PushSync")]
#[serde(skip_serializing_if = "Option::is_none")]
pub push_sync: Option<PushSync>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct IdentityPoolUsage {
#[serde(rename = "DataStorage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub data_storage: Option<i64>,
#[serde(rename = "IdentityPoolId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub identity_pool_id: Option<String>,
#[serde(rename = "LastModifiedDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_modified_date: Option<f64>,
#[serde(rename = "SyncSessionsCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sync_sessions_count: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct IdentityUsage {
#[serde(rename = "DataStorage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub data_storage: Option<i64>,
#[serde(rename = "DatasetCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dataset_count: Option<i64>,
#[serde(rename = "IdentityId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub identity_id: Option<String>,
#[serde(rename = "IdentityPoolId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub identity_pool_id: Option<String>,
#[serde(rename = "LastModifiedDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_modified_date: Option<f64>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListDatasetsRequest {
#[serde(rename = "IdentityId")]
pub identity_id: String,
#[serde(rename = "IdentityPoolId")]
pub identity_pool_id: String,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListDatasetsResponse {
#[serde(rename = "Count")]
#[serde(skip_serializing_if = "Option::is_none")]
pub count: Option<i64>,
#[serde(rename = "Datasets")]
#[serde(skip_serializing_if = "Option::is_none")]
pub datasets: Option<Vec<Dataset>>,
#[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 ListIdentityPoolUsageRequest {
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListIdentityPoolUsageResponse {
#[serde(rename = "Count")]
#[serde(skip_serializing_if = "Option::is_none")]
pub count: Option<i64>,
#[serde(rename = "IdentityPoolUsages")]
#[serde(skip_serializing_if = "Option::is_none")]
pub identity_pool_usages: Option<Vec<IdentityPoolUsage>>,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListRecordsRequest {
#[serde(rename = "DatasetName")]
pub dataset_name: String,
#[serde(rename = "IdentityId")]
pub identity_id: String,
#[serde(rename = "IdentityPoolId")]
pub identity_pool_id: String,
#[serde(rename = "LastSyncCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_sync_count: Option<i64>,
#[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 = "SyncSessionToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sync_session_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListRecordsResponse {
#[serde(rename = "Count")]
#[serde(skip_serializing_if = "Option::is_none")]
pub count: Option<i64>,
#[serde(rename = "DatasetDeletedAfterRequestedSyncCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dataset_deleted_after_requested_sync_count: Option<bool>,
#[serde(rename = "DatasetExists")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dataset_exists: Option<bool>,
#[serde(rename = "DatasetSyncCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dataset_sync_count: Option<i64>,
#[serde(rename = "LastModifiedBy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_modified_by: Option<String>,
#[serde(rename = "MergedDatasetNames")]
#[serde(skip_serializing_if = "Option::is_none")]
pub merged_dataset_names: Option<Vec<String>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Records")]
#[serde(skip_serializing_if = "Option::is_none")]
pub records: Option<Vec<Record>>,
#[serde(rename = "SyncSessionToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sync_session_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct PushSync {
#[serde(rename = "ApplicationArns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_arns: Option<Vec<String>>,
#[serde(rename = "RoleArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub role_arn: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Record {
#[serde(rename = "DeviceLastModifiedDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub device_last_modified_date: Option<f64>,
#[serde(rename = "Key")]
#[serde(skip_serializing_if = "Option::is_none")]
pub key: Option<String>,
#[serde(rename = "LastModifiedBy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_modified_by: Option<String>,
#[serde(rename = "LastModifiedDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_modified_date: Option<f64>,
#[serde(rename = "SyncCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sync_count: Option<i64>,
#[serde(rename = "Value")]
#[serde(skip_serializing_if = "Option::is_none")]
pub value: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct RecordPatch {
#[serde(rename = "DeviceLastModifiedDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub device_last_modified_date: Option<f64>,
#[serde(rename = "Key")]
pub key: String,
#[serde(rename = "Op")]
pub op: String,
#[serde(rename = "SyncCount")]
pub sync_count: i64,
#[serde(rename = "Value")]
#[serde(skip_serializing_if = "Option::is_none")]
pub value: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct RegisterDeviceRequest {
#[serde(rename = "IdentityId")]
pub identity_id: String,
#[serde(rename = "IdentityPoolId")]
pub identity_pool_id: String,
#[serde(rename = "Platform")]
pub platform: String,
#[serde(rename = "Token")]
pub token: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RegisterDeviceResponse {
#[serde(rename = "DeviceId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub device_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct SetCognitoEventsRequest {
#[serde(rename = "Events")]
pub events: ::std::collections::HashMap<String, String>,
#[serde(rename = "IdentityPoolId")]
pub identity_pool_id: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct SetIdentityPoolConfigurationRequest {
#[serde(rename = "CognitoStreams")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cognito_streams: Option<CognitoStreams>,
#[serde(rename = "IdentityPoolId")]
pub identity_pool_id: String,
#[serde(rename = "PushSync")]
#[serde(skip_serializing_if = "Option::is_none")]
pub push_sync: Option<PushSync>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct SetIdentityPoolConfigurationResponse {
#[serde(rename = "CognitoStreams")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cognito_streams: Option<CognitoStreams>,
#[serde(rename = "IdentityPoolId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub identity_pool_id: Option<String>,
#[serde(rename = "PushSync")]
#[serde(skip_serializing_if = "Option::is_none")]
pub push_sync: Option<PushSync>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct SubscribeToDatasetRequest {
#[serde(rename = "DatasetName")]
pub dataset_name: String,
#[serde(rename = "DeviceId")]
pub device_id: String,
#[serde(rename = "IdentityId")]
pub identity_id: String,
#[serde(rename = "IdentityPoolId")]
pub identity_pool_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct SubscribeToDatasetResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UnsubscribeFromDatasetRequest {
#[serde(rename = "DatasetName")]
pub dataset_name: String,
#[serde(rename = "DeviceId")]
pub device_id: String,
#[serde(rename = "IdentityId")]
pub identity_id: String,
#[serde(rename = "IdentityPoolId")]
pub identity_pool_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UnsubscribeFromDatasetResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateRecordsRequest {
#[serde(rename = "ClientContext")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_context: Option<String>,
#[serde(rename = "DatasetName")]
pub dataset_name: String,
#[serde(rename = "DeviceId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub device_id: Option<String>,
#[serde(rename = "IdentityId")]
pub identity_id: String,
#[serde(rename = "IdentityPoolId")]
pub identity_pool_id: String,
#[serde(rename = "RecordPatches")]
#[serde(skip_serializing_if = "Option::is_none")]
pub record_patches: Option<Vec<RecordPatch>>,
#[serde(rename = "SyncSessionToken")]
pub sync_session_token: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateRecordsResponse {
#[serde(rename = "Records")]
#[serde(skip_serializing_if = "Option::is_none")]
pub records: Option<Vec<Record>>,
}
#[derive(Debug, PartialEq)]
pub enum BulkPublishError {
AlreadyStreamed(String),
DuplicateRequest(String),
InternalError(String),
InvalidParameter(String),
NotAuthorized(String),
ResourceNotFound(String),
}
impl BulkPublishError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<BulkPublishError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AlreadyStreamedException" => {
return RusotoError::Service(BulkPublishError::AlreadyStreamed(err.msg))
}
"DuplicateRequestException" => {
return RusotoError::Service(BulkPublishError::DuplicateRequest(err.msg))
}
"InternalErrorException" => {
return RusotoError::Service(BulkPublishError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(BulkPublishError::InvalidParameter(err.msg))
}
"NotAuthorizedException" => {
return RusotoError::Service(BulkPublishError::NotAuthorized(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(BulkPublishError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for BulkPublishError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
BulkPublishError::AlreadyStreamed(ref cause) => write!(f, "{}", cause),
BulkPublishError::DuplicateRequest(ref cause) => write!(f, "{}", cause),
BulkPublishError::InternalError(ref cause) => write!(f, "{}", cause),
BulkPublishError::InvalidParameter(ref cause) => write!(f, "{}", cause),
BulkPublishError::NotAuthorized(ref cause) => write!(f, "{}", cause),
BulkPublishError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for BulkPublishError {}
#[derive(Debug, PartialEq)]
pub enum DeleteDatasetError {
InternalError(String),
InvalidParameter(String),
NotAuthorized(String),
ResourceConflict(String),
ResourceNotFound(String),
TooManyRequests(String),
}
impl DeleteDatasetError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteDatasetError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(DeleteDatasetError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(DeleteDatasetError::InvalidParameter(err.msg))
}
"NotAuthorizedException" => {
return RusotoError::Service(DeleteDatasetError::NotAuthorized(err.msg))
}
"ResourceConflictException" => {
return RusotoError::Service(DeleteDatasetError::ResourceConflict(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DeleteDatasetError::ResourceNotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(DeleteDatasetError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteDatasetError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteDatasetError::InternalError(ref cause) => write!(f, "{}", cause),
DeleteDatasetError::InvalidParameter(ref cause) => write!(f, "{}", cause),
DeleteDatasetError::NotAuthorized(ref cause) => write!(f, "{}", cause),
DeleteDatasetError::ResourceConflict(ref cause) => write!(f, "{}", cause),
DeleteDatasetError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DeleteDatasetError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteDatasetError {}
#[derive(Debug, PartialEq)]
pub enum DescribeDatasetError {
InternalError(String),
InvalidParameter(String),
NotAuthorized(String),
ResourceNotFound(String),
TooManyRequests(String),
}
impl DescribeDatasetError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeDatasetError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(DescribeDatasetError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(DescribeDatasetError::InvalidParameter(err.msg))
}
"NotAuthorizedException" => {
return RusotoError::Service(DescribeDatasetError::NotAuthorized(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeDatasetError::ResourceNotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(DescribeDatasetError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeDatasetError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeDatasetError::InternalError(ref cause) => write!(f, "{}", cause),
DescribeDatasetError::InvalidParameter(ref cause) => write!(f, "{}", cause),
DescribeDatasetError::NotAuthorized(ref cause) => write!(f, "{}", cause),
DescribeDatasetError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DescribeDatasetError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeDatasetError {}
#[derive(Debug, PartialEq)]
pub enum DescribeIdentityPoolUsageError {
InternalError(String),
InvalidParameter(String),
NotAuthorized(String),
ResourceNotFound(String),
TooManyRequests(String),
}
impl DescribeIdentityPoolUsageError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeIdentityPoolUsageError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(DescribeIdentityPoolUsageError::InternalError(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(DescribeIdentityPoolUsageError::InvalidParameter(
err.msg,
))
}
"NotAuthorizedException" => {
return RusotoError::Service(DescribeIdentityPoolUsageError::NotAuthorized(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeIdentityPoolUsageError::ResourceNotFound(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(DescribeIdentityPoolUsageError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeIdentityPoolUsageError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeIdentityPoolUsageError::InternalError(ref cause) => write!(f, "{}", cause),
DescribeIdentityPoolUsageError::InvalidParameter(ref cause) => write!(f, "{}", cause),
DescribeIdentityPoolUsageError::NotAuthorized(ref cause) => write!(f, "{}", cause),
DescribeIdentityPoolUsageError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DescribeIdentityPoolUsageError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeIdentityPoolUsageError {}
#[derive(Debug, PartialEq)]
pub enum DescribeIdentityUsageError {
InternalError(String),
InvalidParameter(String),
NotAuthorized(String),
ResourceNotFound(String),
TooManyRequests(String),
}
impl DescribeIdentityUsageError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeIdentityUsageError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(DescribeIdentityUsageError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(DescribeIdentityUsageError::InvalidParameter(
err.msg,
))
}
"NotAuthorizedException" => {
return RusotoError::Service(DescribeIdentityUsageError::NotAuthorized(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeIdentityUsageError::ResourceNotFound(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(DescribeIdentityUsageError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeIdentityUsageError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeIdentityUsageError::InternalError(ref cause) => write!(f, "{}", cause),
DescribeIdentityUsageError::InvalidParameter(ref cause) => write!(f, "{}", cause),
DescribeIdentityUsageError::NotAuthorized(ref cause) => write!(f, "{}", cause),
DescribeIdentityUsageError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DescribeIdentityUsageError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeIdentityUsageError {}
#[derive(Debug, PartialEq)]
pub enum GetBulkPublishDetailsError {
InternalError(String),
InvalidParameter(String),
NotAuthorized(String),
ResourceNotFound(String),
}
impl GetBulkPublishDetailsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetBulkPublishDetailsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(GetBulkPublishDetailsError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(GetBulkPublishDetailsError::InvalidParameter(
err.msg,
))
}
"NotAuthorizedException" => {
return RusotoError::Service(GetBulkPublishDetailsError::NotAuthorized(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(GetBulkPublishDetailsError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetBulkPublishDetailsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetBulkPublishDetailsError::InternalError(ref cause) => write!(f, "{}", cause),
GetBulkPublishDetailsError::InvalidParameter(ref cause) => write!(f, "{}", cause),
GetBulkPublishDetailsError::NotAuthorized(ref cause) => write!(f, "{}", cause),
GetBulkPublishDetailsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetBulkPublishDetailsError {}
#[derive(Debug, PartialEq)]
pub enum GetCognitoEventsError {
InternalError(String),
InvalidParameter(String),
NotAuthorized(String),
ResourceNotFound(String),
TooManyRequests(String),
}
impl GetCognitoEventsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetCognitoEventsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(GetCognitoEventsError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(GetCognitoEventsError::InvalidParameter(err.msg))
}
"NotAuthorizedException" => {
return RusotoError::Service(GetCognitoEventsError::NotAuthorized(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(GetCognitoEventsError::ResourceNotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(GetCognitoEventsError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetCognitoEventsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetCognitoEventsError::InternalError(ref cause) => write!(f, "{}", cause),
GetCognitoEventsError::InvalidParameter(ref cause) => write!(f, "{}", cause),
GetCognitoEventsError::NotAuthorized(ref cause) => write!(f, "{}", cause),
GetCognitoEventsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
GetCognitoEventsError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetCognitoEventsError {}
#[derive(Debug, PartialEq)]
pub enum GetIdentityPoolConfigurationError {
InternalError(String),
InvalidParameter(String),
NotAuthorized(String),
ResourceNotFound(String),
TooManyRequests(String),
}
impl GetIdentityPoolConfigurationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetIdentityPoolConfigurationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(GetIdentityPoolConfigurationError::InternalError(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(
GetIdentityPoolConfigurationError::InvalidParameter(err.msg),
)
}
"NotAuthorizedException" => {
return RusotoError::Service(GetIdentityPoolConfigurationError::NotAuthorized(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(
GetIdentityPoolConfigurationError::ResourceNotFound(err.msg),
)
}
"TooManyRequestsException" => {
return RusotoError::Service(
GetIdentityPoolConfigurationError::TooManyRequests(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetIdentityPoolConfigurationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetIdentityPoolConfigurationError::InternalError(ref cause) => write!(f, "{}", cause),
GetIdentityPoolConfigurationError::InvalidParameter(ref cause) => {
write!(f, "{}", cause)
}
GetIdentityPoolConfigurationError::NotAuthorized(ref cause) => write!(f, "{}", cause),
GetIdentityPoolConfigurationError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
GetIdentityPoolConfigurationError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetIdentityPoolConfigurationError {}
#[derive(Debug, PartialEq)]
pub enum ListDatasetsError {
InternalError(String),
InvalidParameter(String),
NotAuthorized(String),
TooManyRequests(String),
}
impl ListDatasetsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListDatasetsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(ListDatasetsError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(ListDatasetsError::InvalidParameter(err.msg))
}
"NotAuthorizedException" => {
return RusotoError::Service(ListDatasetsError::NotAuthorized(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(ListDatasetsError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListDatasetsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListDatasetsError::InternalError(ref cause) => write!(f, "{}", cause),
ListDatasetsError::InvalidParameter(ref cause) => write!(f, "{}", cause),
ListDatasetsError::NotAuthorized(ref cause) => write!(f, "{}", cause),
ListDatasetsError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListDatasetsError {}
#[derive(Debug, PartialEq)]
pub enum ListIdentityPoolUsageError {
InternalError(String),
InvalidParameter(String),
NotAuthorized(String),
TooManyRequests(String),
}
impl ListIdentityPoolUsageError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListIdentityPoolUsageError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(ListIdentityPoolUsageError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(ListIdentityPoolUsageError::InvalidParameter(
err.msg,
))
}
"NotAuthorizedException" => {
return RusotoError::Service(ListIdentityPoolUsageError::NotAuthorized(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(ListIdentityPoolUsageError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListIdentityPoolUsageError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListIdentityPoolUsageError::InternalError(ref cause) => write!(f, "{}", cause),
ListIdentityPoolUsageError::InvalidParameter(ref cause) => write!(f, "{}", cause),
ListIdentityPoolUsageError::NotAuthorized(ref cause) => write!(f, "{}", cause),
ListIdentityPoolUsageError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListIdentityPoolUsageError {}
#[derive(Debug, PartialEq)]
pub enum ListRecordsError {
InternalError(String),
InvalidParameter(String),
NotAuthorized(String),
TooManyRequests(String),
}
impl ListRecordsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListRecordsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(ListRecordsError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(ListRecordsError::InvalidParameter(err.msg))
}
"NotAuthorizedException" => {
return RusotoError::Service(ListRecordsError::NotAuthorized(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(ListRecordsError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListRecordsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListRecordsError::InternalError(ref cause) => write!(f, "{}", cause),
ListRecordsError::InvalidParameter(ref cause) => write!(f, "{}", cause),
ListRecordsError::NotAuthorized(ref cause) => write!(f, "{}", cause),
ListRecordsError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListRecordsError {}
#[derive(Debug, PartialEq)]
pub enum RegisterDeviceError {
InternalError(String),
InvalidConfiguration(String),
InvalidParameter(String),
NotAuthorized(String),
ResourceNotFound(String),
TooManyRequests(String),
}
impl RegisterDeviceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<RegisterDeviceError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(RegisterDeviceError::InternalError(err.msg))
}
"InvalidConfigurationException" => {
return RusotoError::Service(RegisterDeviceError::InvalidConfiguration(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(RegisterDeviceError::InvalidParameter(err.msg))
}
"NotAuthorizedException" => {
return RusotoError::Service(RegisterDeviceError::NotAuthorized(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(RegisterDeviceError::ResourceNotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(RegisterDeviceError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for RegisterDeviceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
RegisterDeviceError::InternalError(ref cause) => write!(f, "{}", cause),
RegisterDeviceError::InvalidConfiguration(ref cause) => write!(f, "{}", cause),
RegisterDeviceError::InvalidParameter(ref cause) => write!(f, "{}", cause),
RegisterDeviceError::NotAuthorized(ref cause) => write!(f, "{}", cause),
RegisterDeviceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
RegisterDeviceError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for RegisterDeviceError {}
#[derive(Debug, PartialEq)]
pub enum SetCognitoEventsError {
InternalError(String),
InvalidParameter(String),
NotAuthorized(String),
ResourceNotFound(String),
TooManyRequests(String),
}
impl SetCognitoEventsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<SetCognitoEventsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(SetCognitoEventsError::InternalError(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(SetCognitoEventsError::InvalidParameter(err.msg))
}
"NotAuthorizedException" => {
return RusotoError::Service(SetCognitoEventsError::NotAuthorized(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(SetCognitoEventsError::ResourceNotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(SetCognitoEventsError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for SetCognitoEventsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
SetCognitoEventsError::InternalError(ref cause) => write!(f, "{}", cause),
SetCognitoEventsError::InvalidParameter(ref cause) => write!(f, "{}", cause),
SetCognitoEventsError::NotAuthorized(ref cause) => write!(f, "{}", cause),
SetCognitoEventsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
SetCognitoEventsError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for SetCognitoEventsError {}
#[derive(Debug, PartialEq)]
pub enum SetIdentityPoolConfigurationError {
ConcurrentModification(String),
InternalError(String),
InvalidParameter(String),
NotAuthorized(String),
ResourceNotFound(String),
TooManyRequests(String),
}
impl SetIdentityPoolConfigurationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<SetIdentityPoolConfigurationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"ConcurrentModificationException" => {
return RusotoError::Service(
SetIdentityPoolConfigurationError::ConcurrentModification(err.msg),
)
}
"InternalErrorException" => {
return RusotoError::Service(SetIdentityPoolConfigurationError::InternalError(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(
SetIdentityPoolConfigurationError::InvalidParameter(err.msg),
)
}
"NotAuthorizedException" => {
return RusotoError::Service(SetIdentityPoolConfigurationError::NotAuthorized(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(
SetIdentityPoolConfigurationError::ResourceNotFound(err.msg),
)
}
"TooManyRequestsException" => {
return RusotoError::Service(
SetIdentityPoolConfigurationError::TooManyRequests(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for SetIdentityPoolConfigurationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
SetIdentityPoolConfigurationError::ConcurrentModification(ref cause) => {
write!(f, "{}", cause)
}
SetIdentityPoolConfigurationError::InternalError(ref cause) => write!(f, "{}", cause),
SetIdentityPoolConfigurationError::InvalidParameter(ref cause) => {
write!(f, "{}", cause)
}
SetIdentityPoolConfigurationError::NotAuthorized(ref cause) => write!(f, "{}", cause),
SetIdentityPoolConfigurationError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
SetIdentityPoolConfigurationError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for SetIdentityPoolConfigurationError {}
#[derive(Debug, PartialEq)]
pub enum SubscribeToDatasetError {
InternalError(String),
InvalidConfiguration(String),
InvalidParameter(String),
NotAuthorized(String),
ResourceNotFound(String),
TooManyRequests(String),
}
impl SubscribeToDatasetError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<SubscribeToDatasetError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(SubscribeToDatasetError::InternalError(err.msg))
}
"InvalidConfigurationException" => {
return RusotoError::Service(SubscribeToDatasetError::InvalidConfiguration(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(SubscribeToDatasetError::InvalidParameter(err.msg))
}
"NotAuthorizedException" => {
return RusotoError::Service(SubscribeToDatasetError::NotAuthorized(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(SubscribeToDatasetError::ResourceNotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(SubscribeToDatasetError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for SubscribeToDatasetError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
SubscribeToDatasetError::InternalError(ref cause) => write!(f, "{}", cause),
SubscribeToDatasetError::InvalidConfiguration(ref cause) => write!(f, "{}", cause),
SubscribeToDatasetError::InvalidParameter(ref cause) => write!(f, "{}", cause),
SubscribeToDatasetError::NotAuthorized(ref cause) => write!(f, "{}", cause),
SubscribeToDatasetError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
SubscribeToDatasetError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for SubscribeToDatasetError {}
#[derive(Debug, PartialEq)]
pub enum UnsubscribeFromDatasetError {
InternalError(String),
InvalidConfiguration(String),
InvalidParameter(String),
NotAuthorized(String),
ResourceNotFound(String),
TooManyRequests(String),
}
impl UnsubscribeFromDatasetError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UnsubscribeFromDatasetError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(UnsubscribeFromDatasetError::InternalError(
err.msg,
))
}
"InvalidConfigurationException" => {
return RusotoError::Service(UnsubscribeFromDatasetError::InvalidConfiguration(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(UnsubscribeFromDatasetError::InvalidParameter(
err.msg,
))
}
"NotAuthorizedException" => {
return RusotoError::Service(UnsubscribeFromDatasetError::NotAuthorized(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UnsubscribeFromDatasetError::ResourceNotFound(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(UnsubscribeFromDatasetError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UnsubscribeFromDatasetError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UnsubscribeFromDatasetError::InternalError(ref cause) => write!(f, "{}", cause),
UnsubscribeFromDatasetError::InvalidConfiguration(ref cause) => write!(f, "{}", cause),
UnsubscribeFromDatasetError::InvalidParameter(ref cause) => write!(f, "{}", cause),
UnsubscribeFromDatasetError::NotAuthorized(ref cause) => write!(f, "{}", cause),
UnsubscribeFromDatasetError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
UnsubscribeFromDatasetError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UnsubscribeFromDatasetError {}
#[derive(Debug, PartialEq)]
pub enum UpdateRecordsError {
InternalError(String),
InvalidLambdaFunctionOutput(String),
InvalidParameter(String),
LambdaThrottled(String),
LimitExceeded(String),
NotAuthorized(String),
ResourceConflict(String),
ResourceNotFound(String),
TooManyRequests(String),
}
impl UpdateRecordsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateRecordsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalErrorException" => {
return RusotoError::Service(UpdateRecordsError::InternalError(err.msg))
}
"InvalidLambdaFunctionOutputException" => {
return RusotoError::Service(UpdateRecordsError::InvalidLambdaFunctionOutput(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(UpdateRecordsError::InvalidParameter(err.msg))
}
"LambdaThrottledException" => {
return RusotoError::Service(UpdateRecordsError::LambdaThrottled(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(UpdateRecordsError::LimitExceeded(err.msg))
}
"NotAuthorizedException" => {
return RusotoError::Service(UpdateRecordsError::NotAuthorized(err.msg))
}
"ResourceConflictException" => {
return RusotoError::Service(UpdateRecordsError::ResourceConflict(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UpdateRecordsError::ResourceNotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(UpdateRecordsError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateRecordsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateRecordsError::InternalError(ref cause) => write!(f, "{}", cause),
UpdateRecordsError::InvalidLambdaFunctionOutput(ref cause) => write!(f, "{}", cause),
UpdateRecordsError::InvalidParameter(ref cause) => write!(f, "{}", cause),
UpdateRecordsError::LambdaThrottled(ref cause) => write!(f, "{}", cause),
UpdateRecordsError::LimitExceeded(ref cause) => write!(f, "{}", cause),
UpdateRecordsError::NotAuthorized(ref cause) => write!(f, "{}", cause),
UpdateRecordsError::ResourceConflict(ref cause) => write!(f, "{}", cause),
UpdateRecordsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
UpdateRecordsError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateRecordsError {}
#[async_trait]
pub trait CognitoSync {
async fn bulk_publish(
&self,
input: BulkPublishRequest,
) -> Result<BulkPublishResponse, RusotoError<BulkPublishError>>;
async fn delete_dataset(
&self,
input: DeleteDatasetRequest,
) -> Result<DeleteDatasetResponse, RusotoError<DeleteDatasetError>>;
async fn describe_dataset(
&self,
input: DescribeDatasetRequest,
) -> Result<DescribeDatasetResponse, RusotoError<DescribeDatasetError>>;
async fn describe_identity_pool_usage(
&self,
input: DescribeIdentityPoolUsageRequest,
) -> Result<DescribeIdentityPoolUsageResponse, RusotoError<DescribeIdentityPoolUsageError>>;
async fn describe_identity_usage(
&self,
input: DescribeIdentityUsageRequest,
) -> Result<DescribeIdentityUsageResponse, RusotoError<DescribeIdentityUsageError>>;
async fn get_bulk_publish_details(
&self,
input: GetBulkPublishDetailsRequest,
) -> Result<GetBulkPublishDetailsResponse, RusotoError<GetBulkPublishDetailsError>>;
async fn get_cognito_events(
&self,
input: GetCognitoEventsRequest,
) -> Result<GetCognitoEventsResponse, RusotoError<GetCognitoEventsError>>;
async fn get_identity_pool_configuration(
&self,
input: GetIdentityPoolConfigurationRequest,
) -> Result<GetIdentityPoolConfigurationResponse, RusotoError<GetIdentityPoolConfigurationError>>;
async fn list_datasets(
&self,
input: ListDatasetsRequest,
) -> Result<ListDatasetsResponse, RusotoError<ListDatasetsError>>;
async fn list_identity_pool_usage(
&self,
input: ListIdentityPoolUsageRequest,
) -> Result<ListIdentityPoolUsageResponse, RusotoError<ListIdentityPoolUsageError>>;
async fn list_records(
&self,
input: ListRecordsRequest,
) -> Result<ListRecordsResponse, RusotoError<ListRecordsError>>;
async fn register_device(
&self,
input: RegisterDeviceRequest,
) -> Result<RegisterDeviceResponse, RusotoError<RegisterDeviceError>>;
async fn set_cognito_events(
&self,
input: SetCognitoEventsRequest,
) -> Result<(), RusotoError<SetCognitoEventsError>>;
async fn set_identity_pool_configuration(
&self,
input: SetIdentityPoolConfigurationRequest,
) -> Result<SetIdentityPoolConfigurationResponse, RusotoError<SetIdentityPoolConfigurationError>>;
async fn subscribe_to_dataset(
&self,
input: SubscribeToDatasetRequest,
) -> Result<SubscribeToDatasetResponse, RusotoError<SubscribeToDatasetError>>;
async fn unsubscribe_from_dataset(
&self,
input: UnsubscribeFromDatasetRequest,
) -> Result<UnsubscribeFromDatasetResponse, RusotoError<UnsubscribeFromDatasetError>>;
async fn update_records(
&self,
input: UpdateRecordsRequest,
) -> Result<UpdateRecordsResponse, RusotoError<UpdateRecordsError>>;
}
#[derive(Clone)]
pub struct CognitoSyncClient {
client: Client,
region: region::Region,
}
impl CognitoSyncClient {
pub fn new(region: region::Region) -> CognitoSyncClient {
CognitoSyncClient {
client: Client::shared(),
region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> CognitoSyncClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
D: DispatchSignedRequest + Send + Sync + 'static,
{
CognitoSyncClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region,
}
}
pub fn new_with_client(client: Client, region: region::Region) -> CognitoSyncClient {
CognitoSyncClient { client, region }
}
}
#[async_trait]
impl CognitoSync for CognitoSyncClient {
#[allow(unused_mut)]
async fn bulk_publish(
&self,
input: BulkPublishRequest,
) -> Result<BulkPublishResponse, RusotoError<BulkPublishError>> {
let request_uri = format!(
"/identitypools/{identity_pool_id}/bulkpublish",
identity_pool_id = input.identity_pool_id
);
let mut request = SignedRequest::new("POST", "cognito-sync", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<BulkPublishResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(BulkPublishError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_dataset(
&self,
input: DeleteDatasetRequest,
) -> Result<DeleteDatasetResponse, RusotoError<DeleteDatasetError>> {
let request_uri = format!(
"/identitypools/{identity_pool_id}/identities/{identity_id}/datasets/{dataset_name}",
dataset_name = input.dataset_name,
identity_id = input.identity_id,
identity_pool_id = input.identity_pool_id
);
let mut request = SignedRequest::new("DELETE", "cognito-sync", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteDatasetResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteDatasetError::from_response(response))
}
}
#[allow(unused_mut)]
async fn describe_dataset(
&self,
input: DescribeDatasetRequest,
) -> Result<DescribeDatasetResponse, RusotoError<DescribeDatasetError>> {
let request_uri = format!(
"/identitypools/{identity_pool_id}/identities/{identity_id}/datasets/{dataset_name}",
dataset_name = input.dataset_name,
identity_id = input.identity_id,
identity_pool_id = input.identity_pool_id
);
let mut request = SignedRequest::new("GET", "cognito-sync", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeDatasetResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DescribeDatasetError::from_response(response))
}
}
#[allow(unused_mut)]
async fn describe_identity_pool_usage(
&self,
input: DescribeIdentityPoolUsageRequest,
) -> Result<DescribeIdentityPoolUsageResponse, RusotoError<DescribeIdentityPoolUsageError>>
{
let request_uri = format!(
"/identitypools/{identity_pool_id}",
identity_pool_id = input.identity_pool_id
);
let mut request = SignedRequest::new("GET", "cognito-sync", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeIdentityPoolUsageResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DescribeIdentityPoolUsageError::from_response(response))
}
}
#[allow(unused_mut)]
async fn describe_identity_usage(
&self,
input: DescribeIdentityUsageRequest,
) -> Result<DescribeIdentityUsageResponse, RusotoError<DescribeIdentityUsageError>> {
let request_uri = format!(
"/identitypools/{identity_pool_id}/identities/{identity_id}",
identity_id = input.identity_id,
identity_pool_id = input.identity_pool_id
);
let mut request = SignedRequest::new("GET", "cognito-sync", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeIdentityUsageResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DescribeIdentityUsageError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_bulk_publish_details(
&self,
input: GetBulkPublishDetailsRequest,
) -> Result<GetBulkPublishDetailsResponse, RusotoError<GetBulkPublishDetailsError>> {
let request_uri = format!(
"/identitypools/{identity_pool_id}/getBulkPublishDetails",
identity_pool_id = input.identity_pool_id
);
let mut request = SignedRequest::new("POST", "cognito-sync", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetBulkPublishDetailsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetBulkPublishDetailsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_cognito_events(
&self,
input: GetCognitoEventsRequest,
) -> Result<GetCognitoEventsResponse, RusotoError<GetCognitoEventsError>> {
let request_uri = format!(
"/identitypools/{identity_pool_id}/events",
identity_pool_id = input.identity_pool_id
);
let mut request = SignedRequest::new("GET", "cognito-sync", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetCognitoEventsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetCognitoEventsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_identity_pool_configuration(
&self,
input: GetIdentityPoolConfigurationRequest,
) -> Result<GetIdentityPoolConfigurationResponse, RusotoError<GetIdentityPoolConfigurationError>>
{
let request_uri = format!(
"/identitypools/{identity_pool_id}/configuration",
identity_pool_id = input.identity_pool_id
);
let mut request = SignedRequest::new("GET", "cognito-sync", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetIdentityPoolConfigurationResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetIdentityPoolConfigurationError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_datasets(
&self,
input: ListDatasetsRequest,
) -> Result<ListDatasetsResponse, RusotoError<ListDatasetsError>> {
let request_uri = format!(
"/identitypools/{identity_pool_id}/identities/{identity_id}/datasets",
identity_id = input.identity_id,
identity_pool_id = input.identity_pool_id
);
let mut request = SignedRequest::new("GET", "cognito-sync", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("maxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("nextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListDatasetsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListDatasetsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_identity_pool_usage(
&self,
input: ListIdentityPoolUsageRequest,
) -> Result<ListIdentityPoolUsageResponse, RusotoError<ListIdentityPoolUsageError>> {
let request_uri = "/identitypools";
let mut request = SignedRequest::new("GET", "cognito-sync", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("maxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("nextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListIdentityPoolUsageResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListIdentityPoolUsageError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_records(
&self,
input: ListRecordsRequest,
) -> Result<ListRecordsResponse, RusotoError<ListRecordsError>> {
let request_uri = format!("/identitypools/{identity_pool_id}/identities/{identity_id}/datasets/{dataset_name}/records", dataset_name = input.dataset_name, identity_id = input.identity_id, identity_pool_id = input.identity_pool_id);
let mut request = SignedRequest::new("GET", "cognito-sync", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.last_sync_count {
params.put("lastSyncCount", x);
}
if let Some(ref x) = input.max_results {
params.put("maxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("nextToken", x);
}
if let Some(ref x) = input.sync_session_token {
params.put("syncSessionToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListRecordsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListRecordsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn register_device(
&self,
input: RegisterDeviceRequest,
) -> Result<RegisterDeviceResponse, RusotoError<RegisterDeviceError>> {
let request_uri = format!(
"/identitypools/{identity_pool_id}/identity/{identity_id}/device",
identity_id = input.identity_id,
identity_pool_id = input.identity_pool_id
);
let mut request = SignedRequest::new("POST", "cognito-sync", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<RegisterDeviceResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(RegisterDeviceError::from_response(response))
}
}
#[allow(unused_mut)]
async fn set_cognito_events(
&self,
input: SetCognitoEventsRequest,
) -> Result<(), RusotoError<SetCognitoEventsError>> {
let request_uri = format!(
"/identitypools/{identity_pool_id}/events",
identity_pool_id = input.identity_pool_id
);
let mut request = SignedRequest::new("POST", "cognito-sync", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = ::std::mem::drop(response);
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(SetCognitoEventsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn set_identity_pool_configuration(
&self,
input: SetIdentityPoolConfigurationRequest,
) -> Result<SetIdentityPoolConfigurationResponse, RusotoError<SetIdentityPoolConfigurationError>>
{
let request_uri = format!(
"/identitypools/{identity_pool_id}/configuration",
identity_pool_id = input.identity_pool_id
);
let mut request = SignedRequest::new("POST", "cognito-sync", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<SetIdentityPoolConfigurationResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(SetIdentityPoolConfigurationError::from_response(response))
}
}
#[allow(unused_mut)]
async fn subscribe_to_dataset(
&self,
input: SubscribeToDatasetRequest,
) -> Result<SubscribeToDatasetResponse, RusotoError<SubscribeToDatasetError>> {
let request_uri = format!("/identitypools/{identity_pool_id}/identities/{identity_id}/datasets/{dataset_name}/subscriptions/{device_id}", dataset_name = input.dataset_name, device_id = input.device_id, identity_id = input.identity_id, identity_pool_id = input.identity_pool_id);
let mut request = SignedRequest::new("POST", "cognito-sync", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<SubscribeToDatasetResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(SubscribeToDatasetError::from_response(response))
}
}
#[allow(unused_mut)]
async fn unsubscribe_from_dataset(
&self,
input: UnsubscribeFromDatasetRequest,
) -> Result<UnsubscribeFromDatasetResponse, RusotoError<UnsubscribeFromDatasetError>> {
let request_uri = format!("/identitypools/{identity_pool_id}/identities/{identity_id}/datasets/{dataset_name}/subscriptions/{device_id}", dataset_name = input.dataset_name, device_id = input.device_id, identity_id = input.identity_id, identity_pool_id = input.identity_pool_id);
let mut request = SignedRequest::new("DELETE", "cognito-sync", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UnsubscribeFromDatasetResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UnsubscribeFromDatasetError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_records(
&self,
input: UpdateRecordsRequest,
) -> Result<UpdateRecordsResponse, RusotoError<UpdateRecordsError>> {
let request_uri = format!(
"/identitypools/{identity_pool_id}/identities/{identity_id}/datasets/{dataset_name}",
dataset_name = input.dataset_name,
identity_id = input.identity_id,
identity_pool_id = input.identity_pool_id
);
let mut request = SignedRequest::new("POST", "cognito-sync", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
request.add_optional_header("x-amz-Client-Context", input.client_context.as_ref());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateRecordsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateRecordsError::from_response(response))
}
}
}