File Coverage

blib/lib/Paws/MTurk.pm
Criterion Covered Total %
statement 3 3 100.0
branch n/a
condition n/a
subroutine 1 1 100.0
pod n/a
total 4 4 100.0


line stmt bran cond sub pod time code
1             package Paws::MTurk;
2 1     1   4627 use Moose;
  1         3  
  1         11  
3             sub service { 'mturk-requester' }
4             sub version { '2017-01-17' }
5             sub target_prefix { 'MTurkRequesterServiceV20170117' }
6             sub json_version { "1.1" }
7             has max_attempts => (is => 'ro', isa => 'Int', default => 5);
8             has retry => (is => 'ro', isa => 'HashRef', default => sub {
9             { base => 'rand', type => 'exponential', growth_factor => 2 }
10             });
11             has retriables => (is => 'ro', isa => 'ArrayRef', default => sub { [
12             ] });
13              
14             with 'Paws::API::Caller', 'Paws::API::EndpointResolver', 'Paws::Net::V4Signature', 'Paws::Net::JsonCaller', 'Paws::Net::JsonResponse';
15              
16            
17             sub AcceptQualificationRequest {
18             my $self = shift;
19             my $call_object = $self->new_with_coercions('Paws::MTurk::AcceptQualificationRequest', @_);
20             return $self->caller->do_call($self, $call_object);
21             }
22             sub ApproveAssignment {
23             my $self = shift;
24             my $call_object = $self->new_with_coercions('Paws::MTurk::ApproveAssignment', @_);
25             return $self->caller->do_call($self, $call_object);
26             }
27             sub AssociateQualificationWithWorker {
28             my $self = shift;
29             my $call_object = $self->new_with_coercions('Paws::MTurk::AssociateQualificationWithWorker', @_);
30             return $self->caller->do_call($self, $call_object);
31             }
32             sub CreateAdditionalAssignmentsForHIT {
33             my $self = shift;
34             my $call_object = $self->new_with_coercions('Paws::MTurk::CreateAdditionalAssignmentsForHIT', @_);
35             return $self->caller->do_call($self, $call_object);
36             }
37             sub CreateHIT {
38             my $self = shift;
39             my $call_object = $self->new_with_coercions('Paws::MTurk::CreateHIT', @_);
40             return $self->caller->do_call($self, $call_object);
41             }
42             sub CreateHITType {
43             my $self = shift;
44             my $call_object = $self->new_with_coercions('Paws::MTurk::CreateHITType', @_);
45             return $self->caller->do_call($self, $call_object);
46             }
47             sub CreateHITWithHITType {
48             my $self = shift;
49             my $call_object = $self->new_with_coercions('Paws::MTurk::CreateHITWithHITType', @_);
50             return $self->caller->do_call($self, $call_object);
51             }
52             sub CreateQualificationType {
53             my $self = shift;
54             my $call_object = $self->new_with_coercions('Paws::MTurk::CreateQualificationType', @_);
55             return $self->caller->do_call($self, $call_object);
56             }
57             sub CreateWorkerBlock {
58             my $self = shift;
59             my $call_object = $self->new_with_coercions('Paws::MTurk::CreateWorkerBlock', @_);
60             return $self->caller->do_call($self, $call_object);
61             }
62             sub DeleteHIT {
63             my $self = shift;
64             my $call_object = $self->new_with_coercions('Paws::MTurk::DeleteHIT', @_);
65             return $self->caller->do_call($self, $call_object);
66             }
67             sub DeleteQualificationType {
68             my $self = shift;
69             my $call_object = $self->new_with_coercions('Paws::MTurk::DeleteQualificationType', @_);
70             return $self->caller->do_call($self, $call_object);
71             }
72             sub DeleteWorkerBlock {
73             my $self = shift;
74             my $call_object = $self->new_with_coercions('Paws::MTurk::DeleteWorkerBlock', @_);
75             return $self->caller->do_call($self, $call_object);
76             }
77             sub DisassociateQualificationFromWorker {
78             my $self = shift;
79             my $call_object = $self->new_with_coercions('Paws::MTurk::DisassociateQualificationFromWorker', @_);
80             return $self->caller->do_call($self, $call_object);
81             }
82             sub GetAccountBalance {
83             my $self = shift;
84             my $call_object = $self->new_with_coercions('Paws::MTurk::GetAccountBalance', @_);
85             return $self->caller->do_call($self, $call_object);
86             }
87             sub GetAssignment {
88             my $self = shift;
89             my $call_object = $self->new_with_coercions('Paws::MTurk::GetAssignment', @_);
90             return $self->caller->do_call($self, $call_object);
91             }
92             sub GetFileUploadURL {
93             my $self = shift;
94             my $call_object = $self->new_with_coercions('Paws::MTurk::GetFileUploadURL', @_);
95             return $self->caller->do_call($self, $call_object);
96             }
97             sub GetHIT {
98             my $self = shift;
99             my $call_object = $self->new_with_coercions('Paws::MTurk::GetHIT', @_);
100             return $self->caller->do_call($self, $call_object);
101             }
102             sub GetQualificationScore {
103             my $self = shift;
104             my $call_object = $self->new_with_coercions('Paws::MTurk::GetQualificationScore', @_);
105             return $self->caller->do_call($self, $call_object);
106             }
107             sub GetQualificationType {
108             my $self = shift;
109             my $call_object = $self->new_with_coercions('Paws::MTurk::GetQualificationType', @_);
110             return $self->caller->do_call($self, $call_object);
111             }
112             sub ListAssignmentsForHIT {
113             my $self = shift;
114             my $call_object = $self->new_with_coercions('Paws::MTurk::ListAssignmentsForHIT', @_);
115             return $self->caller->do_call($self, $call_object);
116             }
117             sub ListBonusPayments {
118             my $self = shift;
119             my $call_object = $self->new_with_coercions('Paws::MTurk::ListBonusPayments', @_);
120             return $self->caller->do_call($self, $call_object);
121             }
122             sub ListHITs {
123             my $self = shift;
124             my $call_object = $self->new_with_coercions('Paws::MTurk::ListHITs', @_);
125             return $self->caller->do_call($self, $call_object);
126             }
127             sub ListHITsForQualificationType {
128             my $self = shift;
129             my $call_object = $self->new_with_coercions('Paws::MTurk::ListHITsForQualificationType', @_);
130             return $self->caller->do_call($self, $call_object);
131             }
132             sub ListQualificationRequests {
133             my $self = shift;
134             my $call_object = $self->new_with_coercions('Paws::MTurk::ListQualificationRequests', @_);
135             return $self->caller->do_call($self, $call_object);
136             }
137             sub ListQualificationTypes {
138             my $self = shift;
139             my $call_object = $self->new_with_coercions('Paws::MTurk::ListQualificationTypes', @_);
140             return $self->caller->do_call($self, $call_object);
141             }
142             sub ListReviewableHITs {
143             my $self = shift;
144             my $call_object = $self->new_with_coercions('Paws::MTurk::ListReviewableHITs', @_);
145             return $self->caller->do_call($self, $call_object);
146             }
147             sub ListReviewPolicyResultsForHIT {
148             my $self = shift;
149             my $call_object = $self->new_with_coercions('Paws::MTurk::ListReviewPolicyResultsForHIT', @_);
150             return $self->caller->do_call($self, $call_object);
151             }
152             sub ListWorkerBlocks {
153             my $self = shift;
154             my $call_object = $self->new_with_coercions('Paws::MTurk::ListWorkerBlocks', @_);
155             return $self->caller->do_call($self, $call_object);
156             }
157             sub ListWorkersWithQualificationType {
158             my $self = shift;
159             my $call_object = $self->new_with_coercions('Paws::MTurk::ListWorkersWithQualificationType', @_);
160             return $self->caller->do_call($self, $call_object);
161             }
162             sub NotifyWorkers {
163             my $self = shift;
164             my $call_object = $self->new_with_coercions('Paws::MTurk::NotifyWorkers', @_);
165             return $self->caller->do_call($self, $call_object);
166             }
167             sub RejectAssignment {
168             my $self = shift;
169             my $call_object = $self->new_with_coercions('Paws::MTurk::RejectAssignment', @_);
170             return $self->caller->do_call($self, $call_object);
171             }
172             sub RejectQualificationRequest {
173             my $self = shift;
174             my $call_object = $self->new_with_coercions('Paws::MTurk::RejectQualificationRequest', @_);
175             return $self->caller->do_call($self, $call_object);
176             }
177             sub SendBonus {
178             my $self = shift;
179             my $call_object = $self->new_with_coercions('Paws::MTurk::SendBonus', @_);
180             return $self->caller->do_call($self, $call_object);
181             }
182             sub SendTestEventNotification {
183             my $self = shift;
184             my $call_object = $self->new_with_coercions('Paws::MTurk::SendTestEventNotification', @_);
185             return $self->caller->do_call($self, $call_object);
186             }
187             sub UpdateExpirationForHIT {
188             my $self = shift;
189             my $call_object = $self->new_with_coercions('Paws::MTurk::UpdateExpirationForHIT', @_);
190             return $self->caller->do_call($self, $call_object);
191             }
192             sub UpdateHITReviewStatus {
193             my $self = shift;
194             my $call_object = $self->new_with_coercions('Paws::MTurk::UpdateHITReviewStatus', @_);
195             return $self->caller->do_call($self, $call_object);
196             }
197             sub UpdateHITTypeOfHIT {
198             my $self = shift;
199             my $call_object = $self->new_with_coercions('Paws::MTurk::UpdateHITTypeOfHIT', @_);
200             return $self->caller->do_call($self, $call_object);
201             }
202             sub UpdateNotificationSettings {
203             my $self = shift;
204             my $call_object = $self->new_with_coercions('Paws::MTurk::UpdateNotificationSettings', @_);
205             return $self->caller->do_call($self, $call_object);
206             }
207             sub UpdateQualificationType {
208             my $self = shift;
209             my $call_object = $self->new_with_coercions('Paws::MTurk::UpdateQualificationType', @_);
210             return $self->caller->do_call($self, $call_object);
211             }
212            
213              
214              
215             sub operations { qw/AcceptQualificationRequest ApproveAssignment AssociateQualificationWithWorker CreateAdditionalAssignmentsForHIT CreateHIT CreateHITType CreateHITWithHITType CreateQualificationType CreateWorkerBlock DeleteHIT DeleteQualificationType DeleteWorkerBlock DisassociateQualificationFromWorker GetAccountBalance GetAssignment GetFileUploadURL GetHIT GetQualificationScore GetQualificationType ListAssignmentsForHIT ListBonusPayments ListHITs ListHITsForQualificationType ListQualificationRequests ListQualificationTypes ListReviewableHITs ListReviewPolicyResultsForHIT ListWorkerBlocks ListWorkersWithQualificationType NotifyWorkers RejectAssignment RejectQualificationRequest SendBonus SendTestEventNotification UpdateExpirationForHIT UpdateHITReviewStatus UpdateHITTypeOfHIT UpdateNotificationSettings UpdateQualificationType / }
216              
217             1;
218              
219             ### main pod documentation begin ###
220              
221             =head1 NAME
222              
223             Paws::MTurk - Perl Interface to AWS Amazon Mechanical Turk
224              
225             =head1 SYNOPSIS
226              
227             use Paws;
228              
229             my $obj = Paws->service('MTurk');
230             my $res = $obj->Method(
231             Arg1 => $val1,
232             Arg2 => [ 'V1', 'V2' ],
233             # if Arg3 is an object, the HashRef will be used as arguments to the constructor
234             # of the arguments type
235             Arg3 => { Att1 => 'Val1' },
236             # if Arg4 is an array of objects, the HashRefs will be passed as arguments to
237             # the constructor of the arguments type
238             Arg4 => [ { Att1 => 'Val1' }, { Att1 => 'Val2' } ],
239             );
240              
241             =head1 DESCRIPTION
242              
243             Amazon Mechanical Turk API Reference
244              
245             =head1 METHODS
246              
247             =head2 AcceptQualificationRequest(QualificationRequestId => Str, [IntegerValue => Int])
248              
249             Each argument is described in detail in: L<Paws::MTurk::AcceptQualificationRequest>
250              
251             Returns: a L<Paws::MTurk::AcceptQualificationRequestResponse> instance
252              
253             The C<AcceptQualificationRequest> operation approves a Worker's request
254             for a Qualification.
255              
256             Only the owner of the Qualification type can grant a Qualification
257             request for that type.
258              
259             A successful request for the C<AcceptQualificationRequest> operation
260             returns with no errors and an empty body.
261              
262              
263             =head2 ApproveAssignment(AssignmentId => Str, [OverrideRejection => Bool, RequesterFeedback => Str])
264              
265             Each argument is described in detail in: L<Paws::MTurk::ApproveAssignment>
266              
267             Returns: a L<Paws::MTurk::ApproveAssignmentResponse> instance
268              
269             The C<ApproveAssignment> operation approves the results of a completed
270             assignment.
271              
272             Approving an assignment initiates two payments from the Requester's
273             Amazon.com account
274              
275             =over
276              
277             =item *
278              
279             The Worker who submitted the results is paid the reward specified in
280             the HIT.
281              
282             =item *
283              
284             Amazon Mechanical Turk fees are debited.
285              
286             =back
287              
288             If the Requester's account does not have adequate funds for these
289             payments, the call to ApproveAssignment returns an exception, and the
290             approval is not processed. You can include an optional feedback message
291             with the approval, which the Worker can see in the Status section of
292             the web site.
293              
294             You can also call this operation for assignments that were previous
295             rejected and approve them by explicitly overriding the previous
296             rejection. This only works on rejected assignments that were submitted
297             within the previous 30 days and only if the assignment's related HIT
298             has not been deleted.
299              
300              
301             =head2 AssociateQualificationWithWorker(QualificationTypeId => Str, WorkerId => Str, [IntegerValue => Int, SendNotification => Bool])
302              
303             Each argument is described in detail in: L<Paws::MTurk::AssociateQualificationWithWorker>
304              
305             Returns: a L<Paws::MTurk::AssociateQualificationWithWorkerResponse> instance
306              
307             The C<AssociateQualificationWithWorker> operation gives a Worker a
308             Qualification. C<AssociateQualificationWithWorker> does not require
309             that the Worker submit a Qualification request. It gives the
310             Qualification directly to the Worker.
311              
312             You can only assign a Qualification of a Qualification type that you
313             created (using the C<CreateQualificationType> operation).
314              
315             Note: C<AssociateQualificationWithWorker> does not affect any pending
316             Qualification requests for the Qualification by the Worker. If you
317             assign a Qualification to a Worker, then later grant a Qualification
318             request made by the Worker, the granting of the request may modify the
319             Qualification score. To resolve a pending Qualification request without
320             affecting the Qualification the Worker already has, reject the request
321             with the C<RejectQualificationRequest> operation.
322              
323              
324             =head2 CreateAdditionalAssignmentsForHIT(HITId => Str, NumberOfAdditionalAssignments => Int, [UniqueRequestToken => Str])
325              
326             Each argument is described in detail in: L<Paws::MTurk::CreateAdditionalAssignmentsForHIT>
327              
328             Returns: a L<Paws::MTurk::CreateAdditionalAssignmentsForHITResponse> instance
329              
330             The C<CreateAdditionalAssignmentsForHIT> operation increases the
331             maximum number of assignments of an existing HIT.
332              
333             To extend the maximum number of assignments, specify the number of
334             additional assignments.
335              
336             =over
337              
338             =item *
339              
340             HITs created with fewer than 10 assignments cannot be extended to have
341             10 or more assignments. Attempting to add assignments in a way that
342             brings the total number of assignments for a HIT from fewer than 10
343             assignments to 10 or more assignments will result in an
344             C<AWS.MechanicalTurk.InvalidMaximumAssignmentsIncrease> exception.
345              
346             =item *
347              
348             HITs that were created before July 22, 2015 cannot be extended.
349             Attempting to extend HITs that were created before July 22, 2015 will
350             result in an C<AWS.MechanicalTurk.HITTooOldForExtension> exception.
351              
352             =back
353              
354              
355              
356             =head2 CreateHIT(AssignmentDurationInSeconds => Int, Description => Str, LifetimeInSeconds => Int, Reward => Str, Title => Str, [AssignmentReviewPolicy => L<Paws::MTurk::ReviewPolicy>, AutoApprovalDelayInSeconds => Int, HITLayoutId => Str, HITLayoutParameters => ArrayRef[L<Paws::MTurk::HITLayoutParameter>], HITReviewPolicy => L<Paws::MTurk::ReviewPolicy>, Keywords => Str, MaxAssignments => Int, QualificationRequirements => ArrayRef[L<Paws::MTurk::QualificationRequirement>], Question => Str, RequesterAnnotation => Str, UniqueRequestToken => Str])
357              
358             Each argument is described in detail in: L<Paws::MTurk::CreateHIT>
359              
360             Returns: a L<Paws::MTurk::CreateHITResponse> instance
361              
362             The C<CreateHIT> operation creates a new Human Intelligence Task (HIT).
363             The new HIT is made available for Workers to find and accept on the
364             Amazon Mechanical Turk website.
365              
366             This operation allows you to specify a new HIT by passing in values for
367             the properties of the HIT, such as its title, reward amount and number
368             of assignments. When you pass these values to C<CreateHIT>, a new HIT
369             is created for you, with a new C<HITTypeID>. The HITTypeID can be used
370             to create additional HITs in the future without needing to specify
371             common parameters such as the title, description and reward amount each
372             time.
373              
374             An alternative way to create HITs is to first generate a HITTypeID
375             using the C<CreateHITType> operation and then call the
376             C<CreateHITWithHITType> operation. This is the recommended best
377             practice for Requesters who are creating large numbers of HITs.
378              
379             CreateHIT also supports several ways to provide question data: by
380             providing a value for the C<Question> parameter that fully specifies
381             the contents of the HIT, or by providing a C<HitLayoutId> and
382             associated C<HitLayoutParameters>.
383              
384             If a HIT is created with 10 or more maximum assignments, there is an
385             additional fee. For more information, see Amazon Mechanical Turk
386             Pricing.
387              
388              
389             =head2 CreateHITType(AssignmentDurationInSeconds => Int, Description => Str, Reward => Str, Title => Str, [AutoApprovalDelayInSeconds => Int, Keywords => Str, QualificationRequirements => ArrayRef[L<Paws::MTurk::QualificationRequirement>]])
390              
391             Each argument is described in detail in: L<Paws::MTurk::CreateHITType>
392              
393             Returns: a L<Paws::MTurk::CreateHITTypeResponse> instance
394              
395             The C<CreateHITType> operation creates a new HIT type. This operation
396             allows you to define a standard set of HIT properties to use when
397             creating HITs. If you register a HIT type with values that match an
398             existing HIT type, the HIT type ID of the existing type will be
399             returned.
400              
401              
402             =head2 CreateHITWithHITType(HITTypeId => Str, LifetimeInSeconds => Int, [AssignmentReviewPolicy => L<Paws::MTurk::ReviewPolicy>, HITLayoutId => Str, HITLayoutParameters => ArrayRef[L<Paws::MTurk::HITLayoutParameter>], HITReviewPolicy => L<Paws::MTurk::ReviewPolicy>, MaxAssignments => Int, Question => Str, RequesterAnnotation => Str, UniqueRequestToken => Str])
403              
404             Each argument is described in detail in: L<Paws::MTurk::CreateHITWithHITType>
405              
406             Returns: a L<Paws::MTurk::CreateHITWithHITTypeResponse> instance
407              
408             The C<CreateHITWithHITType> operation creates a new Human Intelligence
409             Task (HIT) using an existing HITTypeID generated by the
410             C<CreateHITType> operation.
411              
412             This is an alternative way to create HITs from the C<CreateHIT>
413             operation. This is the recommended best practice for Requesters who are
414             creating large numbers of HITs.
415              
416             CreateHITWithHITType also supports several ways to provide question
417             data: by providing a value for the C<Question> parameter that fully
418             specifies the contents of the HIT, or by providing a C<HitLayoutId> and
419             associated C<HitLayoutParameters>.
420              
421             If a HIT is created with 10 or more maximum assignments, there is an
422             additional fee. For more information, see Amazon Mechanical Turk
423             Pricing.
424              
425              
426             =head2 CreateQualificationType(Description => Str, Name => Str, QualificationTypeStatus => Str, [AnswerKey => Str, AutoGranted => Bool, AutoGrantedValue => Int, Keywords => Str, RetryDelayInSeconds => Int, Test => Str, TestDurationInSeconds => Int])
427              
428             Each argument is described in detail in: L<Paws::MTurk::CreateQualificationType>
429              
430             Returns: a L<Paws::MTurk::CreateQualificationTypeResponse> instance
431              
432             The C<CreateQualificationType> operation creates a new Qualification
433             type, which is represented by a C<QualificationType> data structure.
434              
435              
436             =head2 CreateWorkerBlock(Reason => Str, WorkerId => Str)
437              
438             Each argument is described in detail in: L<Paws::MTurk::CreateWorkerBlock>
439              
440             Returns: a L<Paws::MTurk::CreateWorkerBlockResponse> instance
441              
442             The C<CreateWorkerBlock> operation allows you to prevent a Worker from
443             working on your HITs. For example, you can block a Worker who is
444             producing poor quality work. You can block up to 100,000 Workers.
445              
446              
447             =head2 DeleteHIT(HITId => Str)
448              
449             Each argument is described in detail in: L<Paws::MTurk::DeleteHIT>
450              
451             Returns: a L<Paws::MTurk::DeleteHITResponse> instance
452              
453             The C<DeleteHIT> operation is used to delete HIT that is no longer
454             needed. Only the Requester who created the HIT can delete it.
455              
456             You can only dispose of HITs that are in the C<Reviewable> state, with
457             all of their submitted assignments already either approved or rejected.
458             If you call the DeleteHIT operation on a HIT that is not in the
459             C<Reviewable> state (for example, that has not expired, or still has
460             active assignments), or on a HIT that is Reviewable but without all of
461             its submitted assignments already approved or rejected, the service
462             will return an error.
463              
464             =over
465              
466             =item *
467              
468             HITs are automatically disposed of after 120 days.
469              
470             =item *
471              
472             After you dispose of a HIT, you can no longer approve the HIT's
473             rejected assignments.
474              
475             =item *
476              
477             Disposed HITs are not returned in results for the ListHITs operation.
478              
479             =item *
480              
481             Disposing HITs can improve the performance of operations such as
482             ListReviewableHITs and ListHITs.
483              
484             =back
485              
486              
487              
488             =head2 DeleteQualificationType(QualificationTypeId => Str)
489              
490             Each argument is described in detail in: L<Paws::MTurk::DeleteQualificationType>
491              
492             Returns: a L<Paws::MTurk::DeleteQualificationTypeResponse> instance
493              
494             The C<DeleteQualificationType> deletes a Qualification type and deletes
495             any HIT types that are associated with the Qualification type.
496              
497             This operation does not revoke Qualifications already assigned to
498             Workers because the Qualifications might be needed for active HITs. If
499             there are any pending requests for the Qualification type, Amazon
500             Mechanical Turk rejects those requests. After you delete a
501             Qualification type, you can no longer use it to create HITs or HIT
502             types.
503              
504             DeleteQualificationType must wait for all the HITs that use the deleted
505             Qualification type to be deleted before completing. It may take up to
506             48 hours before DeleteQualificationType completes and the unique name
507             of the Qualification type is available for reuse with
508             CreateQualificationType.
509              
510              
511             =head2 DeleteWorkerBlock(WorkerId => Str, [Reason => Str])
512              
513             Each argument is described in detail in: L<Paws::MTurk::DeleteWorkerBlock>
514              
515             Returns: a L<Paws::MTurk::DeleteWorkerBlockResponse> instance
516              
517             The C<DeleteWorkerBlock> operation allows you to reinstate a blocked
518             Worker to work on your HITs. This operation reverses the effects of the
519             CreateWorkerBlock operation. You need the Worker ID to use this
520             operation. If the Worker ID is missing or invalid, this operation fails
521             and returns the message E<ldquo>WorkerId is invalid.E<rdquo> If the
522             specified Worker is not blocked, this operation returns successfully.
523              
524              
525             =head2 DisassociateQualificationFromWorker(QualificationTypeId => Str, WorkerId => Str, [Reason => Str])
526              
527             Each argument is described in detail in: L<Paws::MTurk::DisassociateQualificationFromWorker>
528              
529             Returns: a L<Paws::MTurk::DisassociateQualificationFromWorkerResponse> instance
530              
531             The C<DisassociateQualificationFromWorker> revokes a previously granted
532             Qualification from a user.
533              
534             You can provide a text message explaining why the Qualification was
535             revoked. The user who had the Qualification can see this message.
536              
537              
538             =head2 GetAccountBalance()
539              
540             Each argument is described in detail in: L<Paws::MTurk::GetAccountBalance>
541              
542             Returns: a L<Paws::MTurk::GetAccountBalanceResponse> instance
543              
544             The C<GetAccountBalance> operation retrieves the amount of money in
545             your Amazon Mechanical Turk account.
546              
547              
548             =head2 GetAssignment(AssignmentId => Str)
549              
550             Each argument is described in detail in: L<Paws::MTurk::GetAssignment>
551              
552             Returns: a L<Paws::MTurk::GetAssignmentResponse> instance
553              
554             The C<GetAssignment> operation retrieves the details of the specified
555             Assignment.
556              
557              
558             =head2 GetFileUploadURL(AssignmentId => Str, QuestionIdentifier => Str)
559              
560             Each argument is described in detail in: L<Paws::MTurk::GetFileUploadURL>
561              
562             Returns: a L<Paws::MTurk::GetFileUploadURLResponse> instance
563              
564             The C<GetFileUploadURL> operation generates and returns a temporary
565             URL. You use the temporary URL to retrieve a file uploaded by a Worker
566             as an answer to a FileUploadAnswer question for a HIT. The temporary
567             URL is generated the instant the GetFileUploadURL operation is called,
568             and is valid for 60 seconds. You can get a temporary file upload URL
569             any time until the HIT is disposed. After the HIT is disposed, any
570             uploaded files are deleted, and cannot be retrieved.
571              
572              
573             =head2 GetHIT(HITId => Str)
574              
575             Each argument is described in detail in: L<Paws::MTurk::GetHIT>
576              
577             Returns: a L<Paws::MTurk::GetHITResponse> instance
578              
579             The C<GetHIT> operation retrieves the details of the specified HIT.
580              
581              
582             =head2 GetQualificationScore(QualificationTypeId => Str, WorkerId => Str)
583              
584             Each argument is described in detail in: L<Paws::MTurk::GetQualificationScore>
585              
586             Returns: a L<Paws::MTurk::GetQualificationScoreResponse> instance
587              
588             The C<GetQualificationScore> operation returns the value of a Worker's
589             Qualification for a given Qualification type.
590              
591             To get a Worker's Qualification, you must know the Worker's ID. The
592             Worker's ID is included in the assignment data returned by the
593             C<ListAssignmentsForHIT> operation.
594              
595             Only the owner of a Qualification type can query the value of a
596             Worker's Qualification of that type.
597              
598              
599             =head2 GetQualificationType(QualificationTypeId => Str)
600              
601             Each argument is described in detail in: L<Paws::MTurk::GetQualificationType>
602              
603             Returns: a L<Paws::MTurk::GetQualificationTypeResponse> instance
604              
605             The C<GetQualificationType>operation retrieves information about a
606             Qualification type using its ID.
607              
608              
609             =head2 ListAssignmentsForHIT(HITId => Str, [AssignmentStatuses => ArrayRef[Str|Undef], MaxResults => Int, NextToken => Str])
610              
611             Each argument is described in detail in: L<Paws::MTurk::ListAssignmentsForHIT>
612              
613             Returns: a L<Paws::MTurk::ListAssignmentsForHITResponse> instance
614              
615             The C<ListAssignmentsForHIT> operation retrieves completed assignments
616             for a HIT. You can use this operation to retrieve the results for a
617             HIT.
618              
619             You can get assignments for a HIT at any time, even if the HIT is not
620             yet Reviewable. If a HIT requested multiple assignments, and has
621             received some results but has not yet become Reviewable, you can still
622             retrieve the partial results with this operation.
623              
624             Use the AssignmentStatus parameter to control which set of assignments
625             for a HIT are returned. The ListAssignmentsForHIT operation can return
626             submitted assignments awaiting approval, or it can return assignments
627             that have already been approved or rejected. You can set
628             AssignmentStatus=Approved,Rejected to get assignments that have already
629             been approved and rejected together in one result set.
630              
631             Only the Requester who created the HIT can retrieve the assignments for
632             that HIT.
633              
634             Results are sorted and divided into numbered pages and the operation
635             returns a single page of results. You can use the parameters of the
636             operation to control sorting and pagination.
637              
638              
639             =head2 ListBonusPayments([AssignmentId => Str, HITId => Str, MaxResults => Int, NextToken => Str])
640              
641             Each argument is described in detail in: L<Paws::MTurk::ListBonusPayments>
642              
643             Returns: a L<Paws::MTurk::ListBonusPaymentsResponse> instance
644              
645             The C<ListBonusPayments> operation retrieves the amounts of bonuses you
646             have paid to Workers for a given HIT or assignment.
647              
648              
649             =head2 ListHITs([MaxResults => Int, NextToken => Str])
650              
651             Each argument is described in detail in: L<Paws::MTurk::ListHITs>
652              
653             Returns: a L<Paws::MTurk::ListHITsResponse> instance
654              
655             The C<ListHITs> operation returns all of a Requester's HITs. The
656             operation returns HITs of any status, except for HITs that have been
657             deleted of with the DeleteHIT operation or that have been auto-deleted.
658              
659              
660             =head2 ListHITsForQualificationType(QualificationTypeId => Str, [MaxResults => Int, NextToken => Str])
661              
662             Each argument is described in detail in: L<Paws::MTurk::ListHITsForQualificationType>
663              
664             Returns: a L<Paws::MTurk::ListHITsForQualificationTypeResponse> instance
665              
666             The C<ListHITsForQualificationType> operation returns the HITs that use
667             the given Qualification type for a Qualification requirement. The
668             operation returns HITs of any status, except for HITs that have been
669             deleted with the C<DeleteHIT> operation or that have been auto-deleted.
670              
671              
672             =head2 ListQualificationRequests([MaxResults => Int, NextToken => Str, QualificationTypeId => Str])
673              
674             Each argument is described in detail in: L<Paws::MTurk::ListQualificationRequests>
675              
676             Returns: a L<Paws::MTurk::ListQualificationRequestsResponse> instance
677              
678             The C<ListQualificationRequests> operation retrieves requests for
679             Qualifications of a particular Qualification type. The owner of the
680             Qualification type calls this operation to poll for pending requests,
681             and accepts them using the AcceptQualification operation.
682              
683              
684             =head2 ListQualificationTypes(MustBeRequestable => Bool, [MaxResults => Int, MustBeOwnedByCaller => Bool, NextToken => Str, Query => Str])
685              
686             Each argument is described in detail in: L<Paws::MTurk::ListQualificationTypes>
687              
688             Returns: a L<Paws::MTurk::ListQualificationTypesResponse> instance
689              
690             The C<ListQualificationRequests> operation retrieves requests for
691             Qualifications of a particular Qualification type. The owner of the
692             Qualification type calls this operation to poll for pending requests,
693             and accepts them using the AcceptQualification operation.
694              
695              
696             =head2 ListReviewableHITs([HITTypeId => Str, MaxResults => Int, NextToken => Str, Status => Str])
697              
698             Each argument is described in detail in: L<Paws::MTurk::ListReviewableHITs>
699              
700             Returns: a L<Paws::MTurk::ListReviewableHITsResponse> instance
701              
702             The C<ListReviewableHITs> operation retrieves the HITs with Status
703             equal to Reviewable or Status equal to Reviewing that belong to the
704             Requester calling the operation.
705              
706              
707             =head2 ListReviewPolicyResultsForHIT(HITId => Str, [MaxResults => Int, NextToken => Str, PolicyLevels => ArrayRef[Str|Undef], RetrieveActions => Bool, RetrieveResults => Bool])
708              
709             Each argument is described in detail in: L<Paws::MTurk::ListReviewPolicyResultsForHIT>
710              
711             Returns: a L<Paws::MTurk::ListReviewPolicyResultsForHITResponse> instance
712              
713             The C<ListReviewPolicyResultsForHIT> operation retrieves the computed
714             results and the actions taken in the course of executing your Review
715             Policies for a given HIT. For information about how to specify Review
716             Policies when you call CreateHIT, see Review Policies. The
717             ListReviewPolicyResultsForHIT operation can return results for both
718             Assignment-level and HIT-level review results.
719              
720              
721             =head2 ListWorkerBlocks([MaxResults => Int, NextToken => Str])
722              
723             Each argument is described in detail in: L<Paws::MTurk::ListWorkerBlocks>
724              
725             Returns: a L<Paws::MTurk::ListWorkerBlocksResponse> instance
726              
727             The C<ListWorkersBlocks> operation retrieves a list of Workers who are
728             blocked from working on your HITs.
729              
730              
731             =head2 ListWorkersWithQualificationType(QualificationTypeId => Str, [MaxResults => Int, NextToken => Str, Status => Str])
732              
733             Each argument is described in detail in: L<Paws::MTurk::ListWorkersWithQualificationType>
734              
735             Returns: a L<Paws::MTurk::ListWorkersWithQualificationTypeResponse> instance
736              
737             The C<ListWorkersWithQualificationType> operation returns all of the
738             Workers that have been associated with a given Qualification type.
739              
740              
741             =head2 NotifyWorkers(MessageText => Str, Subject => Str, WorkerIds => ArrayRef[Str|Undef])
742              
743             Each argument is described in detail in: L<Paws::MTurk::NotifyWorkers>
744              
745             Returns: a L<Paws::MTurk::NotifyWorkersResponse> instance
746              
747             The C<NotifyWorkers> operation sends an email to one or more Workers
748             that you specify with the Worker ID. You can specify up to 100 Worker
749             IDs to send the same message with a single call to the NotifyWorkers
750             operation. The NotifyWorkers operation will send a notification email
751             to a Worker only if you have previously approved or rejected work from
752             the Worker.
753              
754              
755             =head2 RejectAssignment(AssignmentId => Str, RequesterFeedback => Str)
756              
757             Each argument is described in detail in: L<Paws::MTurk::RejectAssignment>
758              
759             Returns: a L<Paws::MTurk::RejectAssignmentResponse> instance
760              
761             The C<RejectAssignment> operation rejects the results of a completed
762             assignment.
763              
764             You can include an optional feedback message with the rejection, which
765             the Worker can see in the Status section of the web site. When you
766             include a feedback message with the rejection, it helps the Worker
767             understand why the assignment was rejected, and can improve the quality
768             of the results the Worker submits in the future.
769              
770             Only the Requester who created the HIT can reject an assignment for the
771             HIT.
772              
773              
774             =head2 RejectQualificationRequest(QualificationRequestId => Str, [Reason => Str])
775              
776             Each argument is described in detail in: L<Paws::MTurk::RejectQualificationRequest>
777              
778             Returns: a L<Paws::MTurk::RejectQualificationRequestResponse> instance
779              
780             The C<RejectQualificationRequest> operation rejects a user's request
781             for a Qualification.
782              
783             You can provide a text message explaining why the request was rejected.
784             The Worker who made the request can see this message.
785              
786              
787             =head2 SendBonus(AssignmentId => Str, BonusAmount => Str, Reason => Str, WorkerId => Str, [UniqueRequestToken => Str])
788              
789             Each argument is described in detail in: L<Paws::MTurk::SendBonus>
790              
791             Returns: a L<Paws::MTurk::SendBonusResponse> instance
792              
793             The C<SendBonus> operation issues a payment of money from your account
794             to a Worker. This payment happens separately from the reward you pay to
795             the Worker when you approve the Worker's assignment. The SendBonus
796             operation requires the Worker's ID and the assignment ID as parameters
797             to initiate payment of the bonus. You must include a message that
798             explains the reason for the bonus payment, as the Worker may not be
799             expecting the payment. Amazon Mechanical Turk collects a fee for bonus
800             payments, similar to the HIT listing fee. This operation fails if your
801             account does not have enough funds to pay for both the bonus and the
802             fees.
803              
804              
805             =head2 SendTestEventNotification(Notification => L<Paws::MTurk::NotificationSpecification>, TestEventType => Str)
806              
807             Each argument is described in detail in: L<Paws::MTurk::SendTestEventNotification>
808              
809             Returns: a L<Paws::MTurk::SendTestEventNotificationResponse> instance
810              
811             The C<SendTestEventNotification> operation causes Amazon Mechanical
812             Turk to send a notification message as if a HIT event occurred,
813             according to the provided notification specification. This allows you
814             to test notifications without setting up notifications for a real HIT
815             type and trying to trigger them using the website. When you call this
816             operation, the service attempts to send the test notification
817             immediately.
818              
819              
820             =head2 UpdateExpirationForHIT(ExpireAt => Str, HITId => Str)
821              
822             Each argument is described in detail in: L<Paws::MTurk::UpdateExpirationForHIT>
823              
824             Returns: a L<Paws::MTurk::UpdateExpirationForHITResponse> instance
825              
826             The C<UpdateExpirationForHIT> operation allows you update the
827             expiration time of a HIT. If you update it to a time in the past, the
828             HIT will be immediately expired.
829              
830              
831             =head2 UpdateHITReviewStatus(HITId => Str, [Revert => Bool])
832              
833             Each argument is described in detail in: L<Paws::MTurk::UpdateHITReviewStatus>
834              
835             Returns: a L<Paws::MTurk::UpdateHITReviewStatusResponse> instance
836              
837             The C<UpdateHITReviewStatus> operation updates the status of a HIT. If
838             the status is Reviewable, this operation can update the status to
839             Reviewing, or it can revert a Reviewing HIT back to the Reviewable
840             status.
841              
842              
843             =head2 UpdateHITTypeOfHIT(HITId => Str, HITTypeId => Str)
844              
845             Each argument is described in detail in: L<Paws::MTurk::UpdateHITTypeOfHIT>
846              
847             Returns: a L<Paws::MTurk::UpdateHITTypeOfHITResponse> instance
848              
849             The C<UpdateHITTypeOfHIT> operation allows you to change the HITType
850             properties of a HIT. This operation disassociates the HIT from its old
851             HITType properties and associates it with the new HITType properties.
852             The HIT takes on the properties of the new HITType in place of the old
853             ones.
854              
855              
856             =head2 UpdateNotificationSettings(HITTypeId => Str, [Active => Bool, Notification => L<Paws::MTurk::NotificationSpecification>])
857              
858             Each argument is described in detail in: L<Paws::MTurk::UpdateNotificationSettings>
859              
860             Returns: a L<Paws::MTurk::UpdateNotificationSettingsResponse> instance
861              
862             The C<UpdateNotificationSettings> operation creates, updates, disables
863             or re-enables notifications for a HIT type. If you call the
864             UpdateNotificationSettings operation for a HIT type that already has a
865             notification specification, the operation replaces the old
866             specification with a new one. You can call the
867             UpdateNotificationSettings operation to enable or disable notifications
868             for the HIT type, without having to modify the notification
869             specification itself by providing updates to the Active status without
870             specifying a new notification specification. To change the Active
871             status of a HIT type's notifications, the HIT type must already have a
872             notification specification, or one must be provided in the same call to
873             C<UpdateNotificationSettings>.
874              
875              
876             =head2 UpdateQualificationType(QualificationTypeId => Str, [AnswerKey => Str, AutoGranted => Bool, AutoGrantedValue => Int, Description => Str, QualificationTypeStatus => Str, RetryDelayInSeconds => Int, Test => Str, TestDurationInSeconds => Int])
877              
878             Each argument is described in detail in: L<Paws::MTurk::UpdateQualificationType>
879              
880             Returns: a L<Paws::MTurk::UpdateQualificationTypeResponse> instance
881              
882             The C<UpdateQualificationType> operation modifies the attributes of an
883             existing Qualification type, which is represented by a
884             QualificationType data structure. Only the owner of a Qualification
885             type can modify its attributes.
886              
887             Most attributes of a Qualification type can be changed after the type
888             has been created. However, the Name and Keywords fields cannot be
889             modified. The RetryDelayInSeconds parameter can be modified or added to
890             change the delay or to enable retries, but RetryDelayInSeconds cannot
891             be used to disable retries.
892              
893             You can use this operation to update the test for a Qualification type.
894             The test is updated based on the values specified for the Test,
895             TestDurationInSeconds and AnswerKey parameters. All three parameters
896             specify the updated test. If you are updating the test for a type, you
897             must specify the Test and TestDurationInSeconds parameters. The
898             AnswerKey parameter is optional; omitting it specifies that the updated
899             test does not have an answer key.
900              
901             If you omit the Test parameter, the test for the Qualification type is
902             unchanged. There is no way to remove a test from a Qualification type
903             that has one. If the type already has a test, you cannot update it to
904             be AutoGranted. If the Qualification type does not have a test and one
905             is provided by an update, the type will henceforth have a test.
906              
907             If you want to update the test duration or answer key for an existing
908             test without changing the questions, you must specify a Test parameter
909             with the original questions, along with the updated values.
910              
911             If you provide an updated Test but no AnswerKey, the new test will not
912             have an answer key. Requests for such Qualifications must be granted
913             manually.
914              
915             You can also update the AutoGranted and AutoGrantedValue attributes of
916             the Qualification type.
917              
918              
919              
920              
921             =head1 PAGINATORS
922              
923             Paginator methods are helpers that repetively call methods that return partial results
924              
925              
926              
927              
928             =head1 SEE ALSO
929              
930             This service class forms part of L<Paws>
931              
932             =head1 BUGS and CONTRIBUTIONS
933              
934             The source code is located here: https://github.com/pplu/aws-sdk-perl
935              
936             Please report bugs to: https://github.com/pplu/aws-sdk-perl/issues
937              
938             =cut
939