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::signature::SignedRequest;
#[allow(unused_imports)]
use serde::{Deserialize, Serialize};
use serde_json;
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AcceptQualificationRequestRequest {
#[serde(rename = "IntegerValue")]
#[serde(skip_serializing_if = "Option::is_none")]
pub integer_value: Option<i64>,
#[serde(rename = "QualificationRequestId")]
pub qualification_request_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AcceptQualificationRequestResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ApproveAssignmentRequest {
#[serde(rename = "AssignmentId")]
pub assignment_id: String,
#[serde(rename = "OverrideRejection")]
#[serde(skip_serializing_if = "Option::is_none")]
pub override_rejection: Option<bool>,
#[serde(rename = "RequesterFeedback")]
#[serde(skip_serializing_if = "Option::is_none")]
pub requester_feedback: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ApproveAssignmentResponse {}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Assignment {
#[serde(rename = "AcceptTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accept_time: Option<f64>,
#[serde(rename = "Answer")]
#[serde(skip_serializing_if = "Option::is_none")]
pub answer: Option<String>,
#[serde(rename = "ApprovalTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub approval_time: Option<f64>,
#[serde(rename = "AssignmentId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub assignment_id: Option<String>,
#[serde(rename = "AssignmentStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub assignment_status: Option<String>,
#[serde(rename = "AutoApprovalTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_approval_time: Option<f64>,
#[serde(rename = "Deadline")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deadline: Option<f64>,
#[serde(rename = "HITId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hit_id: Option<String>,
#[serde(rename = "RejectionTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub rejection_time: Option<f64>,
#[serde(rename = "RequesterFeedback")]
#[serde(skip_serializing_if = "Option::is_none")]
pub requester_feedback: Option<String>,
#[serde(rename = "SubmitTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub submit_time: Option<f64>,
#[serde(rename = "WorkerId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub worker_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AssociateQualificationWithWorkerRequest {
#[serde(rename = "IntegerValue")]
#[serde(skip_serializing_if = "Option::is_none")]
pub integer_value: Option<i64>,
#[serde(rename = "QualificationTypeId")]
pub qualification_type_id: String,
#[serde(rename = "SendNotification")]
#[serde(skip_serializing_if = "Option::is_none")]
pub send_notification: Option<bool>,
#[serde(rename = "WorkerId")]
pub worker_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AssociateQualificationWithWorkerResponse {}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BonusPayment {
#[serde(rename = "AssignmentId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub assignment_id: Option<String>,
#[serde(rename = "BonusAmount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bonus_amount: Option<String>,
#[serde(rename = "GrantTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub grant_time: Option<f64>,
#[serde(rename = "Reason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub reason: Option<String>,
#[serde(rename = "WorkerId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub worker_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateAdditionalAssignmentsForHITRequest {
#[serde(rename = "HITId")]
pub hit_id: String,
#[serde(rename = "NumberOfAdditionalAssignments")]
pub number_of_additional_assignments: i64,
#[serde(rename = "UniqueRequestToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub unique_request_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateAdditionalAssignmentsForHITResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateHITRequest {
#[serde(rename = "AssignmentDurationInSeconds")]
pub assignment_duration_in_seconds: i64,
#[serde(rename = "AssignmentReviewPolicy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub assignment_review_policy: Option<ReviewPolicy>,
#[serde(rename = "AutoApprovalDelayInSeconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_approval_delay_in_seconds: Option<i64>,
#[serde(rename = "Description")]
pub description: String,
#[serde(rename = "HITLayoutId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hit_layout_id: Option<String>,
#[serde(rename = "HITLayoutParameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hit_layout_parameters: Option<Vec<HITLayoutParameter>>,
#[serde(rename = "HITReviewPolicy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hit_review_policy: Option<ReviewPolicy>,
#[serde(rename = "Keywords")]
#[serde(skip_serializing_if = "Option::is_none")]
pub keywords: Option<String>,
#[serde(rename = "LifetimeInSeconds")]
pub lifetime_in_seconds: i64,
#[serde(rename = "MaxAssignments")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_assignments: Option<i64>,
#[serde(rename = "QualificationRequirements")]
#[serde(skip_serializing_if = "Option::is_none")]
pub qualification_requirements: Option<Vec<QualificationRequirement>>,
#[serde(rename = "Question")]
#[serde(skip_serializing_if = "Option::is_none")]
pub question: Option<String>,
#[serde(rename = "RequesterAnnotation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub requester_annotation: Option<String>,
#[serde(rename = "Reward")]
pub reward: String,
#[serde(rename = "Title")]
pub title: String,
#[serde(rename = "UniqueRequestToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub unique_request_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateHITResponse {
#[serde(rename = "HIT")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hit: Option<HIT>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateHITTypeRequest {
#[serde(rename = "AssignmentDurationInSeconds")]
pub assignment_duration_in_seconds: i64,
#[serde(rename = "AutoApprovalDelayInSeconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_approval_delay_in_seconds: Option<i64>,
#[serde(rename = "Description")]
pub description: String,
#[serde(rename = "Keywords")]
#[serde(skip_serializing_if = "Option::is_none")]
pub keywords: Option<String>,
#[serde(rename = "QualificationRequirements")]
#[serde(skip_serializing_if = "Option::is_none")]
pub qualification_requirements: Option<Vec<QualificationRequirement>>,
#[serde(rename = "Reward")]
pub reward: String,
#[serde(rename = "Title")]
pub title: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateHITTypeResponse {
#[serde(rename = "HITTypeId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hit_type_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateHITWithHITTypeRequest {
#[serde(rename = "AssignmentReviewPolicy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub assignment_review_policy: Option<ReviewPolicy>,
#[serde(rename = "HITLayoutId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hit_layout_id: Option<String>,
#[serde(rename = "HITLayoutParameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hit_layout_parameters: Option<Vec<HITLayoutParameter>>,
#[serde(rename = "HITReviewPolicy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hit_review_policy: Option<ReviewPolicy>,
#[serde(rename = "HITTypeId")]
pub hit_type_id: String,
#[serde(rename = "LifetimeInSeconds")]
pub lifetime_in_seconds: i64,
#[serde(rename = "MaxAssignments")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_assignments: Option<i64>,
#[serde(rename = "Question")]
#[serde(skip_serializing_if = "Option::is_none")]
pub question: Option<String>,
#[serde(rename = "RequesterAnnotation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub requester_annotation: Option<String>,
#[serde(rename = "UniqueRequestToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub unique_request_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateHITWithHITTypeResponse {
#[serde(rename = "HIT")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hit: Option<HIT>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateQualificationTypeRequest {
#[serde(rename = "AnswerKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub answer_key: Option<String>,
#[serde(rename = "AutoGranted")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_granted: Option<bool>,
#[serde(rename = "AutoGrantedValue")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_granted_value: Option<i64>,
#[serde(rename = "Description")]
pub description: String,
#[serde(rename = "Keywords")]
#[serde(skip_serializing_if = "Option::is_none")]
pub keywords: Option<String>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "QualificationTypeStatus")]
pub qualification_type_status: String,
#[serde(rename = "RetryDelayInSeconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub retry_delay_in_seconds: Option<i64>,
#[serde(rename = "Test")]
#[serde(skip_serializing_if = "Option::is_none")]
pub test: Option<String>,
#[serde(rename = "TestDurationInSeconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub test_duration_in_seconds: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateQualificationTypeResponse {
#[serde(rename = "QualificationType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub qualification_type: Option<QualificationType>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateWorkerBlockRequest {
#[serde(rename = "Reason")]
pub reason: String,
#[serde(rename = "WorkerId")]
pub worker_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateWorkerBlockResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteHITRequest {
#[serde(rename = "HITId")]
pub hit_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteHITResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteQualificationTypeRequest {
#[serde(rename = "QualificationTypeId")]
pub qualification_type_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteQualificationTypeResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteWorkerBlockRequest {
#[serde(rename = "Reason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub reason: Option<String>,
#[serde(rename = "WorkerId")]
pub worker_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteWorkerBlockResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DisassociateQualificationFromWorkerRequest {
#[serde(rename = "QualificationTypeId")]
pub qualification_type_id: String,
#[serde(rename = "Reason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub reason: Option<String>,
#[serde(rename = "WorkerId")]
pub worker_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DisassociateQualificationFromWorkerResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetAccountBalanceRequest {}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetAccountBalanceResponse {
#[serde(rename = "AvailableBalance")]
#[serde(skip_serializing_if = "Option::is_none")]
pub available_balance: Option<String>,
#[serde(rename = "OnHoldBalance")]
#[serde(skip_serializing_if = "Option::is_none")]
pub on_hold_balance: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetAssignmentRequest {
#[serde(rename = "AssignmentId")]
pub assignment_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetAssignmentResponse {
#[serde(rename = "Assignment")]
#[serde(skip_serializing_if = "Option::is_none")]
pub assignment: Option<Assignment>,
#[serde(rename = "HIT")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hit: Option<HIT>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetFileUploadURLRequest {
#[serde(rename = "AssignmentId")]
pub assignment_id: String,
#[serde(rename = "QuestionIdentifier")]
pub question_identifier: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetFileUploadURLResponse {
#[serde(rename = "FileUploadURL")]
#[serde(skip_serializing_if = "Option::is_none")]
pub file_upload_url: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetHITRequest {
#[serde(rename = "HITId")]
pub hit_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetHITResponse {
#[serde(rename = "HIT")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hit: Option<HIT>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetQualificationScoreRequest {
#[serde(rename = "QualificationTypeId")]
pub qualification_type_id: String,
#[serde(rename = "WorkerId")]
pub worker_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetQualificationScoreResponse {
#[serde(rename = "Qualification")]
#[serde(skip_serializing_if = "Option::is_none")]
pub qualification: Option<Qualification>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetQualificationTypeRequest {
#[serde(rename = "QualificationTypeId")]
pub qualification_type_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetQualificationTypeResponse {
#[serde(rename = "QualificationType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub qualification_type: Option<QualificationType>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct HIT {
#[serde(rename = "AssignmentDurationInSeconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub assignment_duration_in_seconds: Option<i64>,
#[serde(rename = "AutoApprovalDelayInSeconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_approval_delay_in_seconds: Option<i64>,
#[serde(rename = "CreationTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_time: Option<f64>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "Expiration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub expiration: Option<f64>,
#[serde(rename = "HITGroupId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hit_group_id: Option<String>,
#[serde(rename = "HITId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hit_id: Option<String>,
#[serde(rename = "HITLayoutId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hit_layout_id: Option<String>,
#[serde(rename = "HITReviewStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hit_review_status: Option<String>,
#[serde(rename = "HITStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hit_status: Option<String>,
#[serde(rename = "HITTypeId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hit_type_id: Option<String>,
#[serde(rename = "Keywords")]
#[serde(skip_serializing_if = "Option::is_none")]
pub keywords: Option<String>,
#[serde(rename = "MaxAssignments")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_assignments: Option<i64>,
#[serde(rename = "NumberOfAssignmentsAvailable")]
#[serde(skip_serializing_if = "Option::is_none")]
pub number_of_assignments_available: Option<i64>,
#[serde(rename = "NumberOfAssignmentsCompleted")]
#[serde(skip_serializing_if = "Option::is_none")]
pub number_of_assignments_completed: Option<i64>,
#[serde(rename = "NumberOfAssignmentsPending")]
#[serde(skip_serializing_if = "Option::is_none")]
pub number_of_assignments_pending: Option<i64>,
#[serde(rename = "QualificationRequirements")]
#[serde(skip_serializing_if = "Option::is_none")]
pub qualification_requirements: Option<Vec<QualificationRequirement>>,
#[serde(rename = "Question")]
#[serde(skip_serializing_if = "Option::is_none")]
pub question: Option<String>,
#[serde(rename = "RequesterAnnotation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub requester_annotation: Option<String>,
#[serde(rename = "Reward")]
#[serde(skip_serializing_if = "Option::is_none")]
pub reward: Option<String>,
#[serde(rename = "Title")]
#[serde(skip_serializing_if = "Option::is_none")]
pub title: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct HITLayoutParameter {
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "Value")]
pub value: String,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListAssignmentsForHITRequest {
#[serde(rename = "AssignmentStatuses")]
#[serde(skip_serializing_if = "Option::is_none")]
pub assignment_statuses: Option<Vec<String>>,
#[serde(rename = "HITId")]
pub hit_id: String,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListAssignmentsForHITResponse {
#[serde(rename = "Assignments")]
#[serde(skip_serializing_if = "Option::is_none")]
pub assignments: Option<Vec<Assignment>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "NumResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub num_results: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListBonusPaymentsRequest {
#[serde(rename = "AssignmentId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub assignment_id: Option<String>,
#[serde(rename = "HITId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hit_id: Option<String>,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListBonusPaymentsResponse {
#[serde(rename = "BonusPayments")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bonus_payments: Option<Vec<BonusPayment>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "NumResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub num_results: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListHITsForQualificationTypeRequest {
#[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 = "QualificationTypeId")]
pub qualification_type_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListHITsForQualificationTypeResponse {
#[serde(rename = "HITs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hi_ts: Option<Vec<HIT>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "NumResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub num_results: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListHITsRequest {
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListHITsResponse {
#[serde(rename = "HITs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hi_ts: Option<Vec<HIT>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "NumResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub num_results: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListQualificationRequestsRequest {
#[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 = "QualificationTypeId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub qualification_type_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListQualificationRequestsResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "NumResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub num_results: Option<i64>,
#[serde(rename = "QualificationRequests")]
#[serde(skip_serializing_if = "Option::is_none")]
pub qualification_requests: Option<Vec<QualificationRequest>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListQualificationTypesRequest {
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "MustBeOwnedByCaller")]
#[serde(skip_serializing_if = "Option::is_none")]
pub must_be_owned_by_caller: Option<bool>,
#[serde(rename = "MustBeRequestable")]
pub must_be_requestable: bool,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Query")]
#[serde(skip_serializing_if = "Option::is_none")]
pub query: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListQualificationTypesResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "NumResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub num_results: Option<i64>,
#[serde(rename = "QualificationTypes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub qualification_types: Option<Vec<QualificationType>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListReviewPolicyResultsForHITRequest {
#[serde(rename = "HITId")]
pub hit_id: String,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "PolicyLevels")]
#[serde(skip_serializing_if = "Option::is_none")]
pub policy_levels: Option<Vec<String>>,
#[serde(rename = "RetrieveActions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub retrieve_actions: Option<bool>,
#[serde(rename = "RetrieveResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub retrieve_results: Option<bool>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListReviewPolicyResultsForHITResponse {
#[serde(rename = "AssignmentReviewPolicy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub assignment_review_policy: Option<ReviewPolicy>,
#[serde(rename = "AssignmentReviewReport")]
#[serde(skip_serializing_if = "Option::is_none")]
pub assignment_review_report: Option<ReviewReport>,
#[serde(rename = "HITId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hit_id: Option<String>,
#[serde(rename = "HITReviewPolicy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hit_review_policy: Option<ReviewPolicy>,
#[serde(rename = "HITReviewReport")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hit_review_report: Option<ReviewReport>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListReviewableHITsRequest {
#[serde(rename = "HITTypeId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hit_type_id: Option<String>,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListReviewableHITsResponse {
#[serde(rename = "HITs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hi_ts: Option<Vec<HIT>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "NumResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub num_results: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListWorkerBlocksRequest {
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListWorkerBlocksResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "NumResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub num_results: Option<i64>,
#[serde(rename = "WorkerBlocks")]
#[serde(skip_serializing_if = "Option::is_none")]
pub worker_blocks: Option<Vec<WorkerBlock>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListWorkersWithQualificationTypeRequest {
#[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 = "QualificationTypeId")]
pub qualification_type_id: String,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListWorkersWithQualificationTypeResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "NumResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub num_results: Option<i64>,
#[serde(rename = "Qualifications")]
#[serde(skip_serializing_if = "Option::is_none")]
pub qualifications: Option<Vec<Qualification>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Locale {
#[serde(rename = "Country")]
pub country: String,
#[serde(rename = "Subdivision")]
#[serde(skip_serializing_if = "Option::is_none")]
pub subdivision: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct NotificationSpecification {
#[serde(rename = "Destination")]
pub destination: String,
#[serde(rename = "EventTypes")]
pub event_types: Vec<String>,
#[serde(rename = "Transport")]
pub transport: String,
#[serde(rename = "Version")]
pub version: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct NotifyWorkersFailureStatus {
#[serde(rename = "NotifyWorkersFailureCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub notify_workers_failure_code: Option<String>,
#[serde(rename = "NotifyWorkersFailureMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub notify_workers_failure_message: Option<String>,
#[serde(rename = "WorkerId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub worker_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct NotifyWorkersRequest {
#[serde(rename = "MessageText")]
pub message_text: String,
#[serde(rename = "Subject")]
pub subject: String,
#[serde(rename = "WorkerIds")]
pub worker_ids: Vec<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct NotifyWorkersResponse {
#[serde(rename = "NotifyWorkersFailureStatuses")]
#[serde(skip_serializing_if = "Option::is_none")]
pub notify_workers_failure_statuses: Option<Vec<NotifyWorkersFailureStatus>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ParameterMapEntry {
#[serde(rename = "Key")]
#[serde(skip_serializing_if = "Option::is_none")]
pub key: Option<String>,
#[serde(rename = "Values")]
#[serde(skip_serializing_if = "Option::is_none")]
pub values: Option<Vec<String>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PolicyParameter {
#[serde(rename = "Key")]
#[serde(skip_serializing_if = "Option::is_none")]
pub key: Option<String>,
#[serde(rename = "MapEntries")]
#[serde(skip_serializing_if = "Option::is_none")]
pub map_entries: Option<Vec<ParameterMapEntry>>,
#[serde(rename = "Values")]
#[serde(skip_serializing_if = "Option::is_none")]
pub values: Option<Vec<String>>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Qualification {
#[serde(rename = "GrantTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub grant_time: Option<f64>,
#[serde(rename = "IntegerValue")]
#[serde(skip_serializing_if = "Option::is_none")]
pub integer_value: Option<i64>,
#[serde(rename = "LocaleValue")]
#[serde(skip_serializing_if = "Option::is_none")]
pub locale_value: Option<Locale>,
#[serde(rename = "QualificationTypeId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub qualification_type_id: Option<String>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "WorkerId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub worker_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct QualificationRequest {
#[serde(rename = "Answer")]
#[serde(skip_serializing_if = "Option::is_none")]
pub answer: Option<String>,
#[serde(rename = "QualificationRequestId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub qualification_request_id: Option<String>,
#[serde(rename = "QualificationTypeId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub qualification_type_id: Option<String>,
#[serde(rename = "SubmitTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub submit_time: Option<f64>,
#[serde(rename = "Test")]
#[serde(skip_serializing_if = "Option::is_none")]
pub test: Option<String>,
#[serde(rename = "WorkerId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub worker_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct QualificationRequirement {
#[serde(rename = "ActionsGuarded")]
#[serde(skip_serializing_if = "Option::is_none")]
pub actions_guarded: Option<String>,
#[serde(rename = "Comparator")]
pub comparator: String,
#[serde(rename = "IntegerValues")]
#[serde(skip_serializing_if = "Option::is_none")]
pub integer_values: Option<Vec<i64>>,
#[serde(rename = "LocaleValues")]
#[serde(skip_serializing_if = "Option::is_none")]
pub locale_values: Option<Vec<Locale>>,
#[serde(rename = "QualificationTypeId")]
pub qualification_type_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct QualificationType {
#[serde(rename = "AnswerKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub answer_key: Option<String>,
#[serde(rename = "AutoGranted")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_granted: Option<bool>,
#[serde(rename = "AutoGrantedValue")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_granted_value: Option<i64>,
#[serde(rename = "CreationTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_time: Option<f64>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "IsRequestable")]
#[serde(skip_serializing_if = "Option::is_none")]
pub is_requestable: Option<bool>,
#[serde(rename = "Keywords")]
#[serde(skip_serializing_if = "Option::is_none")]
pub keywords: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "QualificationTypeId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub qualification_type_id: Option<String>,
#[serde(rename = "QualificationTypeStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub qualification_type_status: Option<String>,
#[serde(rename = "RetryDelayInSeconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub retry_delay_in_seconds: Option<i64>,
#[serde(rename = "Test")]
#[serde(skip_serializing_if = "Option::is_none")]
pub test: Option<String>,
#[serde(rename = "TestDurationInSeconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub test_duration_in_seconds: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct RejectAssignmentRequest {
#[serde(rename = "AssignmentId")]
pub assignment_id: String,
#[serde(rename = "RequesterFeedback")]
pub requester_feedback: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RejectAssignmentResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct RejectQualificationRequestRequest {
#[serde(rename = "QualificationRequestId")]
pub qualification_request_id: String,
#[serde(rename = "Reason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub reason: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RejectQualificationRequestResponse {}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ReviewActionDetail {
#[serde(rename = "ActionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub action_id: Option<String>,
#[serde(rename = "ActionName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub action_name: Option<String>,
#[serde(rename = "CompleteTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub complete_time: Option<f64>,
#[serde(rename = "ErrorCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_code: Option<String>,
#[serde(rename = "Result")]
#[serde(skip_serializing_if = "Option::is_none")]
pub result: Option<String>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "TargetId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub target_id: Option<String>,
#[serde(rename = "TargetType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub target_type: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ReviewPolicy {
#[serde(rename = "Parameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub parameters: Option<Vec<PolicyParameter>>,
#[serde(rename = "PolicyName")]
pub policy_name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ReviewReport {
#[serde(rename = "ReviewActions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub review_actions: Option<Vec<ReviewActionDetail>>,
#[serde(rename = "ReviewResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub review_results: Option<Vec<ReviewResultDetail>>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ReviewResultDetail {
#[serde(rename = "ActionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub action_id: Option<String>,
#[serde(rename = "Key")]
#[serde(skip_serializing_if = "Option::is_none")]
pub key: Option<String>,
#[serde(rename = "QuestionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub question_id: Option<String>,
#[serde(rename = "SubjectId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub subject_id: Option<String>,
#[serde(rename = "SubjectType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub subject_type: Option<String>,
#[serde(rename = "Value")]
#[serde(skip_serializing_if = "Option::is_none")]
pub value: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct SendBonusRequest {
#[serde(rename = "AssignmentId")]
pub assignment_id: String,
#[serde(rename = "BonusAmount")]
pub bonus_amount: String,
#[serde(rename = "Reason")]
pub reason: String,
#[serde(rename = "UniqueRequestToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub unique_request_token: Option<String>,
#[serde(rename = "WorkerId")]
pub worker_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct SendBonusResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct SendTestEventNotificationRequest {
#[serde(rename = "Notification")]
pub notification: NotificationSpecification,
#[serde(rename = "TestEventType")]
pub test_event_type: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct SendTestEventNotificationResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateExpirationForHITRequest {
#[serde(rename = "ExpireAt")]
pub expire_at: f64,
#[serde(rename = "HITId")]
pub hit_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateExpirationForHITResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateHITReviewStatusRequest {
#[serde(rename = "HITId")]
pub hit_id: String,
#[serde(rename = "Revert")]
#[serde(skip_serializing_if = "Option::is_none")]
pub revert: Option<bool>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateHITReviewStatusResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateHITTypeOfHITRequest {
#[serde(rename = "HITId")]
pub hit_id: String,
#[serde(rename = "HITTypeId")]
pub hit_type_id: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateHITTypeOfHITResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateNotificationSettingsRequest {
#[serde(rename = "Active")]
#[serde(skip_serializing_if = "Option::is_none")]
pub active: Option<bool>,
#[serde(rename = "HITTypeId")]
pub hit_type_id: String,
#[serde(rename = "Notification")]
#[serde(skip_serializing_if = "Option::is_none")]
pub notification: Option<NotificationSpecification>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateNotificationSettingsResponse {}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateQualificationTypeRequest {
#[serde(rename = "AnswerKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub answer_key: Option<String>,
#[serde(rename = "AutoGranted")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_granted: Option<bool>,
#[serde(rename = "AutoGrantedValue")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_granted_value: Option<i64>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "QualificationTypeId")]
pub qualification_type_id: String,
#[serde(rename = "QualificationTypeStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub qualification_type_status: Option<String>,
#[serde(rename = "RetryDelayInSeconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub retry_delay_in_seconds: Option<i64>,
#[serde(rename = "Test")]
#[serde(skip_serializing_if = "Option::is_none")]
pub test: Option<String>,
#[serde(rename = "TestDurationInSeconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub test_duration_in_seconds: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateQualificationTypeResponse {
#[serde(rename = "QualificationType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub qualification_type: Option<QualificationType>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct WorkerBlock {
#[serde(rename = "Reason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub reason: Option<String>,
#[serde(rename = "WorkerId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub worker_id: Option<String>,
}
#[derive(Debug, PartialEq)]
pub enum AcceptQualificationRequestError {
RequestError(String),
ServiceFault(String),
}
impl AcceptQualificationRequestError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<AcceptQualificationRequestError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"RequestError" => {
return RusotoError::Service(AcceptQualificationRequestError::RequestError(
err.msg,
))
}
"ServiceFault" => {
return RusotoError::Service(AcceptQualificationRequestError::ServiceFault(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AcceptQualificationRequestError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AcceptQualificationRequestError::RequestError(ref cause) => write!(f, "{}", cause),
AcceptQualificationRequestError::ServiceFault(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for AcceptQualificationRequestError {}
#[derive(Debug, PartialEq)]
pub enum ApproveAssignmentError {
RequestError(String),
ServiceFault(String),
}
impl ApproveAssignmentError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ApproveAssignmentError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"RequestError" => {
return RusotoError::Service(ApproveAssignmentError::RequestError(err.msg))
}
"ServiceFault" => {
return RusotoError::Service(ApproveAssignmentError::ServiceFault(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ApproveAssignmentError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ApproveAssignmentError::RequestError(ref cause) => write!(f, "{}", cause),
ApproveAssignmentError::ServiceFault(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ApproveAssignmentError {}
#[derive(Debug, PartialEq)]
pub enum AssociateQualificationWithWorkerError {
RequestError(String),
ServiceFault(String),
}
impl AssociateQualificationWithWorkerError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<AssociateQualificationWithWorkerError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"RequestError" => {
return RusotoError::Service(
AssociateQualificationWithWorkerError::RequestError(err.msg),
)
}
"ServiceFault" => {
return RusotoError::Service(
AssociateQualificationWithWorkerError::ServiceFault(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AssociateQualificationWithWorkerError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AssociateQualificationWithWorkerError::RequestError(ref cause) => {
write!(f, "{}", cause)
}
AssociateQualificationWithWorkerError::ServiceFault(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for AssociateQualificationWithWorkerError {}
#[derive(Debug, PartialEq)]
pub enum CreateAdditionalAssignmentsForHITError {
RequestError(String),
ServiceFault(String),
}
impl CreateAdditionalAssignmentsForHITError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<CreateAdditionalAssignmentsForHITError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"RequestError" => {
return RusotoError::Service(
CreateAdditionalAssignmentsForHITError::RequestError(err.msg),
)
}
"ServiceFault" => {
return RusotoError::Service(
CreateAdditionalAssignmentsForHITError::ServiceFault(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateAdditionalAssignmentsForHITError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateAdditionalAssignmentsForHITError::RequestError(ref cause) => {
write!(f, "{}", cause)
}
CreateAdditionalAssignmentsForHITError::ServiceFault(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for CreateAdditionalAssignmentsForHITError {}
#[derive(Debug, PartialEq)]
pub enum CreateHITError {
RequestError(String),
ServiceFault(String),
}
impl CreateHITError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateHITError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"RequestError" => {
return RusotoError::Service(CreateHITError::RequestError(err.msg))
}
"ServiceFault" => {
return RusotoError::Service(CreateHITError::ServiceFault(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateHITError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateHITError::RequestError(ref cause) => write!(f, "{}", cause),
CreateHITError::ServiceFault(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateHITError {}
#[derive(Debug, PartialEq)]
pub enum CreateHITTypeError {
RequestError(String),
ServiceFault(String),
}
impl CreateHITTypeError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateHITTypeError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"RequestError" => {
return RusotoError::Service(CreateHITTypeError::RequestError(err.msg))
}
"ServiceFault" => {
return RusotoError::Service(CreateHITTypeError::ServiceFault(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateHITTypeError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateHITTypeError::RequestError(ref cause) => write!(f, "{}", cause),
CreateHITTypeError::ServiceFault(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateHITTypeError {}
#[derive(Debug, PartialEq)]
pub enum CreateHITWithHITTypeError {
RequestError(String),
ServiceFault(String),
}
impl CreateHITWithHITTypeError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateHITWithHITTypeError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"RequestError" => {
return RusotoError::Service(CreateHITWithHITTypeError::RequestError(err.msg))
}
"ServiceFault" => {
return RusotoError::Service(CreateHITWithHITTypeError::ServiceFault(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateHITWithHITTypeError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateHITWithHITTypeError::RequestError(ref cause) => write!(f, "{}", cause),
CreateHITWithHITTypeError::ServiceFault(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateHITWithHITTypeError {}
#[derive(Debug, PartialEq)]
pub enum CreateQualificationTypeError {
RequestError(String),
ServiceFault(String),
}
impl CreateQualificationTypeError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateQualificationTypeError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"RequestError" => {
return RusotoError::Service(CreateQualificationTypeError::RequestError(
err.msg,
))
}
"ServiceFault" => {
return RusotoError::Service(CreateQualificationTypeError::ServiceFault(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateQualificationTypeError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateQualificationTypeError::RequestError(ref cause) => write!(f, "{}", cause),
CreateQualificationTypeError::ServiceFault(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateQualificationTypeError {}
#[derive(Debug, PartialEq)]
pub enum CreateWorkerBlockError {
RequestError(String),
ServiceFault(String),
}
impl CreateWorkerBlockError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateWorkerBlockError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"RequestError" => {
return RusotoError::Service(CreateWorkerBlockError::RequestError(err.msg))
}
"ServiceFault" => {
return RusotoError::Service(CreateWorkerBlockError::ServiceFault(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateWorkerBlockError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateWorkerBlockError::RequestError(ref cause) => write!(f, "{}", cause),
CreateWorkerBlockError::ServiceFault(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateWorkerBlockError {}
#[derive(Debug, PartialEq)]
pub enum DeleteHITError {
RequestError(String),
ServiceFault(String),
}
impl DeleteHITError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteHITError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"RequestError" => {
return RusotoError::Service(DeleteHITError::RequestError(err.msg))
}
"ServiceFault" => {
return RusotoError::Service(DeleteHITError::ServiceFault(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteHITError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteHITError::RequestError(ref cause) => write!(f, "{}", cause),
DeleteHITError::ServiceFault(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteHITError {}
#[derive(Debug, PartialEq)]
pub enum DeleteQualificationTypeError {
RequestError(String),
ServiceFault(String),
}
impl DeleteQualificationTypeError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteQualificationTypeError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"RequestError" => {
return RusotoError::Service(DeleteQualificationTypeError::RequestError(
err.msg,
))
}
"ServiceFault" => {
return RusotoError::Service(DeleteQualificationTypeError::ServiceFault(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteQualificationTypeError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteQualificationTypeError::RequestError(ref cause) => write!(f, "{}", cause),
DeleteQualificationTypeError::ServiceFault(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteQualificationTypeError {}
#[derive(Debug, PartialEq)]
pub enum DeleteWorkerBlockError {
RequestError(String),
ServiceFault(String),
}
impl DeleteWorkerBlockError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteWorkerBlockError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"RequestError" => {
return RusotoError::Service(DeleteWorkerBlockError::RequestError(err.msg))
}
"ServiceFault" => {
return RusotoError::Service(DeleteWorkerBlockError::ServiceFault(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteWorkerBlockError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteWorkerBlockError::RequestError(ref cause) => write!(f, "{}", cause),
DeleteWorkerBlockError::ServiceFault(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteWorkerBlockError {}
#[derive(Debug, PartialEq)]
pub enum DisassociateQualificationFromWorkerError {
RequestError(String),
ServiceFault(String),
}
impl DisassociateQualificationFromWorkerError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DisassociateQualificationFromWorkerError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"RequestError" => {
return RusotoError::Service(
DisassociateQualificationFromWorkerError::RequestError(err.msg),
)
}
"ServiceFault" => {
return RusotoError::Service(
DisassociateQualificationFromWorkerError::ServiceFault(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DisassociateQualificationFromWorkerError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DisassociateQualificationFromWorkerError::RequestError(ref cause) => {
write!(f, "{}", cause)
}
DisassociateQualificationFromWorkerError::ServiceFault(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DisassociateQualificationFromWorkerError {}
#[derive(Debug, PartialEq)]
pub enum GetAccountBalanceError {
RequestError(String),
ServiceFault(String),
}
impl GetAccountBalanceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetAccountBalanceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"RequestError" => {
return RusotoError::Service(GetAccountBalanceError::RequestError(err.msg))
}
"ServiceFault" => {
return RusotoError::Service(GetAccountBalanceError::ServiceFault(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetAccountBalanceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetAccountBalanceError::RequestError(ref cause) => write!(f, "{}", cause),
GetAccountBalanceError::ServiceFault(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetAccountBalanceError {}
#[derive(Debug, PartialEq)]
pub enum GetAssignmentError {
RequestError(String),
ServiceFault(String),
}
impl GetAssignmentError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetAssignmentError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"RequestError" => {
return RusotoError::Service(GetAssignmentError::RequestError(err.msg))
}
"ServiceFault" => {
return RusotoError::Service(GetAssignmentError::ServiceFault(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetAssignmentError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetAssignmentError::RequestError(ref cause) => write!(f, "{}", cause),
GetAssignmentError::ServiceFault(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetAssignmentError {}
#[derive(Debug, PartialEq)]
pub enum GetFileUploadURLError {
RequestError(String),
ServiceFault(String),
}
impl GetFileUploadURLError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetFileUploadURLError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"RequestError" => {
return RusotoError::Service(GetFileUploadURLError::RequestError(err.msg))
}
"ServiceFault" => {
return RusotoError::Service(GetFileUploadURLError::ServiceFault(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetFileUploadURLError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetFileUploadURLError::RequestError(ref cause) => write!(f, "{}", cause),
GetFileUploadURLError::ServiceFault(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetFileUploadURLError {}
#[derive(Debug, PartialEq)]
pub enum GetHITError {
RequestError(String),
ServiceFault(String),
}
impl GetHITError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetHITError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"RequestError" => return RusotoError::Service(GetHITError::RequestError(err.msg)),
"ServiceFault" => return RusotoError::Service(GetHITError::ServiceFault(err.msg)),
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetHITError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetHITError::RequestError(ref cause) => write!(f, "{}", cause),
GetHITError::ServiceFault(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetHITError {}
#[derive(Debug, PartialEq)]
pub enum GetQualificationScoreError {
RequestError(String),
ServiceFault(String),
}
impl GetQualificationScoreError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetQualificationScoreError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"RequestError" => {
return RusotoError::Service(GetQualificationScoreError::RequestError(err.msg))
}
"ServiceFault" => {
return RusotoError::Service(GetQualificationScoreError::ServiceFault(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetQualificationScoreError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetQualificationScoreError::RequestError(ref cause) => write!(f, "{}", cause),
GetQualificationScoreError::ServiceFault(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetQualificationScoreError {}
#[derive(Debug, PartialEq)]
pub enum GetQualificationTypeError {
RequestError(String),
ServiceFault(String),
}
impl GetQualificationTypeError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetQualificationTypeError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"RequestError" => {
return RusotoError::Service(GetQualificationTypeError::RequestError(err.msg))
}
"ServiceFault" => {
return RusotoError::Service(GetQualificationTypeError::ServiceFault(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetQualificationTypeError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetQualificationTypeError::RequestError(ref cause) => write!(f, "{}", cause),
GetQualificationTypeError::ServiceFault(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetQualificationTypeError {}
#[derive(Debug, PartialEq)]
pub enum ListAssignmentsForHITError {
RequestError(String),
ServiceFault(String),
}
impl ListAssignmentsForHITError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListAssignmentsForHITError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"RequestError" => {
return RusotoError::Service(ListAssignmentsForHITError::RequestError(err.msg))
}
"ServiceFault" => {
return RusotoError::Service(ListAssignmentsForHITError::ServiceFault(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListAssignmentsForHITError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListAssignmentsForHITError::RequestError(ref cause) => write!(f, "{}", cause),
ListAssignmentsForHITError::ServiceFault(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListAssignmentsForHITError {}
#[derive(Debug, PartialEq)]
pub enum ListBonusPaymentsError {
RequestError(String),
ServiceFault(String),
}
impl ListBonusPaymentsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListBonusPaymentsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"RequestError" => {
return RusotoError::Service(ListBonusPaymentsError::RequestError(err.msg))
}
"ServiceFault" => {
return RusotoError::Service(ListBonusPaymentsError::ServiceFault(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListBonusPaymentsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListBonusPaymentsError::RequestError(ref cause) => write!(f, "{}", cause),
ListBonusPaymentsError::ServiceFault(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListBonusPaymentsError {}
#[derive(Debug, PartialEq)]
pub enum ListHITsError {
RequestError(String),
ServiceFault(String),
}
impl ListHITsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListHITsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"RequestError" => {
return RusotoError::Service(ListHITsError::RequestError(err.msg))
}
"ServiceFault" => {
return RusotoError::Service(ListHITsError::ServiceFault(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListHITsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListHITsError::RequestError(ref cause) => write!(f, "{}", cause),
ListHITsError::ServiceFault(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListHITsError {}
#[derive(Debug, PartialEq)]
pub enum ListHITsForQualificationTypeError {
RequestError(String),
ServiceFault(String),
}
impl ListHITsForQualificationTypeError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListHITsForQualificationTypeError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"RequestError" => {
return RusotoError::Service(ListHITsForQualificationTypeError::RequestError(
err.msg,
))
}
"ServiceFault" => {
return RusotoError::Service(ListHITsForQualificationTypeError::ServiceFault(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListHITsForQualificationTypeError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListHITsForQualificationTypeError::RequestError(ref cause) => write!(f, "{}", cause),
ListHITsForQualificationTypeError::ServiceFault(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListHITsForQualificationTypeError {}
#[derive(Debug, PartialEq)]
pub enum ListQualificationRequestsError {
RequestError(String),
ServiceFault(String),
}
impl ListQualificationRequestsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListQualificationRequestsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"RequestError" => {
return RusotoError::Service(ListQualificationRequestsError::RequestError(
err.msg,
))
}
"ServiceFault" => {
return RusotoError::Service(ListQualificationRequestsError::ServiceFault(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListQualificationRequestsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListQualificationRequestsError::RequestError(ref cause) => write!(f, "{}", cause),
ListQualificationRequestsError::ServiceFault(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListQualificationRequestsError {}
#[derive(Debug, PartialEq)]
pub enum ListQualificationTypesError {
RequestError(String),
ServiceFault(String),
}
impl ListQualificationTypesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListQualificationTypesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"RequestError" => {
return RusotoError::Service(ListQualificationTypesError::RequestError(err.msg))
}
"ServiceFault" => {
return RusotoError::Service(ListQualificationTypesError::ServiceFault(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListQualificationTypesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListQualificationTypesError::RequestError(ref cause) => write!(f, "{}", cause),
ListQualificationTypesError::ServiceFault(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListQualificationTypesError {}
#[derive(Debug, PartialEq)]
pub enum ListReviewPolicyResultsForHITError {
RequestError(String),
ServiceFault(String),
}
impl ListReviewPolicyResultsForHITError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListReviewPolicyResultsForHITError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"RequestError" => {
return RusotoError::Service(ListReviewPolicyResultsForHITError::RequestError(
err.msg,
))
}
"ServiceFault" => {
return RusotoError::Service(ListReviewPolicyResultsForHITError::ServiceFault(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListReviewPolicyResultsForHITError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListReviewPolicyResultsForHITError::RequestError(ref cause) => write!(f, "{}", cause),
ListReviewPolicyResultsForHITError::ServiceFault(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListReviewPolicyResultsForHITError {}
#[derive(Debug, PartialEq)]
pub enum ListReviewableHITsError {
RequestError(String),
ServiceFault(String),
}
impl ListReviewableHITsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListReviewableHITsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"RequestError" => {
return RusotoError::Service(ListReviewableHITsError::RequestError(err.msg))
}
"ServiceFault" => {
return RusotoError::Service(ListReviewableHITsError::ServiceFault(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListReviewableHITsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListReviewableHITsError::RequestError(ref cause) => write!(f, "{}", cause),
ListReviewableHITsError::ServiceFault(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListReviewableHITsError {}
#[derive(Debug, PartialEq)]
pub enum ListWorkerBlocksError {
RequestError(String),
ServiceFault(String),
}
impl ListWorkerBlocksError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListWorkerBlocksError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"RequestError" => {
return RusotoError::Service(ListWorkerBlocksError::RequestError(err.msg))
}
"ServiceFault" => {
return RusotoError::Service(ListWorkerBlocksError::ServiceFault(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListWorkerBlocksError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListWorkerBlocksError::RequestError(ref cause) => write!(f, "{}", cause),
ListWorkerBlocksError::ServiceFault(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListWorkerBlocksError {}
#[derive(Debug, PartialEq)]
pub enum ListWorkersWithQualificationTypeError {
RequestError(String),
ServiceFault(String),
}
impl ListWorkersWithQualificationTypeError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListWorkersWithQualificationTypeError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"RequestError" => {
return RusotoError::Service(
ListWorkersWithQualificationTypeError::RequestError(err.msg),
)
}
"ServiceFault" => {
return RusotoError::Service(
ListWorkersWithQualificationTypeError::ServiceFault(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListWorkersWithQualificationTypeError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListWorkersWithQualificationTypeError::RequestError(ref cause) => {
write!(f, "{}", cause)
}
ListWorkersWithQualificationTypeError::ServiceFault(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ListWorkersWithQualificationTypeError {}
#[derive(Debug, PartialEq)]
pub enum NotifyWorkersError {
RequestError(String),
ServiceFault(String),
}
impl NotifyWorkersError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<NotifyWorkersError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"RequestError" => {
return RusotoError::Service(NotifyWorkersError::RequestError(err.msg))
}
"ServiceFault" => {
return RusotoError::Service(NotifyWorkersError::ServiceFault(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for NotifyWorkersError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
NotifyWorkersError::RequestError(ref cause) => write!(f, "{}", cause),
NotifyWorkersError::ServiceFault(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for NotifyWorkersError {}
#[derive(Debug, PartialEq)]
pub enum RejectAssignmentError {
RequestError(String),
ServiceFault(String),
}
impl RejectAssignmentError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<RejectAssignmentError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"RequestError" => {
return RusotoError::Service(RejectAssignmentError::RequestError(err.msg))
}
"ServiceFault" => {
return RusotoError::Service(RejectAssignmentError::ServiceFault(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for RejectAssignmentError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
RejectAssignmentError::RequestError(ref cause) => write!(f, "{}", cause),
RejectAssignmentError::ServiceFault(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for RejectAssignmentError {}
#[derive(Debug, PartialEq)]
pub enum RejectQualificationRequestError {
RequestError(String),
ServiceFault(String),
}
impl RejectQualificationRequestError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<RejectQualificationRequestError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"RequestError" => {
return RusotoError::Service(RejectQualificationRequestError::RequestError(
err.msg,
))
}
"ServiceFault" => {
return RusotoError::Service(RejectQualificationRequestError::ServiceFault(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for RejectQualificationRequestError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
RejectQualificationRequestError::RequestError(ref cause) => write!(f, "{}", cause),
RejectQualificationRequestError::ServiceFault(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for RejectQualificationRequestError {}
#[derive(Debug, PartialEq)]
pub enum SendBonusError {
RequestError(String),
ServiceFault(String),
}
impl SendBonusError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<SendBonusError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"RequestError" => {
return RusotoError::Service(SendBonusError::RequestError(err.msg))
}
"ServiceFault" => {
return RusotoError::Service(SendBonusError::ServiceFault(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for SendBonusError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
SendBonusError::RequestError(ref cause) => write!(f, "{}", cause),
SendBonusError::ServiceFault(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for SendBonusError {}
#[derive(Debug, PartialEq)]
pub enum SendTestEventNotificationError {
RequestError(String),
ServiceFault(String),
}
impl SendTestEventNotificationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<SendTestEventNotificationError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"RequestError" => {
return RusotoError::Service(SendTestEventNotificationError::RequestError(
err.msg,
))
}
"ServiceFault" => {
return RusotoError::Service(SendTestEventNotificationError::ServiceFault(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for SendTestEventNotificationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
SendTestEventNotificationError::RequestError(ref cause) => write!(f, "{}", cause),
SendTestEventNotificationError::ServiceFault(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for SendTestEventNotificationError {}
#[derive(Debug, PartialEq)]
pub enum UpdateExpirationForHITError {
RequestError(String),
ServiceFault(String),
}
impl UpdateExpirationForHITError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateExpirationForHITError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"RequestError" => {
return RusotoError::Service(UpdateExpirationForHITError::RequestError(err.msg))
}
"ServiceFault" => {
return RusotoError::Service(UpdateExpirationForHITError::ServiceFault(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateExpirationForHITError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateExpirationForHITError::RequestError(ref cause) => write!(f, "{}", cause),
UpdateExpirationForHITError::ServiceFault(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateExpirationForHITError {}
#[derive(Debug, PartialEq)]
pub enum UpdateHITReviewStatusError {
RequestError(String),
ServiceFault(String),
}
impl UpdateHITReviewStatusError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateHITReviewStatusError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"RequestError" => {
return RusotoError::Service(UpdateHITReviewStatusError::RequestError(err.msg))
}
"ServiceFault" => {
return RusotoError::Service(UpdateHITReviewStatusError::ServiceFault(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateHITReviewStatusError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateHITReviewStatusError::RequestError(ref cause) => write!(f, "{}", cause),
UpdateHITReviewStatusError::ServiceFault(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateHITReviewStatusError {}
#[derive(Debug, PartialEq)]
pub enum UpdateHITTypeOfHITError {
RequestError(String),
ServiceFault(String),
}
impl UpdateHITTypeOfHITError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateHITTypeOfHITError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"RequestError" => {
return RusotoError::Service(UpdateHITTypeOfHITError::RequestError(err.msg))
}
"ServiceFault" => {
return RusotoError::Service(UpdateHITTypeOfHITError::ServiceFault(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateHITTypeOfHITError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateHITTypeOfHITError::RequestError(ref cause) => write!(f, "{}", cause),
UpdateHITTypeOfHITError::ServiceFault(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateHITTypeOfHITError {}
#[derive(Debug, PartialEq)]
pub enum UpdateNotificationSettingsError {
RequestError(String),
ServiceFault(String),
}
impl UpdateNotificationSettingsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<UpdateNotificationSettingsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"RequestError" => {
return RusotoError::Service(UpdateNotificationSettingsError::RequestError(
err.msg,
))
}
"ServiceFault" => {
return RusotoError::Service(UpdateNotificationSettingsError::ServiceFault(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateNotificationSettingsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateNotificationSettingsError::RequestError(ref cause) => write!(f, "{}", cause),
UpdateNotificationSettingsError::ServiceFault(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateNotificationSettingsError {}
#[derive(Debug, PartialEq)]
pub enum UpdateQualificationTypeError {
RequestError(String),
ServiceFault(String),
}
impl UpdateQualificationTypeError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateQualificationTypeError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"RequestError" => {
return RusotoError::Service(UpdateQualificationTypeError::RequestError(
err.msg,
))
}
"ServiceFault" => {
return RusotoError::Service(UpdateQualificationTypeError::ServiceFault(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateQualificationTypeError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateQualificationTypeError::RequestError(ref cause) => write!(f, "{}", cause),
UpdateQualificationTypeError::ServiceFault(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateQualificationTypeError {}
#[async_trait]
pub trait MechanicalTurk {
async fn accept_qualification_request(
&self,
input: AcceptQualificationRequestRequest,
) -> Result<AcceptQualificationRequestResponse, RusotoError<AcceptQualificationRequestError>>;
async fn approve_assignment(
&self,
input: ApproveAssignmentRequest,
) -> Result<ApproveAssignmentResponse, RusotoError<ApproveAssignmentError>>;
async fn associate_qualification_with_worker(
&self,
input: AssociateQualificationWithWorkerRequest,
) -> Result<
AssociateQualificationWithWorkerResponse,
RusotoError<AssociateQualificationWithWorkerError>,
>;
async fn create_additional_assignments_for_hit(
&self,
input: CreateAdditionalAssignmentsForHITRequest,
) -> Result<
CreateAdditionalAssignmentsForHITResponse,
RusotoError<CreateAdditionalAssignmentsForHITError>,
>;
async fn create_hit(
&self,
input: CreateHITRequest,
) -> Result<CreateHITResponse, RusotoError<CreateHITError>>;
async fn create_hit_type(
&self,
input: CreateHITTypeRequest,
) -> Result<CreateHITTypeResponse, RusotoError<CreateHITTypeError>>;
async fn create_hit_with_hit_type(
&self,
input: CreateHITWithHITTypeRequest,
) -> Result<CreateHITWithHITTypeResponse, RusotoError<CreateHITWithHITTypeError>>;
async fn create_qualification_type(
&self,
input: CreateQualificationTypeRequest,
) -> Result<CreateQualificationTypeResponse, RusotoError<CreateQualificationTypeError>>;
async fn create_worker_block(
&self,
input: CreateWorkerBlockRequest,
) -> Result<CreateWorkerBlockResponse, RusotoError<CreateWorkerBlockError>>;
async fn delete_hit(
&self,
input: DeleteHITRequest,
) -> Result<DeleteHITResponse, RusotoError<DeleteHITError>>;
async fn delete_qualification_type(
&self,
input: DeleteQualificationTypeRequest,
) -> Result<DeleteQualificationTypeResponse, RusotoError<DeleteQualificationTypeError>>;
async fn delete_worker_block(
&self,
input: DeleteWorkerBlockRequest,
) -> Result<DeleteWorkerBlockResponse, RusotoError<DeleteWorkerBlockError>>;
async fn disassociate_qualification_from_worker(
&self,
input: DisassociateQualificationFromWorkerRequest,
) -> Result<
DisassociateQualificationFromWorkerResponse,
RusotoError<DisassociateQualificationFromWorkerError>,
>;
async fn get_account_balance(
&self,
) -> Result<GetAccountBalanceResponse, RusotoError<GetAccountBalanceError>>;
async fn get_assignment(
&self,
input: GetAssignmentRequest,
) -> Result<GetAssignmentResponse, RusotoError<GetAssignmentError>>;
async fn get_file_upload_url(
&self,
input: GetFileUploadURLRequest,
) -> Result<GetFileUploadURLResponse, RusotoError<GetFileUploadURLError>>;
async fn get_hit(
&self,
input: GetHITRequest,
) -> Result<GetHITResponse, RusotoError<GetHITError>>;
async fn get_qualification_score(
&self,
input: GetQualificationScoreRequest,
) -> Result<GetQualificationScoreResponse, RusotoError<GetQualificationScoreError>>;
async fn get_qualification_type(
&self,
input: GetQualificationTypeRequest,
) -> Result<GetQualificationTypeResponse, RusotoError<GetQualificationTypeError>>;
async fn list_assignments_for_hit(
&self,
input: ListAssignmentsForHITRequest,
) -> Result<ListAssignmentsForHITResponse, RusotoError<ListAssignmentsForHITError>>;
async fn list_bonus_payments(
&self,
input: ListBonusPaymentsRequest,
) -> Result<ListBonusPaymentsResponse, RusotoError<ListBonusPaymentsError>>;
async fn list_hi_ts(
&self,
input: ListHITsRequest,
) -> Result<ListHITsResponse, RusotoError<ListHITsError>>;
async fn list_hi_ts_for_qualification_type(
&self,
input: ListHITsForQualificationTypeRequest,
) -> Result<ListHITsForQualificationTypeResponse, RusotoError<ListHITsForQualificationTypeError>>;
async fn list_qualification_requests(
&self,
input: ListQualificationRequestsRequest,
) -> Result<ListQualificationRequestsResponse, RusotoError<ListQualificationRequestsError>>;
async fn list_qualification_types(
&self,
input: ListQualificationTypesRequest,
) -> Result<ListQualificationTypesResponse, RusotoError<ListQualificationTypesError>>;
async fn list_review_policy_results_for_hit(
&self,
input: ListReviewPolicyResultsForHITRequest,
) -> Result<
ListReviewPolicyResultsForHITResponse,
RusotoError<ListReviewPolicyResultsForHITError>,
>;
async fn list_reviewable_hi_ts(
&self,
input: ListReviewableHITsRequest,
) -> Result<ListReviewableHITsResponse, RusotoError<ListReviewableHITsError>>;
async fn list_worker_blocks(
&self,
input: ListWorkerBlocksRequest,
) -> Result<ListWorkerBlocksResponse, RusotoError<ListWorkerBlocksError>>;
async fn list_workers_with_qualification_type(
&self,
input: ListWorkersWithQualificationTypeRequest,
) -> Result<
ListWorkersWithQualificationTypeResponse,
RusotoError<ListWorkersWithQualificationTypeError>,
>;
async fn notify_workers(
&self,
input: NotifyWorkersRequest,
) -> Result<NotifyWorkersResponse, RusotoError<NotifyWorkersError>>;
async fn reject_assignment(
&self,
input: RejectAssignmentRequest,
) -> Result<RejectAssignmentResponse, RusotoError<RejectAssignmentError>>;
async fn reject_qualification_request(
&self,
input: RejectQualificationRequestRequest,
) -> Result<RejectQualificationRequestResponse, RusotoError<RejectQualificationRequestError>>;
async fn send_bonus(
&self,
input: SendBonusRequest,
) -> Result<SendBonusResponse, RusotoError<SendBonusError>>;
async fn send_test_event_notification(
&self,
input: SendTestEventNotificationRequest,
) -> Result<SendTestEventNotificationResponse, RusotoError<SendTestEventNotificationError>>;
async fn update_expiration_for_hit(
&self,
input: UpdateExpirationForHITRequest,
) -> Result<UpdateExpirationForHITResponse, RusotoError<UpdateExpirationForHITError>>;
async fn update_hit_review_status(
&self,
input: UpdateHITReviewStatusRequest,
) -> Result<UpdateHITReviewStatusResponse, RusotoError<UpdateHITReviewStatusError>>;
async fn update_hit_type_of_hit(
&self,
input: UpdateHITTypeOfHITRequest,
) -> Result<UpdateHITTypeOfHITResponse, RusotoError<UpdateHITTypeOfHITError>>;
async fn update_notification_settings(
&self,
input: UpdateNotificationSettingsRequest,
) -> Result<UpdateNotificationSettingsResponse, RusotoError<UpdateNotificationSettingsError>>;
async fn update_qualification_type(
&self,
input: UpdateQualificationTypeRequest,
) -> Result<UpdateQualificationTypeResponse, RusotoError<UpdateQualificationTypeError>>;
}
#[derive(Clone)]
pub struct MechanicalTurkClient {
client: Client,
region: region::Region,
}
impl MechanicalTurkClient {
pub fn new(region: region::Region) -> MechanicalTurkClient {
MechanicalTurkClient {
client: Client::shared(),
region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> MechanicalTurkClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
D: DispatchSignedRequest + Send + Sync + 'static,
{
MechanicalTurkClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region,
}
}
pub fn new_with_client(client: Client, region: region::Region) -> MechanicalTurkClient {
MechanicalTurkClient { client, region }
}
}
#[async_trait]
impl MechanicalTurk for MechanicalTurkClient {
async fn accept_qualification_request(
&self,
input: AcceptQualificationRequestRequest,
) -> Result<AcceptQualificationRequestResponse, RusotoError<AcceptQualificationRequestError>>
{
let mut request = SignedRequest::new("POST", "mturk-requester", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"MTurkRequesterServiceV20170117.AcceptQualificationRequest",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<AcceptQualificationRequestResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(AcceptQualificationRequestError::from_response(response))
}
}
async fn approve_assignment(
&self,
input: ApproveAssignmentRequest,
) -> Result<ApproveAssignmentResponse, RusotoError<ApproveAssignmentError>> {
let mut request = SignedRequest::new("POST", "mturk-requester", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"MTurkRequesterServiceV20170117.ApproveAssignment",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ApproveAssignmentResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(ApproveAssignmentError::from_response(response))
}
}
async fn associate_qualification_with_worker(
&self,
input: AssociateQualificationWithWorkerRequest,
) -> Result<
AssociateQualificationWithWorkerResponse,
RusotoError<AssociateQualificationWithWorkerError>,
> {
let mut request = SignedRequest::new("POST", "mturk-requester", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"MTurkRequesterServiceV20170117.AssociateQualificationWithWorker",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<AssociateQualificationWithWorkerResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(AssociateQualificationWithWorkerError::from_response(
response,
))
}
}
async fn create_additional_assignments_for_hit(
&self,
input: CreateAdditionalAssignmentsForHITRequest,
) -> Result<
CreateAdditionalAssignmentsForHITResponse,
RusotoError<CreateAdditionalAssignmentsForHITError>,
> {
let mut request = SignedRequest::new("POST", "mturk-requester", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"MTurkRequesterServiceV20170117.CreateAdditionalAssignmentsForHIT",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<CreateAdditionalAssignmentsForHITResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(CreateAdditionalAssignmentsForHITError::from_response(
response,
))
}
}
async fn create_hit(
&self,
input: CreateHITRequest,
) -> Result<CreateHITResponse, RusotoError<CreateHITError>> {
let mut request = SignedRequest::new("POST", "mturk-requester", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "MTurkRequesterServiceV20170117.CreateHIT");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateHITResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(CreateHITError::from_response(response))
}
}
async fn create_hit_type(
&self,
input: CreateHITTypeRequest,
) -> Result<CreateHITTypeResponse, RusotoError<CreateHITTypeError>> {
let mut request = SignedRequest::new("POST", "mturk-requester", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"MTurkRequesterServiceV20170117.CreateHITType",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateHITTypeResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(CreateHITTypeError::from_response(response))
}
}
async fn create_hit_with_hit_type(
&self,
input: CreateHITWithHITTypeRequest,
) -> Result<CreateHITWithHITTypeResponse, RusotoError<CreateHITWithHITTypeError>> {
let mut request = SignedRequest::new("POST", "mturk-requester", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"MTurkRequesterServiceV20170117.CreateHITWithHITType",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<CreateHITWithHITTypeResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(CreateHITWithHITTypeError::from_response(response))
}
}
async fn create_qualification_type(
&self,
input: CreateQualificationTypeRequest,
) -> Result<CreateQualificationTypeResponse, RusotoError<CreateQualificationTypeError>> {
let mut request = SignedRequest::new("POST", "mturk-requester", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"MTurkRequesterServiceV20170117.CreateQualificationType",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<CreateQualificationTypeResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(CreateQualificationTypeError::from_response(response))
}
}
async fn create_worker_block(
&self,
input: CreateWorkerBlockRequest,
) -> Result<CreateWorkerBlockResponse, RusotoError<CreateWorkerBlockError>> {
let mut request = SignedRequest::new("POST", "mturk-requester", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"MTurkRequesterServiceV20170117.CreateWorkerBlock",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<CreateWorkerBlockResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(CreateWorkerBlockError::from_response(response))
}
}
async fn delete_hit(
&self,
input: DeleteHITRequest,
) -> Result<DeleteHITResponse, RusotoError<DeleteHITError>> {
let mut request = SignedRequest::new("POST", "mturk-requester", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "MTurkRequesterServiceV20170117.DeleteHIT");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DeleteHITResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(DeleteHITError::from_response(response))
}
}
async fn delete_qualification_type(
&self,
input: DeleteQualificationTypeRequest,
) -> Result<DeleteQualificationTypeResponse, RusotoError<DeleteQualificationTypeError>> {
let mut request = SignedRequest::new("POST", "mturk-requester", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"MTurkRequesterServiceV20170117.DeleteQualificationType",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteQualificationTypeResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(DeleteQualificationTypeError::from_response(response))
}
}
async fn delete_worker_block(
&self,
input: DeleteWorkerBlockRequest,
) -> Result<DeleteWorkerBlockResponse, RusotoError<DeleteWorkerBlockError>> {
let mut request = SignedRequest::new("POST", "mturk-requester", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"MTurkRequesterServiceV20170117.DeleteWorkerBlock",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteWorkerBlockResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(DeleteWorkerBlockError::from_response(response))
}
}
async fn disassociate_qualification_from_worker(
&self,
input: DisassociateQualificationFromWorkerRequest,
) -> Result<
DisassociateQualificationFromWorkerResponse,
RusotoError<DisassociateQualificationFromWorkerError>,
> {
let mut request = SignedRequest::new("POST", "mturk-requester", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"MTurkRequesterServiceV20170117.DisassociateQualificationFromWorker",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DisassociateQualificationFromWorkerResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(DisassociateQualificationFromWorkerError::from_response(
response,
))
}
}
async fn get_account_balance(
&self,
) -> Result<GetAccountBalanceResponse, RusotoError<GetAccountBalanceError>> {
let mut request = SignedRequest::new("POST", "mturk-requester", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"MTurkRequesterServiceV20170117.GetAccountBalance",
);
request.set_payload(Some(bytes::Bytes::from_static(b"{}")));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<GetAccountBalanceResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(GetAccountBalanceError::from_response(response))
}
}
async fn get_assignment(
&self,
input: GetAssignmentRequest,
) -> Result<GetAssignmentResponse, RusotoError<GetAssignmentError>> {
let mut request = SignedRequest::new("POST", "mturk-requester", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"MTurkRequesterServiceV20170117.GetAssignment",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetAssignmentResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(GetAssignmentError::from_response(response))
}
}
async fn get_file_upload_url(
&self,
input: GetFileUploadURLRequest,
) -> Result<GetFileUploadURLResponse, RusotoError<GetFileUploadURLError>> {
let mut request = SignedRequest::new("POST", "mturk-requester", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"MTurkRequesterServiceV20170117.GetFileUploadURL",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<GetFileUploadURLResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(GetFileUploadURLError::from_response(response))
}
}
async fn get_hit(
&self,
input: GetHITRequest,
) -> Result<GetHITResponse, RusotoError<GetHITError>> {
let mut request = SignedRequest::new("POST", "mturk-requester", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "MTurkRequesterServiceV20170117.GetHIT");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetHITResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(GetHITError::from_response(response))
}
}
async fn get_qualification_score(
&self,
input: GetQualificationScoreRequest,
) -> Result<GetQualificationScoreResponse, RusotoError<GetQualificationScoreError>> {
let mut request = SignedRequest::new("POST", "mturk-requester", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"MTurkRequesterServiceV20170117.GetQualificationScore",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<GetQualificationScoreResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(GetQualificationScoreError::from_response(response))
}
}
async fn get_qualification_type(
&self,
input: GetQualificationTypeRequest,
) -> Result<GetQualificationTypeResponse, RusotoError<GetQualificationTypeError>> {
let mut request = SignedRequest::new("POST", "mturk-requester", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"MTurkRequesterServiceV20170117.GetQualificationType",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<GetQualificationTypeResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(GetQualificationTypeError::from_response(response))
}
}
async fn list_assignments_for_hit(
&self,
input: ListAssignmentsForHITRequest,
) -> Result<ListAssignmentsForHITResponse, RusotoError<ListAssignmentsForHITError>> {
let mut request = SignedRequest::new("POST", "mturk-requester", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"MTurkRequesterServiceV20170117.ListAssignmentsForHIT",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListAssignmentsForHITResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(ListAssignmentsForHITError::from_response(response))
}
}
async fn list_bonus_payments(
&self,
input: ListBonusPaymentsRequest,
) -> Result<ListBonusPaymentsResponse, RusotoError<ListBonusPaymentsError>> {
let mut request = SignedRequest::new("POST", "mturk-requester", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"MTurkRequesterServiceV20170117.ListBonusPayments",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListBonusPaymentsResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(ListBonusPaymentsError::from_response(response))
}
}
async fn list_hi_ts(
&self,
input: ListHITsRequest,
) -> Result<ListHITsResponse, RusotoError<ListHITsError>> {
let mut request = SignedRequest::new("POST", "mturk-requester", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "MTurkRequesterServiceV20170117.ListHITs");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListHITsResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(ListHITsError::from_response(response))
}
}
async fn list_hi_ts_for_qualification_type(
&self,
input: ListHITsForQualificationTypeRequest,
) -> Result<ListHITsForQualificationTypeResponse, RusotoError<ListHITsForQualificationTypeError>>
{
let mut request = SignedRequest::new("POST", "mturk-requester", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"MTurkRequesterServiceV20170117.ListHITsForQualificationType",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListHITsForQualificationTypeResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(ListHITsForQualificationTypeError::from_response(response))
}
}
async fn list_qualification_requests(
&self,
input: ListQualificationRequestsRequest,
) -> Result<ListQualificationRequestsResponse, RusotoError<ListQualificationRequestsError>>
{
let mut request = SignedRequest::new("POST", "mturk-requester", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"MTurkRequesterServiceV20170117.ListQualificationRequests",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListQualificationRequestsResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(ListQualificationRequestsError::from_response(response))
}
}
async fn list_qualification_types(
&self,
input: ListQualificationTypesRequest,
) -> Result<ListQualificationTypesResponse, RusotoError<ListQualificationTypesError>> {
let mut request = SignedRequest::new("POST", "mturk-requester", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"MTurkRequesterServiceV20170117.ListQualificationTypes",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListQualificationTypesResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(ListQualificationTypesError::from_response(response))
}
}
async fn list_review_policy_results_for_hit(
&self,
input: ListReviewPolicyResultsForHITRequest,
) -> Result<
ListReviewPolicyResultsForHITResponse,
RusotoError<ListReviewPolicyResultsForHITError>,
> {
let mut request = SignedRequest::new("POST", "mturk-requester", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"MTurkRequesterServiceV20170117.ListReviewPolicyResultsForHIT",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListReviewPolicyResultsForHITResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(ListReviewPolicyResultsForHITError::from_response(response))
}
}
async fn list_reviewable_hi_ts(
&self,
input: ListReviewableHITsRequest,
) -> Result<ListReviewableHITsResponse, RusotoError<ListReviewableHITsError>> {
let mut request = SignedRequest::new("POST", "mturk-requester", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"MTurkRequesterServiceV20170117.ListReviewableHITs",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListReviewableHITsResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(ListReviewableHITsError::from_response(response))
}
}
async fn list_worker_blocks(
&self,
input: ListWorkerBlocksRequest,
) -> Result<ListWorkerBlocksResponse, RusotoError<ListWorkerBlocksError>> {
let mut request = SignedRequest::new("POST", "mturk-requester", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"MTurkRequesterServiceV20170117.ListWorkerBlocks",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListWorkerBlocksResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(ListWorkerBlocksError::from_response(response))
}
}
async fn list_workers_with_qualification_type(
&self,
input: ListWorkersWithQualificationTypeRequest,
) -> Result<
ListWorkersWithQualificationTypeResponse,
RusotoError<ListWorkersWithQualificationTypeError>,
> {
let mut request = SignedRequest::new("POST", "mturk-requester", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"MTurkRequesterServiceV20170117.ListWorkersWithQualificationType",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListWorkersWithQualificationTypeResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(ListWorkersWithQualificationTypeError::from_response(
response,
))
}
}
async fn notify_workers(
&self,
input: NotifyWorkersRequest,
) -> Result<NotifyWorkersResponse, RusotoError<NotifyWorkersError>> {
let mut request = SignedRequest::new("POST", "mturk-requester", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"MTurkRequesterServiceV20170117.NotifyWorkers",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<NotifyWorkersResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(NotifyWorkersError::from_response(response))
}
}
async fn reject_assignment(
&self,
input: RejectAssignmentRequest,
) -> Result<RejectAssignmentResponse, RusotoError<RejectAssignmentError>> {
let mut request = SignedRequest::new("POST", "mturk-requester", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"MTurkRequesterServiceV20170117.RejectAssignment",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<RejectAssignmentResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(RejectAssignmentError::from_response(response))
}
}
async fn reject_qualification_request(
&self,
input: RejectQualificationRequestRequest,
) -> Result<RejectQualificationRequestResponse, RusotoError<RejectQualificationRequestError>>
{
let mut request = SignedRequest::new("POST", "mturk-requester", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"MTurkRequesterServiceV20170117.RejectQualificationRequest",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<RejectQualificationRequestResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(RejectQualificationRequestError::from_response(response))
}
}
async fn send_bonus(
&self,
input: SendBonusRequest,
) -> Result<SendBonusResponse, RusotoError<SendBonusError>> {
let mut request = SignedRequest::new("POST", "mturk-requester", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "MTurkRequesterServiceV20170117.SendBonus");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<SendBonusResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(SendBonusError::from_response(response))
}
}
async fn send_test_event_notification(
&self,
input: SendTestEventNotificationRequest,
) -> Result<SendTestEventNotificationResponse, RusotoError<SendTestEventNotificationError>>
{
let mut request = SignedRequest::new("POST", "mturk-requester", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"MTurkRequesterServiceV20170117.SendTestEventNotification",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<SendTestEventNotificationResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(SendTestEventNotificationError::from_response(response))
}
}
async fn update_expiration_for_hit(
&self,
input: UpdateExpirationForHITRequest,
) -> Result<UpdateExpirationForHITResponse, RusotoError<UpdateExpirationForHITError>> {
let mut request = SignedRequest::new("POST", "mturk-requester", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"MTurkRequesterServiceV20170117.UpdateExpirationForHIT",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateExpirationForHITResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(UpdateExpirationForHITError::from_response(response))
}
}
async fn update_hit_review_status(
&self,
input: UpdateHITReviewStatusRequest,
) -> Result<UpdateHITReviewStatusResponse, RusotoError<UpdateHITReviewStatusError>> {
let mut request = SignedRequest::new("POST", "mturk-requester", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"MTurkRequesterServiceV20170117.UpdateHITReviewStatus",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateHITReviewStatusResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(UpdateHITReviewStatusError::from_response(response))
}
}
async fn update_hit_type_of_hit(
&self,
input: UpdateHITTypeOfHITRequest,
) -> Result<UpdateHITTypeOfHITResponse, RusotoError<UpdateHITTypeOfHITError>> {
let mut request = SignedRequest::new("POST", "mturk-requester", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"MTurkRequesterServiceV20170117.UpdateHITTypeOfHIT",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateHITTypeOfHITResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(UpdateHITTypeOfHITError::from_response(response))
}
}
async fn update_notification_settings(
&self,
input: UpdateNotificationSettingsRequest,
) -> Result<UpdateNotificationSettingsResponse, RusotoError<UpdateNotificationSettingsError>>
{
let mut request = SignedRequest::new("POST", "mturk-requester", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"MTurkRequesterServiceV20170117.UpdateNotificationSettings",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateNotificationSettingsResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(UpdateNotificationSettingsError::from_response(response))
}
}
async fn update_qualification_type(
&self,
input: UpdateQualificationTypeRequest,
) -> Result<UpdateQualificationTypeResponse, RusotoError<UpdateQualificationTypeError>> {
let mut request = SignedRequest::new("POST", "mturk-requester", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"MTurkRequesterServiceV20170117.UpdateQualificationType",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateQualificationTypeResponse, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(UpdateQualificationTypeError::from_response(response))
}
}
}