types

package
v0.26.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Oct 1, 2020 License: Apache-2.0 Imports: 3 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type Assignment 

type Assignment struct {

	// The date and time of the deadline for the assignment. This value is derived from
	// the deadline specification for the HIT and the date and time the Worker accepted
	// the HIT.
	Deadline *time.Time

	// If results have been submitted, AutoApprovalTime is the date and time the
	// results of the assignment results are considered Approved automatically if they
	// have not already been explicitly approved or rejected by the Requester. This
	// value is derived from the auto-approval delay specified by the Requester in the
	// HIT. This value is omitted from the assignment if the Worker has not yet
	// submitted results.
	AutoApprovalTime *time.Time

	// The status of the assignment.
	AssignmentStatus AssignmentStatus

	// A unique identifier for the assignment.
	AssignmentId *string

	// The ID of the HIT.
	HITId *string

	// The date and time the Worker accepted the assignment.
	AcceptTime *time.Time

	// If the Worker has submitted results and the Requester has approved the results,
	// ApprovalTime is the date and time the Requester approved the results. This value
	// is omitted from the assignment if the Requester has not yet approved the
	// results.
	ApprovalTime *time.Time

	// The feedback string included with the call to the ApproveAssignment operation or
	// the RejectAssignment operation, if the Requester approved or rejected the
	// assignment and specified feedback.
	RequesterFeedback *string

	// If the Worker has submitted results, SubmitTime is the date and time the
	// assignment was submitted. This value is omitted from the assignment if the
	// Worker has not yet submitted results.
	SubmitTime *time.Time

	// The ID of the Worker who accepted the HIT.
	WorkerId *string

	// The Worker's answers submitted for the HIT contained in a QuestionFormAnswers
	// document, if the Worker provides an answer. If the Worker does not provide any
	// answers, Answer may contain a QuestionFormAnswers document, or Answer may be
	// empty.
	Answer *string

	// If the Worker has submitted results and the Requester has rejected the results,
	// RejectionTime is the date and time the Requester rejected the results.
	RejectionTime *time.Time
}

The Assignment data structure represents a single assignment of a HIT to a Worker. The assignment tracks the Worker's efforts to complete the HIT, and contains the results for later retrieval.

type AssignmentStatus 

type AssignmentStatus string
const (
	AssignmentStatusSubmitted AssignmentStatus = "Submitted"
	AssignmentStatusApproved  AssignmentStatus = "Approved"
	AssignmentStatusRejected  AssignmentStatus = "Rejected"
)

Enum values for AssignmentStatus

type BonusPayment 

type BonusPayment struct {

	// The Reason text given when the bonus was granted, if any.
	Reason *string

	// The date and time of when the bonus was granted.
	GrantTime *time.Time

	// A string representing a currency amount.
	BonusAmount *string

	// The ID of the Worker to whom the bonus was paid.
	WorkerId *string

	// The ID of the assignment associated with this bonus payment.
	AssignmentId *string
}

An object representing a Bonus payment paid to a Worker.

type Comparator 

type Comparator string
const (
	ComparatorLessthan             Comparator = "LessThan"
	ComparatorLessthanorequalto    Comparator = "LessThanOrEqualTo"
	ComparatorGreaterthan          Comparator = "GreaterThan"
	ComparatorGreaterthanorequalto Comparator = "GreaterThanOrEqualTo"
	ComparatorEqualto              Comparator = "EqualTo"
	ComparatorNotequalto           Comparator = "NotEqualTo"
	ComparatorExists               Comparator = "Exists"
	ComparatorDoesnotexist         Comparator = "DoesNotExist"
	ComparatorIn                   Comparator = "In"
	ComparatorNotin                Comparator = "NotIn"
)

Enum values for Comparator

type EventType 

type EventType string
const (
	EventTypeAssignmentaccepted  EventType = "AssignmentAccepted"
	EventTypeAssignmentabandoned EventType = "AssignmentAbandoned"
	EventTypeAssignmentreturned  EventType = "AssignmentReturned"
	EventTypeAssignmentsubmitted EventType = "AssignmentSubmitted"
	EventTypeAssignmentrejected  EventType = "AssignmentRejected"
	EventTypeAssignmentapproved  EventType = "AssignmentApproved"
	EventTypeHitcreated          EventType = "HITCreated"
	EventTypeHitexpired          EventType = "HITExpired"
	EventTypeHitreviewable       EventType = "HITReviewable"
	EventTypeHitextended         EventType = "HITExtended"
	EventTypeHitdisposed         EventType = "HITDisposed"
	EventTypePing                EventType = "Ping"
)

Enum values for EventType

type HIT 

type HIT struct {

	// The number of times the HIT can be accepted and completed before the HIT becomes
	// unavailable.
	MaxAssignments *int32

	// The status of the HIT and its assignments. Valid Values are Assignable |
	// Unassignable | Reviewable | Reviewing | Disposed.
	HITStatus HITStatus

	// The ID of the HIT type of this HIT
	HITTypeId *string

	// The date and time the HIT was created.
	CreationTime *time.Time

	// The length of time, in seconds, that a Worker has to complete the HIT after
	// accepting it.
	AssignmentDurationInSeconds *int64

	// The date and time the HIT expires.
	Expiration *time.Time

	// A general description of the HIT.
	Description *string

	// The ID of the HIT Group of this HIT.
	HITGroupId *string

	// One or more words or phrases that describe the HIT, separated by commas. Search
	// terms similar to the keywords of a HIT are more likely to have the HIT in the
	// search results.
	Keywords *string

	// An arbitrary data field the Requester who created the HIT can use. This field is
	// visible only to the creator of the HIT.
	RequesterAnnotation *string

	// The number of assignments for this HIT that have been approved or rejected.
	NumberOfAssignmentsCompleted *int32

	// The number of assignments for this HIT that are available for Workers to accept.
	NumberOfAssignmentsAvailable *int32

	// The number of assignments for this HIT that are being previewed or have been
	// accepted by Workers, but have not yet been submitted, returned, or abandoned.
	NumberOfAssignmentsPending *int32

	// The ID of the HIT Layout of this HIT.
	HITLayoutId *string

	// Conditions that a Worker's Qualifications must meet in order to accept the HIT.
	// A HIT can have between zero and ten Qualification requirements. All requirements
	// must be met in order for a Worker to accept the HIT. Additionally, other actions
	// can be restricted using the ActionsGuarded field on each
	// QualificationRequirement structure.
	QualificationRequirements []*QualificationRequirement

	// The amount of time, in seconds, after the Worker submits an assignment for the
	// HIT that the results are automatically approved by Amazon Mechanical Turk. This
	// is the amount of time the Requester has to reject an assignment submitted by a
	// Worker before the assignment is auto-approved and the Worker is paid.
	AutoApprovalDelayInSeconds *int64

	// A string representing a currency amount.
	Reward *string

	// The data the Worker completing the HIT uses produce the results. This is either
	// either a QuestionForm, HTMLQuestion or an ExternalQuestion data structure.
	Question *string

	// Indicates the review status of the HIT. Valid Values are NotReviewed |
	// MarkedForReview | ReviewedAppropriate | ReviewedInappropriate.
	HITReviewStatus HITReviewStatus

	// A unique identifier for the HIT.
	HITId *string

	// The title of the HIT.
	Title *string
}

The HIT data structure represents a single HIT, including all the information necessary for a Worker to accept and complete the HIT.

type HITAccessActions 

type HITAccessActions string
const (
	HITAccessActionsAccept                   HITAccessActions = "Accept"
	HITAccessActionsPreviewandaccept         HITAccessActions = "PreviewAndAccept"
	HITAccessActionsDiscoverpreviewandaccept HITAccessActions = "DiscoverPreviewAndAccept"
)

Enum values for HITAccessActions

type HITLayoutParameter 

type HITLayoutParameter struct {

	// The name of the parameter in the HITLayout.
	//
	// This member is required.
	Name *string

	// The value substituted for the parameter referenced in the HITLayout.
	//
	// This member is required.
	Value *string
}

The HITLayoutParameter data structure defines parameter values used with a HITLayout. A HITLayout is a reusable Amazon Mechanical Turk project template used to provide Human Intelligence Task (HIT) question data for CreateHIT.

type HITReviewStatus 

type HITReviewStatus string
const (
	HITReviewStatusNotreviewed           HITReviewStatus = "NotReviewed"
	HITReviewStatusMarkedforreview       HITReviewStatus = "MarkedForReview"
	HITReviewStatusReviewedappropriate   HITReviewStatus = "ReviewedAppropriate"
	HITReviewStatusReviewedinappropriate HITReviewStatus = "ReviewedInappropriate"
)

Enum values for HITReviewStatus

type HITStatus 

type HITStatus string
const (
	HITStatusAssignable   HITStatus = "Assignable"
	HITStatusUnassignable HITStatus = "Unassignable"
	HITStatusReviewable   HITStatus = "Reviewable"
	HITStatusReviewing    HITStatus = "Reviewing"
	HITStatusDisposed     HITStatus = "Disposed"
)

Enum values for HITStatus

type Locale 

type Locale struct {

	// The country of the locale. Must be a valid ISO 3166 country code. For example,
	// the code US refers to the United States of America.
	//
	// This member is required.
	Country *string

	// The state or subdivision of the locale. A valid ISO 3166-2 subdivision code. For
	// example, the code WA refers to the state of Washington.
	Subdivision *string
}

The Locale data structure represents a geographical region or location.

type NotificationSpecification 

type NotificationSpecification struct {

	// The list of events that should cause notifications to be sent. Valid Values:
	// AssignmentAccepted | AssignmentAbandoned | AssignmentReturned |
	// AssignmentSubmitted | AssignmentRejected | AssignmentApproved | HITCreated |
	// HITExtended | HITDisposed | HITReviewable | HITExpired | Ping. The Ping event is
	// only valid for the SendTestEventNotification operation.
	//
	// This member is required.
	EventTypes []EventType

	// The method Amazon Mechanical Turk uses to send the notification. Valid Values:
	// Email | SQS | SNS.
	//
	// This member is required.
	Transport NotificationTransport

	// The target for notification messages. The Destination’s format is determined by
	// the specified Transport:
	//
	//     * When Transport is Email, the Destination is your
	// email address.
	//
	//     * When Transport is SQS, the Destination is your queue
	// URL.
	//
	//     * When Transport is SNS, the Destination is the ARN of your topic.
	//
	// This member is required.
	Destination *string

	// The version of the Notification API to use. Valid value is 2006-05-05.
	//
	// This member is required.
	Version *string
}

The NotificationSpecification data structure describes a HIT event notification for a HIT type.

type NotificationTransport 

type NotificationTransport string
const (
	NotificationTransportEmail NotificationTransport = "Email"
	NotificationTransportSqs   NotificationTransport = "SQS"
	NotificationTransportSns   NotificationTransport = "SNS"
)

Enum values for NotificationTransport

type NotifyWorkersFailureCode 

type NotifyWorkersFailureCode string
const (
	NotifyWorkersFailureCodeSoftfailure NotifyWorkersFailureCode = "SoftFailure"
	NotifyWorkersFailureCodeHardfailure NotifyWorkersFailureCode = "HardFailure"
)

Enum values for NotifyWorkersFailureCode

type NotifyWorkersFailureStatus 

type NotifyWorkersFailureStatus struct {

	// A message detailing the reason the Worker could not be notified.
	NotifyWorkersFailureMessage *string

	// The ID of the Worker.
	WorkerId *string

	// Encoded value for the failure type.
	NotifyWorkersFailureCode NotifyWorkersFailureCode
}

When MTurk encounters an issue with notifying the Workers you specified, it returns back this object with failure details.

type ParameterMapEntry 

type ParameterMapEntry struct {

	// The list of answers to the question specified in the MapEntry Key element. The
	// Worker must match all values in order for the answer to be scored correctly.
	Values []*string

	// The QuestionID from the HIT that is used to identify which question requires
	// Mechanical Turk to score as part of the ScoreMyKnownAnswers/2011-09-01 Review
	// Policy.
	Key *string
}

This data structure is the data type for the AnswerKey parameter of the ScoreMyKnownAnswers/2011-09-01 Review Policy.

type PolicyParameter 

type PolicyParameter struct {

	// Name of the parameter from the list of Review Polices.
	Key *string

	// The list of values of the Parameter
	Values []*string

	// List of ParameterMapEntry objects.
	MapEntries []*ParameterMapEntry
}

Name of the parameter from the Review policy.

type Qualification 

type Qualification struct {

	// The value (score) of the Qualification, if the Qualification has an integer
	// value.
	IntegerValue *int32

	// The Locale data structure represents a geographical region or location.
	LocaleValue *Locale

	// The ID of the Worker who possesses the Qualification.
	WorkerId *string

	// The ID of the Qualification type for the Qualification.
	QualificationTypeId *string

	// The date and time the Qualification was granted to the Worker. If the Worker's
	// Qualification was revoked, and then re-granted based on a new Qualification
	// request, GrantTime is the date and time of the last call to the
	// AcceptQualificationRequest operation.
	GrantTime *time.Time

	// The status of the Qualification. Valid values are Granted | Revoked.
	Status QualificationStatus
}

The Qualification data structure represents a Qualification assigned to a user, including the Qualification type and the value (score).

type QualificationRequest 

type QualificationRequest struct {

	// The ID of the Qualification type the Worker is requesting, as returned by the
	// CreateQualificationType operation.
	QualificationTypeId *string

	// The ID of the Worker requesting the Qualification.
	WorkerId *string

	// The ID of the Qualification request, a unique identifier generated when the
	// request was submitted.  </p>
	QualificationRequestId *string

	// The date and time the Qualification request had a status of Submitted. This is
	// either the time the Worker submitted answers for a Qualification test, or the
	// time the Worker requested the Qualification if the Qualification type does not
	// have a test.
	SubmitTime *time.Time

	// The Worker's answers for the Qualification type's test contained in a
	// QuestionFormAnswers document, if the type has a test and the Worker has
	// submitted answers. If the Worker does not provide any answers, Answer may be
	// empty.
	Answer *string

	// The contents of the Qualification test that was presented to the Worker, if the
	// type has a test and the Worker has submitted answers. This value is identical to
	// the QuestionForm associated with the Qualification type at the time the Worker
	// requests the Qualification.
	Test *string
}

The QualificationRequest data structure represents a request a Worker has made for a Qualification.

type QualificationRequirement 

type QualificationRequirement struct {

	// Setting this attribute prevents Workers whose Qualifications do not meet this
	// QualificationRequirement from taking the specified action. Valid arguments
	// include "Accept" (Worker cannot accept the HIT, but can preview the HIT and see
	// it in their search results), "PreviewAndAccept" (Worker cannot accept or preview
	// the HIT, but can see the HIT in their search results), and
	// "DiscoverPreviewAndAccept" (Worker cannot accept, preview, or see the HIT in
	// their search results). It's possible for you to create a HIT with multiple
	// QualificationRequirements (which can have different values for the ActionGuarded
	// attribute). In this case, the Worker is only permitted to perform an action when
	// they have met all QualificationRequirements guarding the action. The actions in
	// the order of least restrictive to most restrictive are Discover, Preview and
	// Accept. For example, if a Worker meets all QualificationRequirements that are
	// set to DiscoverPreviewAndAccept, but do not meet all requirements that are set
	// with PreviewAndAccept, then the Worker will be able to Discover, i.e. see the
	// HIT in their search result, but will not be able to Preview or Accept the HIT.
	// ActionsGuarded should not be used in combination with the RequiredToPreview
	// field.
	ActionsGuarded HITAccessActions

	// DEPRECATED: Use the ActionsGuarded field instead. If RequiredToPreview is true,
	// the question data for the HIT will not be shown when a Worker whose
	// Qualifications do not meet this requirement tries to preview the HIT. That is, a
	// Worker's Qualifications must meet all of the requirements for which
	// RequiredToPreview is true in order to preview the HIT. If a Worker meets all of
	// the requirements where RequiredToPreview is true (or if there are no such
	// requirements), but does not meet all of the requirements for the HIT, the Worker
	// will be allowed to preview the HIT's question data, but will not be allowed to
	// accept and complete the HIT. The default is false. This should not be used in
	// combination with the ActionsGuarded field.
	RequiredToPreview *bool

	// The locale value to compare against the Qualification's value. The local value
	// must be a valid ISO 3166 country code or supports ISO 3166-2 subdivisions.
	// LocaleValue can only be used with a Worker_Locale QualificationType ID.
	// LocaleValue can only be used with the EqualTo, NotEqualTo, In, and NotIn
	// comparators. You must only use a single LocaleValue element when using the
	// EqualTo or NotEqualTo comparators. When performing a set comparison by using the
	// In or the NotIn comparator, you can use up to 30 LocaleValue elements in a
	// QualificationRequirement data structure.
	LocaleValues []*Locale

	// The integer value to compare against the Qualification's value. IntegerValue
	// must not be present if Comparator is Exists or DoesNotExist. IntegerValue can
	// only be used if the Qualification type has an integer value; it cannot be used
	// with the Worker_Locale QualificationType ID. When performing a set comparison by
	// using the In or the NotIn comparator, you can use up to 15 IntegerValue elements
	// in a QualificationRequirement data structure.
	IntegerValues []*int32

	// The ID of the Qualification type for the requirement.
	//
	// This member is required.
	QualificationTypeId *string

	// The kind of comparison to make against a Qualification's value. You can compare
	// a Qualification's value to an IntegerValue to see if it is LessThan,
	// LessThanOrEqualTo, GreaterThan, GreaterThanOrEqualTo, EqualTo, or NotEqualTo the
	// IntegerValue. You can compare it to a LocaleValue to see if it is EqualTo, or
	// NotEqualTo the LocaleValue. You can check to see if the value is In or NotIn a
	// set of IntegerValue or LocaleValue values. Lastly, a Qualification requirement
	// can also test if a Qualification Exists or DoesNotExist in the user's profile,
	// regardless of its value.
	//
	// This member is required.
	Comparator Comparator
}

The QualificationRequirement data structure describes a Qualification that a Worker must have before the Worker is allowed to accept a HIT. A requirement may optionally state that a Worker must have the Qualification in order to preview the HIT, or see the HIT in search results.

type QualificationStatus 

type QualificationStatus string
const (
	QualificationStatusGranted QualificationStatus = "Granted"
	QualificationStatusRevoked QualificationStatus = "Revoked"
)

Enum values for QualificationStatus

type QualificationType 

type QualificationType struct {

	// The questions for a Qualification test associated with this Qualification type
	// that a user can take to obtain a Qualification of this type. This parameter must
	// be specified if AnswerKey is present. A Qualification type cannot have both a
	// specified Test parameter and an AutoGranted value of true.
	Test *string

	// The amount of time, in seconds, Workers must wait after taking the Qualification
	// test before they can take it again. Workers can take a Qualification test
	// multiple times if they were not granted the Qualification from a previous
	// attempt, or if the test offers a gradient score and they want a better score. If
	// not specified, retries are disabled and Workers can request a Qualification only
	// once.
	RetryDelayInSeconds *int64

	// The name of the Qualification type. The type name is used to identify the type,
	// and to find the type using a Qualification type search.
	Name *string

	// One or more words or phrases that describe theQualification type, separated by
	// commas. The Keywords make the type easier to find using a search.
	Keywords *string

	// A unique identifier for the Qualification type. A Qualification type is given a
	// Qualification type ID when you call the CreateQualificationType operation.
	QualificationTypeId *string

	// Specifies that requests for the Qualification type are granted immediately,
	// without prompting the Worker with a Qualification test. Valid values are True |
	// False.
	AutoGranted *bool

	// The date and time the Qualification type was created.
	CreationTime *time.Time

	// The amount of time, in seconds, given to a Worker to complete the Qualification
	// test, beginning from the time the Worker requests the Qualification.
	TestDurationInSeconds *int64

	// A long description for the Qualification type.
	Description *string

	// The Qualification integer value to use for automatically granted Qualifications,
	// if AutoGranted is true. This is 1 by default.
	AutoGrantedValue *int32

	// The status of the Qualification type. A Qualification type's status determines
	// if users can apply to receive a Qualification of this type, and if HITs can be
	// created with requirements based on this type. Valid values are Active |
	// Inactive.
	QualificationTypeStatus QualificationTypeStatus

	// Specifies whether the Qualification type is one that a user can request through
	// the Amazon Mechanical Turk web site, such as by taking a Qualification test.
	// This value is False for Qualifications assigned automatically by the system.
	// Valid values are True | False.
	IsRequestable *bool

	// The answers to the Qualification test specified in the Test parameter.
	AnswerKey *string
}

The QualificationType data structure represents a Qualification type, a description of a property of a Worker that must match the requirements of a HIT for the Worker to be able to accept the HIT. The type also describes how a Worker can obtain a Qualification of that type, such as through a Qualification test.

type QualificationTypeStatus 

type QualificationTypeStatus string
const (
	QualificationTypeStatusActive   QualificationTypeStatus = "Active"
	QualificationTypeStatusInactive QualificationTypeStatus = "Inactive"
)

Enum values for QualificationTypeStatus

type RequestError 

type RequestError struct {
	Message *string

	TurkErrorCode *string
}

Your request is invalid.

func (*RequestError) Error 

func (e *RequestError) Error() string

func (*RequestError) ErrorCode 

func (e *RequestError) ErrorCode() string

func (*RequestError) ErrorFault 

func (e *RequestError) ErrorFault() smithy.ErrorFault

func (*RequestError) ErrorMessage 

func (e *RequestError) ErrorMessage() string

type ReviewActionDetail 

type ReviewActionDetail struct {

	// The unique identifier for the action.
	ActionId *string

	// The date when the action was completed.
	CompleteTime *time.Time

	// The nature of the action itself. The Review Policy is responsible for examining
	// the HIT and Assignments, emitting results, and deciding which other actions will
	// be necessary.
	ActionName *string

	// A description of the outcome of the review.
	Result *string

	// The specific HITId or AssignmentID targeted by the action.
	TargetId *string

	// The type of object in TargetId.
	TargetType *string

	// Present only when the Results have a FAILED Status.
	ErrorCode *string

	// The current disposition of the action: INTENDED, SUCCEEDED, FAILED, or
	// CANCELLED.
	Status ReviewActionStatus
}

Both the AssignmentReviewReport and the HITReviewReport elements contains the ReviewActionDetail data structure. This structure is returned multiple times for each action specified in the Review Policy.

type ReviewActionStatus 

type ReviewActionStatus string
const (
	ReviewActionStatusIntended  ReviewActionStatus = "Intended"
	ReviewActionStatusSucceeded ReviewActionStatus = "Succeeded"
	ReviewActionStatusFailed    ReviewActionStatus = "Failed"
	ReviewActionStatusCancelled ReviewActionStatus = "Cancelled"
)

Enum values for ReviewActionStatus

type ReviewPolicy 

type ReviewPolicy struct {

	// Name of the parameter from the Review policy.
	Parameters []*PolicyParameter

	// Name of a Review Policy: SimplePlurality/2011-09-01 or
	// ScoreMyKnownAnswers/2011-09-01
	//
	// This member is required.
	PolicyName *string
}

HIT Review Policy data structures represent HIT review policies, which you specify when you create a HIT.

type ReviewPolicyLevel 

type ReviewPolicyLevel string
const (
	ReviewPolicyLevelAssignment ReviewPolicyLevel = "Assignment"
	ReviewPolicyLevelHit        ReviewPolicyLevel = "HIT"
)

Enum values for ReviewPolicyLevel

type ReviewReport 

type ReviewReport struct {

	// A list of ReviewAction objects for each action specified in the Review Policy.
	ReviewActions []*ReviewActionDetail

	// A list of ReviewResults objects for each action specified in the Review Policy.
	ReviewResults []*ReviewResultDetail
}

Contains both ReviewResult and ReviewAction elements for a particular HIT.

type ReviewResultDetail 

type ReviewResultDetail struct {

	// Specifies the QuestionId the result is describing. Depending on whether the
	// TargetType is a HIT or Assignment this results could specify multiple values. If
	// TargetType is HIT and QuestionId is absent, then the result describes results of
	// the HIT, including the HIT agreement score. If ObjectType is Assignment and
	// QuestionId is absent, then the result describes the Worker's performance on the
	// HIT.
	QuestionId *string

	// A unique identifier of the Review action result.
	ActionId *string

	// Key identifies the particular piece of reviewed information.
	Key *string

	// The HITID or AssignmentId about which this result was taken. Note that HIT-level
	// Review Policies will often emit results about both the HIT itself and its
	// Assignments, while Assignment-level review policies generally only emit results
	// about the Assignment itself.
	SubjectId *string

	// The type of the object from the SubjectId field.
	SubjectType *string

	// The values of Key provided by the review policies you have selected.
	Value *string
}

This data structure is returned multiple times for each result specified in the Review Policy.

type ReviewableHITStatus 

type ReviewableHITStatus string
const (
	ReviewableHITStatusReviewable ReviewableHITStatus = "Reviewable"
	ReviewableHITStatusReviewing  ReviewableHITStatus = "Reviewing"
)

Enum values for ReviewableHITStatus

type ServiceFault 

type ServiceFault struct {
	Message *string

	TurkErrorCode *string
}

Amazon Mechanical Turk is temporarily unable to process your request. Try your call again.

func (*ServiceFault) Error 

func (e *ServiceFault) Error() string

func (*ServiceFault) ErrorCode 

func (e *ServiceFault) ErrorCode() string

func (*ServiceFault) ErrorFault 

func (e *ServiceFault) ErrorFault() smithy.ErrorFault

func (*ServiceFault) ErrorMessage 

func (e *ServiceFault) ErrorMessage() string

type WorkerBlock 

type WorkerBlock struct {

	// A message explaining the reason the Worker was blocked.
	Reason *string

	// The ID of the Worker who accepted the HIT.
	WorkerId *string
}

The WorkerBlock data structure represents a Worker who has been blocked. It has two elements: the WorkerId and the Reason for the block.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.