blib/lib/Paws/MTurk.pm untested

filter: Statementstmt 0.0% 0 / 312 Branchbran 0.0% 0 / 36 Conditioncond n/a MC/DCmcdc n/a Subroutinesub 0.0% 0 / 55 Podpod 0.0% 0 / 54 totaltotal 0.0% 0 / 457 CC 19 SCAR 17.4
CC
19
Cov
0%
ListAllAssignmentsForHIT
12.0
ListAllBonusPayments
12.0
ListAllHITs
12.0
CRAP 5.7
1 package Paws::MTurk;
2 use Moose;
3 sub service { 'mturk-requester' }
4 sub signing_name { 'mturk-requester' }
5 sub version { '2017-01-17' }
6 sub target_prefix { 'MTurkRequesterServiceV20170117' }
7 sub json_version { "1.1" }
8 has max_attempts => (is => 'ro', isa => 'Int', default => 5);
9 has retry => (is => 'ro', isa => 'HashRef', default => sub {
10 { base => 'rand', type => 'exponential', growth_factor => 2 }
11 });
12 has retriables => (is => 'ro', isa => 'ArrayRef', default => sub { [
13 ] });
14  
15 with 'Paws::API::Caller', 'Paws::API::EndpointResolver', 'Paws::Net::V4Signature', 'Paws::Net::JsonCaller';
16  
17
18 sub AcceptQualificationRequest {
19 my $self = shift;
20 my $call_object = $self->new_with_coercions('Paws::MTurk::AcceptQualificationRequest', @_);
21 return $self->caller->do_call($self, $call_object);
22 }
23 sub ApproveAssignment {
24 my $self = shift;
25 my $call_object = $self->new_with_coercions('Paws::MTurk::ApproveAssignment', @_);
26 return $self->caller->do_call($self, $call_object);
27 }
28 sub AssociateQualificationWithWorker {
29 my $self = shift;
30 my $call_object = $self->new_with_coercions('Paws::MTurk::AssociateQualificationWithWorker', @_);
31 return $self->caller->do_call($self, $call_object);
32 }
33 sub CreateAdditionalAssignmentsForHIT {
34 my $self = shift;
35 my $call_object = $self->new_with_coercions('Paws::MTurk::CreateAdditionalAssignmentsForHIT', @_);
36 return $self->caller->do_call($self, $call_object);
37 }
38 sub CreateHIT {
39 my $self = shift;
40 my $call_object = $self->new_with_coercions('Paws::MTurk::CreateHIT', @_);
41 return $self->caller->do_call($self, $call_object);
42 }
43 sub CreateHITType {
44 my $self = shift;
45 my $call_object = $self->new_with_coercions('Paws::MTurk::CreateHITType', @_);
46 return $self->caller->do_call($self, $call_object);
47 }
48 sub CreateHITWithHITType {
49 my $self = shift;
50 my $call_object = $self->new_with_coercions('Paws::MTurk::CreateHITWithHITType', @_);
51 return $self->caller->do_call($self, $call_object);
52 }
53 sub CreateQualificationType {
54 my $self = shift;
55 my $call_object = $self->new_with_coercions('Paws::MTurk::CreateQualificationType', @_);
56 return $self->caller->do_call($self, $call_object);
57 }
58 sub CreateWorkerBlock {
59 my $self = shift;
60 my $call_object = $self->new_with_coercions('Paws::MTurk::CreateWorkerBlock', @_);
61 return $self->caller->do_call($self, $call_object);
62 }
63 sub DeleteHIT {
64 my $self = shift;
65 my $call_object = $self->new_with_coercions('Paws::MTurk::DeleteHIT', @_);
66 return $self->caller->do_call($self, $call_object);
67 }
68 sub DeleteQualificationType {
69 my $self = shift;
70 my $call_object = $self->new_with_coercions('Paws::MTurk::DeleteQualificationType', @_);
71 return $self->caller->do_call($self, $call_object);
72 }
73 sub DeleteWorkerBlock {
74 my $self = shift;
75 my $call_object = $self->new_with_coercions('Paws::MTurk::DeleteWorkerBlock', @_);
76 return $self->caller->do_call($self, $call_object);
77 }
78 sub DisassociateQualificationFromWorker {
79 my $self = shift;
80 my $call_object = $self->new_with_coercions('Paws::MTurk::DisassociateQualificationFromWorker', @_);
81 return $self->caller->do_call($self, $call_object);
82 }
83 sub GetAccountBalance {
84 my $self = shift;
85 my $call_object = $self->new_with_coercions('Paws::MTurk::GetAccountBalance', @_);
86 return $self->caller->do_call($self, $call_object);
87 }
88 sub GetAssignment {
89 my $self = shift;
90 my $call_object = $self->new_with_coercions('Paws::MTurk::GetAssignment', @_);
91 return $self->caller->do_call($self, $call_object);
92 }
93 sub GetFileUploadURL {
94 my $self = shift;
95 my $call_object = $self->new_with_coercions('Paws::MTurk::GetFileUploadURL', @_);
96 return $self->caller->do_call($self, $call_object);
97 }
98 sub GetHIT {
99 my $self = shift;
100 my $call_object = $self->new_with_coercions('Paws::MTurk::GetHIT', @_);
101 return $self->caller->do_call($self, $call_object);
102 }
103 sub GetQualificationScore {
104 my $self = shift;
105 my $call_object = $self->new_with_coercions('Paws::MTurk::GetQualificationScore', @_);
106 return $self->caller->do_call($self, $call_object);
107 }
108 sub GetQualificationType {
109 my $self = shift;
110 my $call_object = $self->new_with_coercions('Paws::MTurk::GetQualificationType', @_);
111 return $self->caller->do_call($self, $call_object);
112 }
113 sub ListAssignmentsForHIT {
114 my $self = shift;
115 my $call_object = $self->new_with_coercions('Paws::MTurk::ListAssignmentsForHIT', @_);
116 return $self->caller->do_call($self, $call_object);
117 }
118 sub ListBonusPayments {
119 my $self = shift;
120 my $call_object = $self->new_with_coercions('Paws::MTurk::ListBonusPayments', @_);
121 return $self->caller->do_call($self, $call_object);
122 }
123 sub ListHITs {
124 my $self = shift;
125 my $call_object = $self->new_with_coercions('Paws::MTurk::ListHITs', @_);
126 return $self->caller->do_call($self, $call_object);
127 }
128 sub ListHITsForQualificationType {
129 my $self = shift;
130 my $call_object = $self->new_with_coercions('Paws::MTurk::ListHITsForQualificationType', @_);
131 return $self->caller->do_call($self, $call_object);
132 }
133 sub ListQualificationRequests {
134 my $self = shift;
135 my $call_object = $self->new_with_coercions('Paws::MTurk::ListQualificationRequests', @_);
136 return $self->caller->do_call($self, $call_object);
137 }
138 sub ListQualificationTypes {
139 my $self = shift;
140 my $call_object = $self->new_with_coercions('Paws::MTurk::ListQualificationTypes', @_);
141 return $self->caller->do_call($self, $call_object);
142 }
143 sub ListReviewableHITs {
144 my $self = shift;
145 my $call_object = $self->new_with_coercions('Paws::MTurk::ListReviewableHITs', @_);
146 return $self->caller->do_call($self, $call_object);
147 }
148 sub ListReviewPolicyResultsForHIT {
149 my $self = shift;
150 my $call_object = $self->new_with_coercions('Paws::MTurk::ListReviewPolicyResultsForHIT', @_);
151 return $self->caller->do_call($self, $call_object);
152 }
153 sub ListWorkerBlocks {
154 my $self = shift;
155 my $call_object = $self->new_with_coercions('Paws::MTurk::ListWorkerBlocks', @_);
156 return $self->caller->do_call($self, $call_object);
157 }
158 sub ListWorkersWithQualificationType {
159 my $self = shift;
160 my $call_object = $self->new_with_coercions('Paws::MTurk::ListWorkersWithQualificationType', @_);
161 return $self->caller->do_call($self, $call_object);
162 }
163 sub NotifyWorkers {
164 my $self = shift;
165 my $call_object = $self->new_with_coercions('Paws::MTurk::NotifyWorkers', @_);
166 return $self->caller->do_call($self, $call_object);
167 }
168 sub RejectAssignment {
169 my $self = shift;
170 my $call_object = $self->new_with_coercions('Paws::MTurk::RejectAssignment', @_);
171 return $self->caller->do_call($self, $call_object);
172 }
173 sub RejectQualificationRequest {
174 my $self = shift;
175 my $call_object = $self->new_with_coercions('Paws::MTurk::RejectQualificationRequest', @_);
176 return $self->caller->do_call($self, $call_object);
177 }
178 sub SendBonus {
179 my $self = shift;
180 my $call_object = $self->new_with_coercions('Paws::MTurk::SendBonus', @_);
181 return $self->caller->do_call($self, $call_object);
182 }
183 sub SendTestEventNotification {
184 my $self = shift;
185 my $call_object = $self->new_with_coercions('Paws::MTurk::SendTestEventNotification', @_);
186 return $self->caller->do_call($self, $call_object);
187 }
188 sub UpdateExpirationForHIT {
189 my $self = shift;
190 my $call_object = $self->new_with_coercions('Paws::MTurk::UpdateExpirationForHIT', @_);
191 return $self->caller->do_call($self, $call_object);
192 }
193 sub UpdateHITReviewStatus {
194 my $self = shift;
195 my $call_object = $self->new_with_coercions('Paws::MTurk::UpdateHITReviewStatus', @_);
196 return $self->caller->do_call($self, $call_object);
197 }
198 sub UpdateHITTypeOfHIT {
199 my $self = shift;
200 my $call_object = $self->new_with_coercions('Paws::MTurk::UpdateHITTypeOfHIT', @_);
201 return $self->caller->do_call($self, $call_object);
202 }
203 sub UpdateNotificationSettings {
204 my $self = shift;
205 my $call_object = $self->new_with_coercions('Paws::MTurk::UpdateNotificationSettings', @_);
206 return $self->caller->do_call($self, $call_object);
207 }
208 sub UpdateQualificationType {
209 my $self = shift;
210 my $call_object = $self->new_with_coercions('Paws::MTurk::UpdateQualificationType', @_);
211 return $self->caller->do_call($self, $call_object);
212 }
213
214 sub ListAllAssignmentsForHIT {
215 my $self = shift;
216  
217 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
218 my $result = $self->ListAssignmentsForHIT(@_);
219 my $next_result = $result;
220  
221 if (not defined $callback) {
222 while ($next_result->NextToken) {
223 $next_result = $self->ListAssignmentsForHIT(@_, NextToken => $next_result->NextToken);
224 push @{ $result->Assignments }, @{ $next_result->Assignments };
225 }
226 return $result;
227 } else {
228 while ($result->NextToken) {
229 $callback->($_ => 'Assignments') foreach (@{ $result->Assignments });
230 $result = $self->ListAssignmentsForHIT(@_, NextToken => $result->NextToken);
231 }
232 $callback->($_ => 'Assignments') foreach (@{ $result->Assignments });
233 }
234  
235 return undef
236 }
237 sub ListAllBonusPayments {
238 my $self = shift;
239  
240 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
241 my $result = $self->ListBonusPayments(@_);
242 my $next_result = $result;
243  
244 if (not defined $callback) {
245 while ($next_result->NextToken) {
246 $next_result = $self->ListBonusPayments(@_, NextToken => $next_result->NextToken);
247 push @{ $result->BonusPayments }, @{ $next_result->BonusPayments };
248 }
249 return $result;
250 } else {
251 while ($result->NextToken) {
252 $callback->($_ => 'BonusPayments') foreach (@{ $result->BonusPayments });
253 $result = $self->ListBonusPayments(@_, NextToken => $result->NextToken);
254 }
255 $callback->($_ => 'BonusPayments') foreach (@{ $result->BonusPayments });
256 }
257  
258 return undef
259 }
260 sub ListAllHITs {
261 my $self = shift;
262  
263 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
264 my $result = $self->ListHITs(@_);
265 my $next_result = $result;
266  
267 if (not defined $callback) {
268 while ($next_result->NextToken) {
269 $next_result = $self->ListHITs(@_, NextToken => $next_result->NextToken);
270 push @{ $result->HITs }, @{ $next_result->HITs };
271 }
272 return $result;
273 } else {
274 while ($result->NextToken) {
275 $callback->($_ => 'HITs') foreach (@{ $result->HITs });
276 $result = $self->ListHITs(@_, NextToken => $result->NextToken);
277 }
278 $callback->($_ => 'HITs') foreach (@{ $result->HITs });
279 }
280  
281 return undef
282 }
283 sub ListAllHITsForQualificationType {
284 my $self = shift;
285  
286 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
287 my $result = $self->ListHITsForQualificationType(@_);
288 my $next_result = $result;
289  
290 if (not defined $callback) {
291 while ($next_result->NextToken) {
292 $next_result = $self->ListHITsForQualificationType(@_, NextToken => $next_result->NextToken);
293 push @{ $result->HITs }, @{ $next_result->HITs };
294 }
295 return $result;
296 } else {
297 while ($result->NextToken) {
298 $callback->($_ => 'HITs') foreach (@{ $result->HITs });
299 $result = $self->ListHITsForQualificationType(@_, NextToken => $result->NextToken);
300 }
301 $callback->($_ => 'HITs') foreach (@{ $result->HITs });
302 }
303  
304 return undef
305 }
306 sub ListAllQualificationRequests {
307 my $self = shift;
308  
309 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
310 my $result = $self->ListQualificationRequests(@_);
311 my $next_result = $result;
312  
313 if (not defined $callback) {
314 while ($next_result->NextToken) {
315 $next_result = $self->ListQualificationRequests(@_, NextToken => $next_result->NextToken);
316 push @{ $result->QualificationRequests }, @{ $next_result->QualificationRequests };
317 }
318 return $result;
319 } else {
320 while ($result->NextToken) {
321 $callback->($_ => 'QualificationRequests') foreach (@{ $result->QualificationRequests });
322 $result = $self->ListQualificationRequests(@_, NextToken => $result->NextToken);
323 }
324 $callback->($_ => 'QualificationRequests') foreach (@{ $result->QualificationRequests });
325 }
326  
327 return undef
328 }
329 sub ListAllQualificationTypes {
330 my $self = shift;
331  
332 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
333 my $result = $self->ListQualificationTypes(@_);
334 my $next_result = $result;
335  
336 if (not defined $callback) {
337 while ($next_result->NextToken) {
338 $next_result = $self->ListQualificationTypes(@_, NextToken => $next_result->NextToken);
339 push @{ $result->QualificationTypes }, @{ $next_result->QualificationTypes };
340 }
341 return $result;
342 } else {
343 while ($result->NextToken) {
344 $callback->($_ => 'QualificationTypes') foreach (@{ $result->QualificationTypes });
345 $result = $self->ListQualificationTypes(@_, NextToken => $result->NextToken);
346 }
347 $callback->($_ => 'QualificationTypes') foreach (@{ $result->QualificationTypes });
348 }
349  
350 return undef
351 }
352 sub ListAllReviewableHITs {
353 my $self = shift;
354  
355 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
356 my $result = $self->ListReviewableHITs(@_);
357 my $next_result = $result;
358  
359 if (not defined $callback) {
360 while ($next_result->NextToken) {
361 $next_result = $self->ListReviewableHITs(@_, NextToken => $next_result->NextToken);
362 push @{ $result->HITs }, @{ $next_result->HITs };
363 }
364 return $result;
365 } else {
366 while ($result->NextToken) {
367 $callback->($_ => 'HITs') foreach (@{ $result->HITs });
368 $result = $self->ListReviewableHITs(@_, NextToken => $result->NextToken);
369 }
370 $callback->($_ => 'HITs') foreach (@{ $result->HITs });
371 }
372  
373 return undef
374 }
375 sub ListAllWorkerBlocks {
376 my $self = shift;
377  
378 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
379 my $result = $self->ListWorkerBlocks(@_);
380 my $next_result = $result;
381  
382 if (not defined $callback) {
383 while ($next_result->NextToken) {
384 $next_result = $self->ListWorkerBlocks(@_, NextToken => $next_result->NextToken);
385 push @{ $result->WorkerBlocks }, @{ $next_result->WorkerBlocks };
386 }
387 return $result;
388 } else {
389 while ($result->NextToken) {
390 $callback->($_ => 'WorkerBlocks') foreach (@{ $result->WorkerBlocks });
391 $result = $self->ListWorkerBlocks(@_, NextToken => $result->NextToken);
392 }
393 $callback->($_ => 'WorkerBlocks') foreach (@{ $result->WorkerBlocks });
394 }
395  
396 return undef
397 }
398 sub ListAllWorkersWithQualificationType {
399 my $self = shift;
400  
401 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
402 my $result = $self->ListWorkersWithQualificationType(@_);
403 my $next_result = $result;
404  
405 if (not defined $callback) {
406 while ($next_result->NextToken) {
407 $next_result = $self->ListWorkersWithQualificationType(@_, NextToken => $next_result->NextToken);
408 push @{ $result->Qualifications }, @{ $next_result->Qualifications };
409 }
410 return $result;
411 } else {
412 while ($result->NextToken) {
413 $callback->($_ => 'Qualifications') foreach (@{ $result->Qualifications });
414 $result = $self->ListWorkersWithQualificationType(@_, NextToken => $result->NextToken);
415 }
416 $callback->($_ => 'Qualifications') foreach (@{ $result->Qualifications });
417 }
418  
419 return undef
420 }
421  
422  
423 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 / }
424  
425 1;
426  
427 ### main pod documentation begin ###
428  
429 =head1 NAME
430  
431 Paws::MTurk - Perl Interface to AWS Amazon Mechanical Turk
432  
433 =head1 SYNOPSIS
434  
435 use Paws;
436  
437 my $obj = Paws->service('MTurk');
438 my $res = $obj->Method(
439 Arg1 => $val1,
440 Arg2 => [ 'V1', 'V2' ],
441 # if Arg3 is an object, the HashRef will be used as arguments to the constructor
442 # of the arguments type
443 Arg3 => { Att1 => 'Val1' },
444 # if Arg4 is an array of objects, the HashRefs will be passed as arguments to
445 # the constructor of the arguments type
446 Arg4 => [ { Att1 => 'Val1' }, { Att1 => 'Val2' } ],
447 );
448  
449 =head1 DESCRIPTION
450  
451 Amazon Mechanical Turk API Reference
452  
453 For the AWS API documentation, see L<https://docs.aws.amazon.com/mturk/>
454  
455  
456 =head1 METHODS
457  
458 =head2 AcceptQualificationRequest
459  
460 =over
461  
462 =item QualificationRequestId => Str
463  
464 =item [IntegerValue => Int]
465  
466  
467 =back
468  
469 Each argument is described in detail in: L<Paws::MTurk::AcceptQualificationRequest>
470  
471 Returns: a L<Paws::MTurk::AcceptQualificationRequestResponse> instance
472  
473 The C<AcceptQualificationRequest> operation approves a Worker's request
474 for a Qualification.
475  
476 Only the owner of the Qualification type can grant a Qualification
477 request for that type.
478  
479 A successful request for the C<AcceptQualificationRequest> operation
480 returns with no errors and an empty body.
481  
482  
483 =head2 ApproveAssignment
484  
485 =over
486  
487 =item AssignmentId => Str
488  
489 =item [OverrideRejection => Bool]
490  
491 =item [RequesterFeedback => Str]
492  
493  
494 =back
495  
496 Each argument is described in detail in: L<Paws::MTurk::ApproveAssignment>
497  
498 Returns: a L<Paws::MTurk::ApproveAssignmentResponse> instance
499  
500 The C<ApproveAssignment> operation approves the results of a completed
501 assignment.
502  
503 Approving an assignment initiates two payments from the Requester's
504 Amazon.com account
505  
506 =over
507  
508 =item *
509  
510 The Worker who submitted the results is paid the reward specified in
511 the HIT.
512  
513 =item *
514  
515 Amazon Mechanical Turk fees are debited.
516  
517 =back
518  
519 If the Requester's account does not have adequate funds for these
520 payments, the call to ApproveAssignment returns an exception, and the
521 approval is not processed. You can include an optional feedback message
522 with the approval, which the Worker can see in the Status section of
523 the web site.
524  
525 You can also call this operation for assignments that were previous
526 rejected and approve them by explicitly overriding the previous
527 rejection. This only works on rejected assignments that were submitted
528 within the previous 30 days and only if the assignment's related HIT
529 has not been deleted.
530  
531  
532 =head2 AssociateQualificationWithWorker
533  
534 =over
535  
536 =item QualificationTypeId => Str
537  
538 =item WorkerId => Str
539  
540 =item [IntegerValue => Int]
541  
542 =item [SendNotification => Bool]
543  
544  
545 =back
546  
547 Each argument is described in detail in: L<Paws::MTurk::AssociateQualificationWithWorker>
548  
549 Returns: a L<Paws::MTurk::AssociateQualificationWithWorkerResponse> instance
550  
551 The C<AssociateQualificationWithWorker> operation gives a Worker a
552 Qualification. C<AssociateQualificationWithWorker> does not require
553 that the Worker submit a Qualification request. It gives the
554 Qualification directly to the Worker.
555  
556 You can only assign a Qualification of a Qualification type that you
557 created (using the C<CreateQualificationType> operation).
558  
559 Note: C<AssociateQualificationWithWorker> does not affect any pending
560 Qualification requests for the Qualification by the Worker. If you
561 assign a Qualification to a Worker, then later grant a Qualification
562 request made by the Worker, the granting of the request may modify the
563 Qualification score. To resolve a pending Qualification request without
564 affecting the Qualification the Worker already has, reject the request
565 with the C<RejectQualificationRequest> operation.
566  
567  
568 =head2 CreateAdditionalAssignmentsForHIT
569  
570 =over
571  
572 =item HITId => Str
573  
574 =item NumberOfAdditionalAssignments => Int
575  
576 =item [UniqueRequestToken => Str]
577  
578  
579 =back
580  
581 Each argument is described in detail in: L<Paws::MTurk::CreateAdditionalAssignmentsForHIT>
582  
583 Returns: a L<Paws::MTurk::CreateAdditionalAssignmentsForHITResponse> instance
584  
585 The C<CreateAdditionalAssignmentsForHIT> operation increases the
586 maximum number of assignments of an existing HIT.
587  
588 To extend the maximum number of assignments, specify the number of
589 additional assignments.
590  
591 =over
592  
593 =item *
594  
595 HITs created with fewer than 10 assignments cannot be extended to have
596 10 or more assignments. Attempting to add assignments in a way that
597 brings the total number of assignments for a HIT from fewer than 10
598 assignments to 10 or more assignments will result in an
599 C<AWS.MechanicalTurk.InvalidMaximumAssignmentsIncrease> exception.
600  
601 =item *
602  
603 HITs that were created before July 22, 2015 cannot be extended.
604 Attempting to extend HITs that were created before July 22, 2015 will
605 result in an C<AWS.MechanicalTurk.HITTooOldForExtension> exception.
606  
607 =back
608  
609  
610  
611 =head2 CreateHIT
612  
613 =over
614  
615 =item AssignmentDurationInSeconds => Int
616  
617 =item Description => Str
618  
619 =item LifetimeInSeconds => Int
620  
621 =item Reward => Str
622  
623 =item Title => Str
624  
625 =item [AssignmentReviewPolicy => L<Paws::MTurk::ReviewPolicy>]
626  
627 =item [AutoApprovalDelayInSeconds => Int]
628  
629 =item [HITLayoutId => Str]
630  
631 =item [HITLayoutParameters => ArrayRef[L<Paws::MTurk::HITLayoutParameter>]]
632  
633 =item [HITReviewPolicy => L<Paws::MTurk::ReviewPolicy>]
634  
635 =item [Keywords => Str]
636  
637 =item [MaxAssignments => Int]
638  
639 =item [QualificationRequirements => ArrayRef[L<Paws::MTurk::QualificationRequirement>]]
640  
641 =item [Question => Str]
642  
643 =item [RequesterAnnotation => Str]
644  
645 =item [UniqueRequestToken => Str]
646  
647  
648 =back
649  
650 Each argument is described in detail in: L<Paws::MTurk::CreateHIT>
651  
652 Returns: a L<Paws::MTurk::CreateHITResponse> instance
653  
654 The C<CreateHIT> operation creates a new Human Intelligence Task (HIT).
655 The new HIT is made available for Workers to find and accept on the
656 Amazon Mechanical Turk website.
657  
658 This operation allows you to specify a new HIT by passing in values for
659 the properties of the HIT, such as its title, reward amount and number
660 of assignments. When you pass these values to C<CreateHIT>, a new HIT
661 is created for you, with a new C<HITTypeID>. The HITTypeID can be used
662 to create additional HITs in the future without needing to specify
663 common parameters such as the title, description and reward amount each
664 time.
665  
666 An alternative way to create HITs is to first generate a HITTypeID
667 using the C<CreateHITType> operation and then call the
668 C<CreateHITWithHITType> operation. This is the recommended best
669 practice for Requesters who are creating large numbers of HITs.
670  
671 CreateHIT also supports several ways to provide question data: by
672 providing a value for the C<Question> parameter that fully specifies
673 the contents of the HIT, or by providing a C<HitLayoutId> and
674 associated C<HitLayoutParameters>.
675  
676 If a HIT is created with 10 or more maximum assignments, there is an
677 additional fee. For more information, see Amazon Mechanical Turk
678 Pricing (https://requester.mturk.com/pricing).
679  
680  
681 =head2 CreateHITType
682  
683 =over
684  
685 =item AssignmentDurationInSeconds => Int
686  
687 =item Description => Str
688  
689 =item Reward => Str
690  
691 =item Title => Str
692  
693 =item [AutoApprovalDelayInSeconds => Int]
694  
695 =item [Keywords => Str]
696  
697 =item [QualificationRequirements => ArrayRef[L<Paws::MTurk::QualificationRequirement>]]
698  
699  
700 =back
701  
702 Each argument is described in detail in: L<Paws::MTurk::CreateHITType>
703  
704 Returns: a L<Paws::MTurk::CreateHITTypeResponse> instance
705  
706 The C<CreateHITType> operation creates a new HIT type. This operation
707 allows you to define a standard set of HIT properties to use when
708 creating HITs. If you register a HIT type with values that match an
709 existing HIT type, the HIT type ID of the existing type will be
710 returned.
711  
712  
713 =head2 CreateHITWithHITType
714  
715 =over
716  
717 =item HITTypeId => Str
718  
719 =item LifetimeInSeconds => Int
720  
721 =item [AssignmentReviewPolicy => L<Paws::MTurk::ReviewPolicy>]
722  
723 =item [HITLayoutId => Str]
724  
725 =item [HITLayoutParameters => ArrayRef[L<Paws::MTurk::HITLayoutParameter>]]
726  
727 =item [HITReviewPolicy => L<Paws::MTurk::ReviewPolicy>]
728  
729 =item [MaxAssignments => Int]
730  
731 =item [Question => Str]
732  
733 =item [RequesterAnnotation => Str]
734  
735 =item [UniqueRequestToken => Str]
736  
737  
738 =back
739  
740 Each argument is described in detail in: L<Paws::MTurk::CreateHITWithHITType>
741  
742 Returns: a L<Paws::MTurk::CreateHITWithHITTypeResponse> instance
743  
744 The C<CreateHITWithHITType> operation creates a new Human Intelligence
745 Task (HIT) using an existing HITTypeID generated by the
746 C<CreateHITType> operation.
747  
748 This is an alternative way to create HITs from the C<CreateHIT>
749 operation. This is the recommended best practice for Requesters who are
750 creating large numbers of HITs.
751  
752 CreateHITWithHITType also supports several ways to provide question
753 data: by providing a value for the C<Question> parameter that fully
754 specifies the contents of the HIT, or by providing a C<HitLayoutId> and
755 associated C<HitLayoutParameters>.
756  
757 If a HIT is created with 10 or more maximum assignments, there is an
758 additional fee. For more information, see Amazon Mechanical Turk
759 Pricing (https://requester.mturk.com/pricing).
760  
761  
762 =head2 CreateQualificationType
763  
764 =over
765  
766 =item Description => Str
767  
768 =item Name => Str
769  
770 =item QualificationTypeStatus => Str
771  
772 =item [AnswerKey => Str]
773  
774 =item [AutoGranted => Bool]
775  
776 =item [AutoGrantedValue => Int]
777  
778 =item [Keywords => Str]
779  
780 =item [RetryDelayInSeconds => Int]
781  
782 =item [Test => Str]
783  
784 =item [TestDurationInSeconds => Int]
785  
786  
787 =back
788  
789 Each argument is described in detail in: L<Paws::MTurk::CreateQualificationType>
790  
791 Returns: a L<Paws::MTurk::CreateQualificationTypeResponse> instance
792  
793 The C<CreateQualificationType> operation creates a new Qualification
794 type, which is represented by a C<QualificationType> data structure.
795  
796  
797 =head2 CreateWorkerBlock
798  
799 =over
800  
801 =item Reason => Str
802  
803 =item WorkerId => Str
804  
805  
806 =back
807  
808 Each argument is described in detail in: L<Paws::MTurk::CreateWorkerBlock>
809  
810 Returns: a L<Paws::MTurk::CreateWorkerBlockResponse> instance
811  
812 The C<CreateWorkerBlock> operation allows you to prevent a Worker from
813 working on your HITs. For example, you can block a Worker who is
814 producing poor quality work. You can block up to 100,000 Workers.
815  
816  
817 =head2 DeleteHIT
818  
819 =over
820  
821 =item HITId => Str
822  
823  
824 =back
825  
826 Each argument is described in detail in: L<Paws::MTurk::DeleteHIT>
827  
828 Returns: a L<Paws::MTurk::DeleteHITResponse> instance
829  
830 The C<DeleteHIT> operation is used to delete HIT that is no longer
831 needed. Only the Requester who created the HIT can delete it.
832  
833 You can only dispose of HITs that are in the C<Reviewable> state, with
834 all of their submitted assignments already either approved or rejected.
835 If you call the DeleteHIT operation on a HIT that is not in the
836 C<Reviewable> state (for example, that has not expired, or still has
837 active assignments), or on a HIT that is Reviewable but without all of
838 its submitted assignments already approved or rejected, the service
839 will return an error.
840  
841 =over
842  
843 =item *
844  
845 HITs are automatically disposed of after 120 days.
846  
847 =item *
848  
849 After you dispose of a HIT, you can no longer approve the HIT's
850 rejected assignments.
851  
852 =item *
853  
854 Disposed HITs are not returned in results for the ListHITs operation.
855  
856 =item *
857  
858 Disposing HITs can improve the performance of operations such as
859 ListReviewableHITs and ListHITs.
860  
861 =back
862  
863  
864  
865 =head2 DeleteQualificationType
866  
867 =over
868  
869 =item QualificationTypeId => Str
870  
871  
872 =back
873  
874 Each argument is described in detail in: L<Paws::MTurk::DeleteQualificationType>
875  
876 Returns: a L<Paws::MTurk::DeleteQualificationTypeResponse> instance
877  
878 The C<DeleteQualificationType> deletes a Qualification type and deletes
879 any HIT types that are associated with the Qualification type.
880  
881 This operation does not revoke Qualifications already assigned to
882 Workers because the Qualifications might be needed for active HITs. If
883 there are any pending requests for the Qualification type, Amazon
884 Mechanical Turk rejects those requests. After you delete a
885 Qualification type, you can no longer use it to create HITs or HIT
886 types.
887  
888 DeleteQualificationType must wait for all the HITs that use the deleted
889 Qualification type to be deleted before completing. It may take up to
890 48 hours before DeleteQualificationType completes and the unique name
891 of the Qualification type is available for reuse with
892 CreateQualificationType.
893  
894  
895 =head2 DeleteWorkerBlock
896  
897 =over
898  
899 =item WorkerId => Str
900  
901 =item [Reason => Str]
902  
903  
904 =back
905  
906 Each argument is described in detail in: L<Paws::MTurk::DeleteWorkerBlock>
907  
908 Returns: a L<Paws::MTurk::DeleteWorkerBlockResponse> instance
909  
910 The C<DeleteWorkerBlock> operation allows you to reinstate a blocked
911 Worker to work on your HITs. This operation reverses the effects of the
912 CreateWorkerBlock operation. You need the Worker ID to use this
913 operation. If the Worker ID is missing or invalid, this operation fails
914 and returns the message E<ldquo>WorkerId is invalid.E<rdquo> If the
915 specified Worker is not blocked, this operation returns successfully.
916  
917  
918 =head2 DisassociateQualificationFromWorker
919  
920 =over
921  
922 =item QualificationTypeId => Str
923  
924 =item WorkerId => Str
925  
926 =item [Reason => Str]
927  
928  
929 =back
930  
931 Each argument is described in detail in: L<Paws::MTurk::DisassociateQualificationFromWorker>
932  
933 Returns: a L<Paws::MTurk::DisassociateQualificationFromWorkerResponse> instance
934  
935 The C<DisassociateQualificationFromWorker> revokes a previously granted
936 Qualification from a user.
937  
938 You can provide a text message explaining why the Qualification was
939 revoked. The user who had the Qualification can see this message.
940  
941  
942 =head2 GetAccountBalance
943  
944  
945  
946  
947  
948  
949 Each argument is described in detail in: L<Paws::MTurk::GetAccountBalance>
950  
951 Returns: a L<Paws::MTurk::GetAccountBalanceResponse> instance
952  
953 The C<GetAccountBalance> operation retrieves the Prepaid HITs balance
954 in your Amazon Mechanical Turk account if you are a Prepaid Requester.
955 Alternatively, this operation will retrieve the remaining available AWS
956 Billing usage if you have enabled AWS Billing. Note: If you have
957 enabled AWS Billing and still have a remaining Prepaid HITs balance,
958 this balance can be viewed on the My Account page in the Requester
959 console.
960  
961  
962 =head2 GetAssignment
963  
964 =over
965  
966 =item AssignmentId => Str
967  
968  
969 =back
970  
971 Each argument is described in detail in: L<Paws::MTurk::GetAssignment>
972  
973 Returns: a L<Paws::MTurk::GetAssignmentResponse> instance
974  
975 The C<GetAssignment> operation retrieves the details of the specified
976 Assignment.
977  
978  
979 =head2 GetFileUploadURL
980  
981 =over
982  
983 =item AssignmentId => Str
984  
985 =item QuestionIdentifier => Str
986  
987  
988 =back
989  
990 Each argument is described in detail in: L<Paws::MTurk::GetFileUploadURL>
991  
992 Returns: a L<Paws::MTurk::GetFileUploadURLResponse> instance
993  
994 The C<GetFileUploadURL> operation generates and returns a temporary
995 URL. You use the temporary URL to retrieve a file uploaded by a Worker
996 as an answer to a FileUploadAnswer question for a HIT. The temporary
997 URL is generated the instant the GetFileUploadURL operation is called,
998 and is valid for 60 seconds. You can get a temporary file upload URL
999 any time until the HIT is disposed. After the HIT is disposed, any
1000 uploaded files are deleted, and cannot be retrieved. Pending
1001 Deprecation on December 12, 2017. The Answer Specification structure
1002 will no longer support the C<FileUploadAnswer> element to be used for
1003 the QuestionForm data structure. Instead, we recommend that Requesters
1004 who want to create HITs asking Workers to upload files to use Amazon
1005 S3.
1006  
1007  
1008 =head2 GetHIT
1009  
1010 =over
1011  
1012 =item HITId => Str
1013  
1014  
1015 =back
1016  
1017 Each argument is described in detail in: L<Paws::MTurk::GetHIT>
1018  
1019 Returns: a L<Paws::MTurk::GetHITResponse> instance
1020  
1021 The C<GetHIT> operation retrieves the details of the specified HIT.
1022  
1023  
1024 =head2 GetQualificationScore
1025  
1026 =over
1027  
1028 =item QualificationTypeId => Str
1029  
1030 =item WorkerId => Str
1031  
1032  
1033 =back
1034  
1035 Each argument is described in detail in: L<Paws::MTurk::GetQualificationScore>
1036  
1037 Returns: a L<Paws::MTurk::GetQualificationScoreResponse> instance
1038  
1039 The C<GetQualificationScore> operation returns the value of a Worker's
1040 Qualification for a given Qualification type.
1041  
1042 To get a Worker's Qualification, you must know the Worker's ID. The
1043 Worker's ID is included in the assignment data returned by the
1044 C<ListAssignmentsForHIT> operation.
1045  
1046 Only the owner of a Qualification type can query the value of a
1047 Worker's Qualification of that type.
1048  
1049  
1050 =head2 GetQualificationType
1051  
1052 =over
1053  
1054 =item QualificationTypeId => Str
1055  
1056  
1057 =back
1058  
1059 Each argument is described in detail in: L<Paws::MTurk::GetQualificationType>
1060  
1061 Returns: a L<Paws::MTurk::GetQualificationTypeResponse> instance
1062  
1063 The C<GetQualificationType>operation retrieves information about a
1064 Qualification type using its ID.
1065  
1066  
1067 =head2 ListAssignmentsForHIT
1068  
1069 =over
1070  
1071 =item HITId => Str
1072  
1073 =item [AssignmentStatuses => ArrayRef[Str|Undef]]
1074  
1075 =item [MaxResults => Int]
1076  
1077 =item [NextToken => Str]
1078  
1079  
1080 =back
1081  
1082 Each argument is described in detail in: L<Paws::MTurk::ListAssignmentsForHIT>
1083  
1084 Returns: a L<Paws::MTurk::ListAssignmentsForHITResponse> instance
1085  
1086 The C<ListAssignmentsForHIT> operation retrieves completed assignments
1087 for a HIT. You can use this operation to retrieve the results for a
1088 HIT.
1089  
1090 You can get assignments for a HIT at any time, even if the HIT is not
1091 yet Reviewable. If a HIT requested multiple assignments, and has
1092 received some results but has not yet become Reviewable, you can still
1093 retrieve the partial results with this operation.
1094  
1095 Use the AssignmentStatus parameter to control which set of assignments
1096 for a HIT are returned. The ListAssignmentsForHIT operation can return
1097 submitted assignments awaiting approval, or it can return assignments
1098 that have already been approved or rejected. You can set
1099 AssignmentStatus=Approved,Rejected to get assignments that have already
1100 been approved and rejected together in one result set.
1101  
1102 Only the Requester who created the HIT can retrieve the assignments for
1103 that HIT.
1104  
1105 Results are sorted and divided into numbered pages and the operation
1106 returns a single page of results. You can use the parameters of the
1107 operation to control sorting and pagination.
1108  
1109  
1110 =head2 ListBonusPayments
1111  
1112 =over
1113  
1114 =item [AssignmentId => Str]
1115  
1116 =item [HITId => Str]
1117  
1118 =item [MaxResults => Int]
1119  
1120 =item [NextToken => Str]
1121  
1122  
1123 =back
1124  
1125 Each argument is described in detail in: L<Paws::MTurk::ListBonusPayments>
1126  
1127 Returns: a L<Paws::MTurk::ListBonusPaymentsResponse> instance
1128  
1129 The C<ListBonusPayments> operation retrieves the amounts of bonuses you
1130 have paid to Workers for a given HIT or assignment.
1131  
1132  
1133 =head2 ListHITs
1134  
1135 =over
1136  
1137 =item [MaxResults => Int]
1138  
1139 =item [NextToken => Str]
1140  
1141  
1142 =back
1143  
1144 Each argument is described in detail in: L<Paws::MTurk::ListHITs>
1145  
1146 Returns: a L<Paws::MTurk::ListHITsResponse> instance
1147  
1148 The C<ListHITs> operation returns all of a Requester's HITs. The
1149 operation returns HITs of any status, except for HITs that have been
1150 deleted of with the DeleteHIT operation or that have been auto-deleted.
1151  
1152  
1153 =head2 ListHITsForQualificationType
1154  
1155 =over
1156  
1157 =item QualificationTypeId => Str
1158  
1159 =item [MaxResults => Int]
1160  
1161 =item [NextToken => Str]
1162  
1163  
1164 =back
1165  
1166 Each argument is described in detail in: L<Paws::MTurk::ListHITsForQualificationType>
1167  
1168 Returns: a L<Paws::MTurk::ListHITsForQualificationTypeResponse> instance
1169  
1170 The C<ListHITsForQualificationType> operation returns the HITs that use
1171 the given Qualification type for a Qualification requirement. The
1172 operation returns HITs of any status, except for HITs that have been
1173 deleted with the C<DeleteHIT> operation or that have been auto-deleted.
1174  
1175  
1176 =head2 ListQualificationRequests
1177  
1178 =over
1179  
1180 =item [MaxResults => Int]
1181  
1182 =item [NextToken => Str]
1183  
1184 =item [QualificationTypeId => Str]
1185  
1186  
1187 =back
1188  
1189 Each argument is described in detail in: L<Paws::MTurk::ListQualificationRequests>
1190  
1191 Returns: a L<Paws::MTurk::ListQualificationRequestsResponse> instance
1192  
1193 The C<ListQualificationRequests> operation retrieves requests for
1194 Qualifications of a particular Qualification type. The owner of the
1195 Qualification type calls this operation to poll for pending requests,
1196 and accepts them using the AcceptQualification operation.
1197  
1198  
1199 =head2 ListQualificationTypes
1200  
1201 =over
1202  
1203 =item MustBeRequestable => Bool
1204  
1205 =item [MaxResults => Int]
1206  
1207 =item [MustBeOwnedByCaller => Bool]
1208  
1209 =item [NextToken => Str]
1210  
1211 =item [Query => Str]
1212  
1213  
1214 =back
1215  
1216 Each argument is described in detail in: L<Paws::MTurk::ListQualificationTypes>
1217  
1218 Returns: a L<Paws::MTurk::ListQualificationTypesResponse> instance
1219  
1220 The C<ListQualificationTypes> operation returns a list of Qualification
1221 types, filtered by an optional search term.
1222  
1223  
1224 =head2 ListReviewableHITs
1225  
1226 =over
1227  
1228 =item [HITTypeId => Str]
1229  
1230 =item [MaxResults => Int]
1231  
1232 =item [NextToken => Str]
1233  
1234 =item [Status => Str]
1235  
1236  
1237 =back
1238  
1239 Each argument is described in detail in: L<Paws::MTurk::ListReviewableHITs>
1240  
1241 Returns: a L<Paws::MTurk::ListReviewableHITsResponse> instance
1242  
1243 The C<ListReviewableHITs> operation retrieves the HITs with Status
1244 equal to Reviewable or Status equal to Reviewing that belong to the
1245 Requester calling the operation.
1246  
1247  
1248 =head2 ListReviewPolicyResultsForHIT
1249  
1250 =over
1251  
1252 =item HITId => Str
1253  
1254 =item [MaxResults => Int]
1255  
1256 =item [NextToken => Str]
1257  
1258 =item [PolicyLevels => ArrayRef[Str|Undef]]
1259  
1260 =item [RetrieveActions => Bool]
1261  
1262 =item [RetrieveResults => Bool]
1263  
1264  
1265 =back
1266  
1267 Each argument is described in detail in: L<Paws::MTurk::ListReviewPolicyResultsForHIT>
1268  
1269 Returns: a L<Paws::MTurk::ListReviewPolicyResultsForHITResponse> instance
1270  
1271 The C<ListReviewPolicyResultsForHIT> operation retrieves the computed
1272 results and the actions taken in the course of executing your Review
1273 Policies for a given HIT. For information about how to specify Review
1274 Policies when you call CreateHIT, see Review Policies. The
1275 ListReviewPolicyResultsForHIT operation can return results for both
1276 Assignment-level and HIT-level review results.
1277  
1278  
1279 =head2 ListWorkerBlocks
1280  
1281 =over
1282  
1283 =item [MaxResults => Int]
1284  
1285 =item [NextToken => Str]
1286  
1287  
1288 =back
1289  
1290 Each argument is described in detail in: L<Paws::MTurk::ListWorkerBlocks>
1291  
1292 Returns: a L<Paws::MTurk::ListWorkerBlocksResponse> instance
1293  
1294 The C<ListWorkersBlocks> operation retrieves a list of Workers who are
1295 blocked from working on your HITs.
1296  
1297  
1298 =head2 ListWorkersWithQualificationType
1299  
1300 =over
1301  
1302 =item QualificationTypeId => Str
1303  
1304 =item [MaxResults => Int]
1305  
1306 =item [NextToken => Str]
1307  
1308 =item [Status => Str]
1309  
1310  
1311 =back
1312  
1313 Each argument is described in detail in: L<Paws::MTurk::ListWorkersWithQualificationType>
1314  
1315 Returns: a L<Paws::MTurk::ListWorkersWithQualificationTypeResponse> instance
1316  
1317 The C<ListWorkersWithQualificationType> operation returns all of the
1318 Workers that have been associated with a given Qualification type.
1319  
1320  
1321 =head2 NotifyWorkers
1322  
1323 =over
1324  
1325 =item MessageText => Str
1326  
1327 =item Subject => Str
1328  
1329 =item WorkerIds => ArrayRef[Str|Undef]
1330  
1331  
1332 =back
1333  
1334 Each argument is described in detail in: L<Paws::MTurk::NotifyWorkers>
1335  
1336 Returns: a L<Paws::MTurk::NotifyWorkersResponse> instance
1337  
1338 The C<NotifyWorkers> operation sends an email to one or more Workers
1339 that you specify with the Worker ID. You can specify up to 100 Worker
1340 IDs to send the same message with a single call to the NotifyWorkers
1341 operation. The NotifyWorkers operation will send a notification email
1342 to a Worker only if you have previously approved or rejected work from
1343 the Worker.
1344  
1345  
1346 =head2 RejectAssignment
1347  
1348 =over
1349  
1350 =item AssignmentId => Str
1351  
1352 =item RequesterFeedback => Str
1353  
1354  
1355 =back
1356  
1357 Each argument is described in detail in: L<Paws::MTurk::RejectAssignment>
1358  
1359 Returns: a L<Paws::MTurk::RejectAssignmentResponse> instance
1360  
1361 The C<RejectAssignment> operation rejects the results of a completed
1362 assignment.
1363  
1364 You can include an optional feedback message with the rejection, which
1365 the Worker can see in the Status section of the web site. When you
1366 include a feedback message with the rejection, it helps the Worker
1367 understand why the assignment was rejected, and can improve the quality
1368 of the results the Worker submits in the future.
1369  
1370 Only the Requester who created the HIT can reject an assignment for the
1371 HIT.
1372  
1373  
1374 =head2 RejectQualificationRequest
1375  
1376 =over
1377  
1378 =item QualificationRequestId => Str
1379  
1380 =item [Reason => Str]
1381  
1382  
1383 =back
1384  
1385 Each argument is described in detail in: L<Paws::MTurk::RejectQualificationRequest>
1386  
1387 Returns: a L<Paws::MTurk::RejectQualificationRequestResponse> instance
1388  
1389 The C<RejectQualificationRequest> operation rejects a user's request
1390 for a Qualification.
1391  
1392 You can provide a text message explaining why the request was rejected.
1393 The Worker who made the request can see this message.
1394  
1395  
1396 =head2 SendBonus
1397  
1398 =over
1399  
1400 =item AssignmentId => Str
1401  
1402 =item BonusAmount => Str
1403  
1404 =item Reason => Str
1405  
1406 =item WorkerId => Str
1407  
1408 =item [UniqueRequestToken => Str]
1409  
1410  
1411 =back
1412  
1413 Each argument is described in detail in: L<Paws::MTurk::SendBonus>
1414  
1415 Returns: a L<Paws::MTurk::SendBonusResponse> instance
1416  
1417 The C<SendBonus> operation issues a payment of money from your account
1418 to a Worker. This payment happens separately from the reward you pay to
1419 the Worker when you approve the Worker's assignment. The SendBonus
1420 operation requires the Worker's ID and the assignment ID as parameters
1421 to initiate payment of the bonus. You must include a message that
1422 explains the reason for the bonus payment, as the Worker may not be
1423 expecting the payment. Amazon Mechanical Turk collects a fee for bonus
1424 payments, similar to the HIT listing fee. This operation fails if your
1425 account does not have enough funds to pay for both the bonus and the
1426 fees.
1427  
1428  
1429 =head2 SendTestEventNotification
1430  
1431 =over
1432  
1433 =item Notification => L<Paws::MTurk::NotificationSpecification>
1434  
1435 =item TestEventType => Str
1436  
1437  
1438 =back
1439  
1440 Each argument is described in detail in: L<Paws::MTurk::SendTestEventNotification>
1441  
1442 Returns: a L<Paws::MTurk::SendTestEventNotificationResponse> instance
1443  
1444 The C<SendTestEventNotification> operation causes Amazon Mechanical
1445 Turk to send a notification message as if a HIT event occurred,
1446 according to the provided notification specification. This allows you
1447 to test notifications without setting up notifications for a real HIT
1448 type and trying to trigger them using the website. When you call this
1449 operation, the service attempts to send the test notification
1450 immediately.
1451  
1452  
1453 =head2 UpdateExpirationForHIT
1454  
1455 =over
1456  
1457 =item ExpireAt => Str
1458  
1459 =item HITId => Str
1460  
1461  
1462 =back
1463  
1464 Each argument is described in detail in: L<Paws::MTurk::UpdateExpirationForHIT>
1465  
1466 Returns: a L<Paws::MTurk::UpdateExpirationForHITResponse> instance
1467  
1468 The C<UpdateExpirationForHIT> operation allows you update the
1469 expiration time of a HIT. If you update it to a time in the past, the
1470 HIT will be immediately expired.
1471  
1472  
1473 =head2 UpdateHITReviewStatus
1474  
1475 =over
1476  
1477 =item HITId => Str
1478  
1479 =item [Revert => Bool]
1480  
1481  
1482 =back
1483  
1484 Each argument is described in detail in: L<Paws::MTurk::UpdateHITReviewStatus>
1485  
1486 Returns: a L<Paws::MTurk::UpdateHITReviewStatusResponse> instance
1487  
1488 The C<UpdateHITReviewStatus> operation updates the status of a HIT. If
1489 the status is Reviewable, this operation can update the status to
1490 Reviewing, or it can revert a Reviewing HIT back to the Reviewable
1491 status.
1492  
1493  
1494 =head2 UpdateHITTypeOfHIT
1495  
1496 =over
1497  
1498 =item HITId => Str
1499  
1500 =item HITTypeId => Str
1501  
1502  
1503 =back
1504  
1505 Each argument is described in detail in: L<Paws::MTurk::UpdateHITTypeOfHIT>
1506  
1507 Returns: a L<Paws::MTurk::UpdateHITTypeOfHITResponse> instance
1508  
1509 The C<UpdateHITTypeOfHIT> operation allows you to change the HITType
1510 properties of a HIT. This operation disassociates the HIT from its old
1511 HITType properties and associates it with the new HITType properties.
1512 The HIT takes on the properties of the new HITType in place of the old
1513 ones.
1514  
1515  
1516 =head2 UpdateNotificationSettings
1517  
1518 =over
1519  
1520 =item HITTypeId => Str
1521  
1522 =item [Active => Bool]
1523  
1524 =item [Notification => L<Paws::MTurk::NotificationSpecification>]
1525  
1526  
1527 =back
1528  
1529 Each argument is described in detail in: L<Paws::MTurk::UpdateNotificationSettings>
1530  
1531 Returns: a L<Paws::MTurk::UpdateNotificationSettingsResponse> instance
1532  
1533 The C<UpdateNotificationSettings> operation creates, updates, disables
1534 or re-enables notifications for a HIT type. If you call the
1535 UpdateNotificationSettings operation for a HIT type that already has a
1536 notification specification, the operation replaces the old
1537 specification with a new one. You can call the
1538 UpdateNotificationSettings operation to enable or disable notifications
1539 for the HIT type, without having to modify the notification
1540 specification itself by providing updates to the Active status without
1541 specifying a new notification specification. To change the Active
1542 status of a HIT type's notifications, the HIT type must already have a
1543 notification specification, or one must be provided in the same call to
1544 C<UpdateNotificationSettings>.
1545  
1546  
1547 =head2 UpdateQualificationType
1548  
1549 =over
1550  
1551 =item QualificationTypeId => Str
1552  
1553 =item [AnswerKey => Str]
1554  
1555 =item [AutoGranted => Bool]
1556  
1557 =item [AutoGrantedValue => Int]
1558  
1559 =item [Description => Str]
1560  
1561 =item [QualificationTypeStatus => Str]
1562  
1563 =item [RetryDelayInSeconds => Int]
1564  
1565 =item [Test => Str]
1566  
1567 =item [TestDurationInSeconds => Int]
1568  
1569  
1570 =back
1571  
1572 Each argument is described in detail in: L<Paws::MTurk::UpdateQualificationType>
1573  
1574 Returns: a L<Paws::MTurk::UpdateQualificationTypeResponse> instance
1575  
1576 The C<UpdateQualificationType> operation modifies the attributes of an
1577 existing Qualification type, which is represented by a
1578 QualificationType data structure. Only the owner of a Qualification
1579 type can modify its attributes.
1580  
1581 Most attributes of a Qualification type can be changed after the type
1582 has been created. However, the Name and Keywords fields cannot be
1583 modified. The RetryDelayInSeconds parameter can be modified or added to
1584 change the delay or to enable retries, but RetryDelayInSeconds cannot
1585 be used to disable retries.
1586  
1587 You can use this operation to update the test for a Qualification type.
1588 The test is updated based on the values specified for the Test,
1589 TestDurationInSeconds and AnswerKey parameters. All three parameters
1590 specify the updated test. If you are updating the test for a type, you
1591 must specify the Test and TestDurationInSeconds parameters. The
1592 AnswerKey parameter is optional; omitting it specifies that the updated
1593 test does not have an answer key.
1594  
1595 If you omit the Test parameter, the test for the Qualification type is
1596 unchanged. There is no way to remove a test from a Qualification type
1597 that has one. If the type already has a test, you cannot update it to
1598 be AutoGranted. If the Qualification type does not have a test and one
1599 is provided by an update, the type will henceforth have a test.
1600  
1601 If you want to update the test duration or answer key for an existing
1602 test without changing the questions, you must specify a Test parameter
1603 with the original questions, along with the updated values.
1604  
1605 If you provide an updated Test but no AnswerKey, the new test will not
1606 have an answer key. Requests for such Qualifications must be granted
1607 manually.
1608  
1609 You can also update the AutoGranted and AutoGrantedValue attributes of
1610 the Qualification type.
1611  
1612  
1613  
1614  
1615 =head1 PAGINATORS
1616  
1617 Paginator methods are helpers that repetively call methods that return partial results
1618  
1619 =head2 ListAllAssignmentsForHIT(sub { },HITId => Str, [AssignmentStatuses => ArrayRef[Str|Undef], MaxResults => Int, NextToken => Str])
1620  
1621 =head2 ListAllAssignmentsForHIT(HITId => Str, [AssignmentStatuses => ArrayRef[Str|Undef], MaxResults => Int, NextToken => Str])
1622  
1623  
1624 If passed a sub as first parameter, it will call the sub for each element found in :
1625  
1626 - Assignments, passing the object as the first parameter, and the string 'Assignments' as the second parameter
1627  
1628 If not, it will return a a L<Paws::MTurk::ListAssignmentsForHITResponse> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
1629  
1630  
1631 =head2 ListAllBonusPayments(sub { },[AssignmentId => Str, HITId => Str, MaxResults => Int, NextToken => Str])
1632  
1633 =head2 ListAllBonusPayments([AssignmentId => Str, HITId => Str, MaxResults => Int, NextToken => Str])
1634  
1635  
1636 If passed a sub as first parameter, it will call the sub for each element found in :
1637  
1638 - BonusPayments, passing the object as the first parameter, and the string 'BonusPayments' as the second parameter
1639  
1640 If not, it will return a a L<Paws::MTurk::ListBonusPaymentsResponse> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
1641  
1642  
1643 =head2 ListAllHITs(sub { },[MaxResults => Int, NextToken => Str])
1644  
1645 =head2 ListAllHITs([MaxResults => Int, NextToken => Str])
1646  
1647  
1648 If passed a sub as first parameter, it will call the sub for each element found in :
1649  
1650 - HITs, passing the object as the first parameter, and the string 'HITs' as the second parameter
1651  
1652 If not, it will return a a L<Paws::MTurk::ListHITsResponse> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
1653  
1654  
1655 =head2 ListAllHITsForQualificationType(sub { },QualificationTypeId => Str, [MaxResults => Int, NextToken => Str])
1656  
1657 =head2 ListAllHITsForQualificationType(QualificationTypeId => Str, [MaxResults => Int, NextToken => Str])
1658  
1659  
1660 If passed a sub as first parameter, it will call the sub for each element found in :
1661  
1662 - HITs, passing the object as the first parameter, and the string 'HITs' as the second parameter
1663  
1664 If not, it will return a a L<Paws::MTurk::ListHITsForQualificationTypeResponse> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
1665  
1666  
1667 =head2 ListAllQualificationRequests(sub { },[MaxResults => Int, NextToken => Str, QualificationTypeId => Str])
1668  
1669 =head2 ListAllQualificationRequests([MaxResults => Int, NextToken => Str, QualificationTypeId => Str])
1670  
1671  
1672 If passed a sub as first parameter, it will call the sub for each element found in :
1673  
1674 - QualificationRequests, passing the object as the first parameter, and the string 'QualificationRequests' as the second parameter
1675  
1676 If not, it will return a a L<Paws::MTurk::ListQualificationRequestsResponse> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
1677  
1678  
1679 =head2 ListAllQualificationTypes(sub { },MustBeRequestable => Bool, [MaxResults => Int, MustBeOwnedByCaller => Bool, NextToken => Str, Query => Str])
1680  
1681 =head2 ListAllQualificationTypes(MustBeRequestable => Bool, [MaxResults => Int, MustBeOwnedByCaller => Bool, NextToken => Str, Query => Str])
1682  
1683  
1684 If passed a sub as first parameter, it will call the sub for each element found in :
1685  
1686 - QualificationTypes, passing the object as the first parameter, and the string 'QualificationTypes' as the second parameter
1687  
1688 If not, it will return a a L<Paws::MTurk::ListQualificationTypesResponse> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
1689  
1690  
1691 =head2 ListAllReviewableHITs(sub { },[HITTypeId => Str, MaxResults => Int, NextToken => Str, Status => Str])
1692  
1693 =head2 ListAllReviewableHITs([HITTypeId => Str, MaxResults => Int, NextToken => Str, Status => Str])
1694  
1695  
1696 If passed a sub as first parameter, it will call the sub for each element found in :
1697  
1698 - HITs, passing the object as the first parameter, and the string 'HITs' as the second parameter
1699  
1700 If not, it will return a a L<Paws::MTurk::ListReviewableHITsResponse> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
1701  
1702  
1703 =head2 ListAllWorkerBlocks(sub { },[MaxResults => Int, NextToken => Str])
1704  
1705 =head2 ListAllWorkerBlocks([MaxResults => Int, NextToken => Str])
1706  
1707  
1708 If passed a sub as first parameter, it will call the sub for each element found in :
1709  
1710 - WorkerBlocks, passing the object as the first parameter, and the string 'WorkerBlocks' as the second parameter
1711  
1712 If not, it will return a a L<Paws::MTurk::ListWorkerBlocksResponse> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
1713  
1714  
1715 =head2 ListAllWorkersWithQualificationType(sub { },QualificationTypeId => Str, [MaxResults => Int, NextToken => Str, Status => Str])
1716  
1717 =head2 ListAllWorkersWithQualificationType(QualificationTypeId => Str, [MaxResults => Int, NextToken => Str, Status => Str])
1718  
1719  
1720 If passed a sub as first parameter, it will call the sub for each element found in :
1721  
1722 - Qualifications, passing the object as the first parameter, and the string 'Qualifications' as the second parameter
1723  
1724 If not, it will return a a L<Paws::MTurk::ListWorkersWithQualificationTypeResponse> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
1725  
1726  
1727  
1728  
1729  
1730 =head1 SEE ALSO
1731  
1732 This service class forms part of L<Paws>
1733  
1734 =head1 BUGS and CONTRIBUTIONS
1735  
1736 The source code is located here: L<https://github.com/pplu/aws-sdk-perl>
1737  
1738 Please report bugs to: L<https://github.com/pplu/aws-sdk-perl/issues>
1739  
1740 =cut
1741