@aws-sdk/client-mturk 3.50.0 → 3.51.0

package/dist-types/ts3.4/models/models_0.d.ts

@@ -0,0 +1,1269 @@
+import { MetadataBearer as $MetadataBearer, SmithyException as __SmithyException } from "@aws-sdk/types";
+export interface AcceptQualificationRequestRequest {
+    
+    QualificationRequestId: string | undefined;
+    
+    IntegerValue?: number;
+}
+export declare namespace AcceptQualificationRequestRequest {
+    
+    const filterSensitiveLog: (obj: AcceptQualificationRequestRequest) => any;
+}
+export interface AcceptQualificationRequestResponse {
+}
+export declare namespace AcceptQualificationRequestResponse {
+    
+    const filterSensitiveLog: (obj: AcceptQualificationRequestResponse) => any;
+}
+
+export interface RequestError extends __SmithyException, $MetadataBearer {
+    name: "RequestError";
+    $fault: "client";
+    Message?: string;
+    TurkErrorCode?: string;
+}
+
+export interface ServiceFault extends __SmithyException, $MetadataBearer {
+    name: "ServiceFault";
+    $fault: "server";
+    Message?: string;
+    TurkErrorCode?: string;
+}
+export interface ApproveAssignmentRequest {
+    
+    AssignmentId: string | undefined;
+    
+    RequesterFeedback?: string;
+    
+    OverrideRejection?: boolean;
+}
+export declare namespace ApproveAssignmentRequest {
+    
+    const filterSensitiveLog: (obj: ApproveAssignmentRequest) => any;
+}
+export interface ApproveAssignmentResponse {
+}
+export declare namespace ApproveAssignmentResponse {
+    
+    const filterSensitiveLog: (obj: ApproveAssignmentResponse) => any;
+}
+export declare enum AssignmentStatus {
+    Approved = "Approved",
+    Rejected = "Rejected",
+    Submitted = "Submitted"
+}
+
+export interface Assignment {
+    
+    AssignmentId?: string;
+    
+    WorkerId?: string;
+    
+    HITId?: string;
+    
+    AssignmentStatus?: AssignmentStatus | string;
+    
+    AutoApprovalTime?: Date;
+    
+    AcceptTime?: Date;
+    
+    SubmitTime?: Date;
+    
+    ApprovalTime?: Date;
+    
+    RejectionTime?: Date;
+    
+    Deadline?: Date;
+    
+    Answer?: string;
+    
+    RequesterFeedback?: string;
+}
+export declare namespace Assignment {
+    
+    const filterSensitiveLog: (obj: Assignment) => any;
+}
+export interface AssociateQualificationWithWorkerRequest {
+    
+    QualificationTypeId: string | undefined;
+    
+    WorkerId: string | undefined;
+    
+    IntegerValue?: number;
+    
+    SendNotification?: boolean;
+}
+export declare namespace AssociateQualificationWithWorkerRequest {
+    
+    const filterSensitiveLog: (obj: AssociateQualificationWithWorkerRequest) => any;
+}
+export interface AssociateQualificationWithWorkerResponse {
+}
+export declare namespace AssociateQualificationWithWorkerResponse {
+    
+    const filterSensitiveLog: (obj: AssociateQualificationWithWorkerResponse) => any;
+}
+
+export interface BonusPayment {
+    
+    WorkerId?: string;
+    
+    BonusAmount?: string;
+    
+    AssignmentId?: string;
+    
+    Reason?: string;
+    
+    GrantTime?: Date;
+}
+export declare namespace BonusPayment {
+    
+    const filterSensitiveLog: (obj: BonusPayment) => any;
+}
+export declare enum Comparator {
+    DoesNotExist = "DoesNotExist",
+    EqualTo = "EqualTo",
+    Exists = "Exists",
+    GreaterThan = "GreaterThan",
+    GreaterThanOrEqualTo = "GreaterThanOrEqualTo",
+    In = "In",
+    LessThan = "LessThan",
+    LessThanOrEqualTo = "LessThanOrEqualTo",
+    NotEqualTo = "NotEqualTo",
+    NotIn = "NotIn"
+}
+export interface CreateAdditionalAssignmentsForHITRequest {
+    
+    HITId: string | undefined;
+    
+    NumberOfAdditionalAssignments: number | undefined;
+    
+    UniqueRequestToken?: string;
+}
+export declare namespace CreateAdditionalAssignmentsForHITRequest {
+    
+    const filterSensitiveLog: (obj: CreateAdditionalAssignmentsForHITRequest) => any;
+}
+export interface CreateAdditionalAssignmentsForHITResponse {
+}
+export declare namespace CreateAdditionalAssignmentsForHITResponse {
+    
+    const filterSensitiveLog: (obj: CreateAdditionalAssignmentsForHITResponse) => any;
+}
+
+export interface ParameterMapEntry {
+    
+    Key?: string;
+    
+    Values?: string[];
+}
+export declare namespace ParameterMapEntry {
+    
+    const filterSensitiveLog: (obj: ParameterMapEntry) => any;
+}
+
+export interface PolicyParameter {
+    
+    Key?: string;
+    
+    Values?: string[];
+    
+    MapEntries?: ParameterMapEntry[];
+}
+export declare namespace PolicyParameter {
+    
+    const filterSensitiveLog: (obj: PolicyParameter) => any;
+}
+
+export interface ReviewPolicy {
+    
+    PolicyName: string | undefined;
+    
+    Parameters?: PolicyParameter[];
+}
+export declare namespace ReviewPolicy {
+    
+    const filterSensitiveLog: (obj: ReviewPolicy) => any;
+}
+
+export interface HITLayoutParameter {
+    
+    Name: string | undefined;
+    
+    Value: string | undefined;
+}
+export declare namespace HITLayoutParameter {
+    
+    const filterSensitiveLog: (obj: HITLayoutParameter) => any;
+}
+export declare enum HITAccessActions {
+    Accept = "Accept",
+    DiscoverPreviewAndAccept = "DiscoverPreviewAndAccept",
+    PreviewAndAccept = "PreviewAndAccept"
+}
+
+export interface Locale {
+    
+    Country: string | undefined;
+    
+    Subdivision?: string;
+}
+export declare namespace Locale {
+    
+    const filterSensitiveLog: (obj: Locale) => any;
+}
+
+export interface QualificationRequirement {
+    
+    QualificationTypeId: string | undefined;
+    
+    Comparator: Comparator | string | undefined;
+    
+    IntegerValues?: number[];
+    
+    LocaleValues?: Locale[];
+    
+    RequiredToPreview?: boolean;
+    
+    ActionsGuarded?: HITAccessActions | string;
+}
+export declare namespace QualificationRequirement {
+    
+    const filterSensitiveLog: (obj: QualificationRequirement) => any;
+}
+export interface CreateHITRequest {
+    
+    MaxAssignments?: number;
+    
+    AutoApprovalDelayInSeconds?: number;
+    
+    LifetimeInSeconds: number | undefined;
+    
+    AssignmentDurationInSeconds: number | undefined;
+    
+    Reward: string | undefined;
+    
+    Title: string | undefined;
+    
+    Keywords?: string;
+    
+    Description: string | undefined;
+    
+    Question?: string;
+    
+    RequesterAnnotation?: string;
+    
+    QualificationRequirements?: QualificationRequirement[];
+    
+    UniqueRequestToken?: string;
+    
+    AssignmentReviewPolicy?: ReviewPolicy;
+    
+    HITReviewPolicy?: ReviewPolicy;
+    
+    HITLayoutId?: string;
+    
+    HITLayoutParameters?: HITLayoutParameter[];
+}
+export declare namespace CreateHITRequest {
+    
+    const filterSensitiveLog: (obj: CreateHITRequest) => any;
+}
+export declare enum HITReviewStatus {
+    MarkedForReview = "MarkedForReview",
+    NotReviewed = "NotReviewed",
+    ReviewedAppropriate = "ReviewedAppropriate",
+    ReviewedInappropriate = "ReviewedInappropriate"
+}
+export declare enum HITStatus {
+    Assignable = "Assignable",
+    Disposed = "Disposed",
+    Reviewable = "Reviewable",
+    Reviewing = "Reviewing",
+    Unassignable = "Unassignable"
+}
+
+export interface HIT {
+    
+    HITId?: string;
+    
+    HITTypeId?: string;
+    
+    HITGroupId?: string;
+    
+    HITLayoutId?: string;
+    
+    CreationTime?: Date;
+    
+    Title?: string;
+    
+    Description?: string;
+    
+    Question?: string;
+    
+    Keywords?: string;
+    
+    HITStatus?: HITStatus | string;
+    
+    MaxAssignments?: number;
+    
+    Reward?: string;
+    
+    AutoApprovalDelayInSeconds?: number;
+    
+    Expiration?: Date;
+    
+    AssignmentDurationInSeconds?: number;
+    
+    RequesterAnnotation?: string;
+    
+    QualificationRequirements?: QualificationRequirement[];
+    
+    HITReviewStatus?: HITReviewStatus | string;
+    
+    NumberOfAssignmentsPending?: number;
+    
+    NumberOfAssignmentsAvailable?: number;
+    
+    NumberOfAssignmentsCompleted?: number;
+}
+export declare namespace HIT {
+    
+    const filterSensitiveLog: (obj: HIT) => any;
+}
+export interface CreateHITResponse {
+    
+    HIT?: HIT;
+}
+export declare namespace CreateHITResponse {
+    
+    const filterSensitiveLog: (obj: CreateHITResponse) => any;
+}
+export interface CreateHITTypeRequest {
+    
+    AutoApprovalDelayInSeconds?: number;
+    
+    AssignmentDurationInSeconds: number | undefined;
+    
+    Reward: string | undefined;
+    
+    Title: string | undefined;
+    
+    Keywords?: string;
+    
+    Description: string | undefined;
+    
+    QualificationRequirements?: QualificationRequirement[];
+}
+export declare namespace CreateHITTypeRequest {
+    
+    const filterSensitiveLog: (obj: CreateHITTypeRequest) => any;
+}
+export interface CreateHITTypeResponse {
+    
+    HITTypeId?: string;
+}
+export declare namespace CreateHITTypeResponse {
+    
+    const filterSensitiveLog: (obj: CreateHITTypeResponse) => any;
+}
+export interface CreateHITWithHITTypeRequest {
+    
+    HITTypeId: string | undefined;
+    
+    MaxAssignments?: number;
+    
+    LifetimeInSeconds: number | undefined;
+    
+    Question?: string;
+    
+    RequesterAnnotation?: string;
+    
+    UniqueRequestToken?: string;
+    
+    AssignmentReviewPolicy?: ReviewPolicy;
+    
+    HITReviewPolicy?: ReviewPolicy;
+    
+    HITLayoutId?: string;
+    
+    HITLayoutParameters?: HITLayoutParameter[];
+}
+export declare namespace CreateHITWithHITTypeRequest {
+    
+    const filterSensitiveLog: (obj: CreateHITWithHITTypeRequest) => any;
+}
+export interface CreateHITWithHITTypeResponse {
+    
+    HIT?: HIT;
+}
+export declare namespace CreateHITWithHITTypeResponse {
+    
+    const filterSensitiveLog: (obj: CreateHITWithHITTypeResponse) => any;
+}
+export declare enum QualificationTypeStatus {
+    Active = "Active",
+    Inactive = "Inactive"
+}
+export interface CreateQualificationTypeRequest {
+    
+    Name: string | undefined;
+    
+    Keywords?: string;
+    
+    Description: string | undefined;
+    
+    QualificationTypeStatus: QualificationTypeStatus | string | undefined;
+    
+    RetryDelayInSeconds?: number;
+    
+    Test?: string;
+    
+    AnswerKey?: string;
+    
+    TestDurationInSeconds?: number;
+    
+    AutoGranted?: boolean;
+    
+    AutoGrantedValue?: number;
+}
+export declare namespace CreateQualificationTypeRequest {
+    
+    const filterSensitiveLog: (obj: CreateQualificationTypeRequest) => any;
+}
+
+export interface QualificationType {
+    
+    QualificationTypeId?: string;
+    
+    CreationTime?: Date;
+    
+    Name?: string;
+    
+    Description?: string;
+    
+    Keywords?: string;
+    
+    QualificationTypeStatus?: QualificationTypeStatus | string;
+    
+    Test?: string;
+    
+    TestDurationInSeconds?: number;
+    
+    AnswerKey?: string;
+    
+    RetryDelayInSeconds?: number;
+    
+    IsRequestable?: boolean;
+    
+    AutoGranted?: boolean;
+    
+    AutoGrantedValue?: number;
+}
+export declare namespace QualificationType {
+    
+    const filterSensitiveLog: (obj: QualificationType) => any;
+}
+export interface CreateQualificationTypeResponse {
+    
+    QualificationType?: QualificationType;
+}
+export declare namespace CreateQualificationTypeResponse {
+    
+    const filterSensitiveLog: (obj: CreateQualificationTypeResponse) => any;
+}
+export interface CreateWorkerBlockRequest {
+    
+    WorkerId: string | undefined;
+    
+    Reason: string | undefined;
+}
+export declare namespace CreateWorkerBlockRequest {
+    
+    const filterSensitiveLog: (obj: CreateWorkerBlockRequest) => any;
+}
+export interface CreateWorkerBlockResponse {
+}
+export declare namespace CreateWorkerBlockResponse {
+    
+    const filterSensitiveLog: (obj: CreateWorkerBlockResponse) => any;
+}
+export interface DeleteHITRequest {
+    
+    HITId: string | undefined;
+}
+export declare namespace DeleteHITRequest {
+    
+    const filterSensitiveLog: (obj: DeleteHITRequest) => any;
+}
+export interface DeleteHITResponse {
+}
+export declare namespace DeleteHITResponse {
+    
+    const filterSensitiveLog: (obj: DeleteHITResponse) => any;
+}
+export interface DeleteQualificationTypeRequest {
+    
+    QualificationTypeId: string | undefined;
+}
+export declare namespace DeleteQualificationTypeRequest {
+    
+    const filterSensitiveLog: (obj: DeleteQualificationTypeRequest) => any;
+}
+export interface DeleteQualificationTypeResponse {
+}
+export declare namespace DeleteQualificationTypeResponse {
+    
+    const filterSensitiveLog: (obj: DeleteQualificationTypeResponse) => any;
+}
+export interface DeleteWorkerBlockRequest {
+    
+    WorkerId: string | undefined;
+    
+    Reason?: string;
+}
+export declare namespace DeleteWorkerBlockRequest {
+    
+    const filterSensitiveLog: (obj: DeleteWorkerBlockRequest) => any;
+}
+export interface DeleteWorkerBlockResponse {
+}
+export declare namespace DeleteWorkerBlockResponse {
+    
+    const filterSensitiveLog: (obj: DeleteWorkerBlockResponse) => any;
+}
+export interface DisassociateQualificationFromWorkerRequest {
+    
+    WorkerId: string | undefined;
+    
+    QualificationTypeId: string | undefined;
+    
+    Reason?: string;
+}
+export declare namespace DisassociateQualificationFromWorkerRequest {
+    
+    const filterSensitiveLog: (obj: DisassociateQualificationFromWorkerRequest) => any;
+}
+export interface DisassociateQualificationFromWorkerResponse {
+}
+export declare namespace DisassociateQualificationFromWorkerResponse {
+    
+    const filterSensitiveLog: (obj: DisassociateQualificationFromWorkerResponse) => any;
+}
+export declare enum EventType {
+    AssignmentAbandoned = "AssignmentAbandoned",
+    AssignmentAccepted = "AssignmentAccepted",
+    AssignmentApproved = "AssignmentApproved",
+    AssignmentRejected = "AssignmentRejected",
+    AssignmentReturned = "AssignmentReturned",
+    AssignmentSubmitted = "AssignmentSubmitted",
+    HITCreated = "HITCreated",
+    HITDisposed = "HITDisposed",
+    HITExpired = "HITExpired",
+    HITExtended = "HITExtended",
+    HITReviewable = "HITReviewable",
+    Ping = "Ping"
+}
+export interface GetAccountBalanceRequest {
+}
+export declare namespace GetAccountBalanceRequest {
+    
+    const filterSensitiveLog: (obj: GetAccountBalanceRequest) => any;
+}
+export interface GetAccountBalanceResponse {
+    
+    AvailableBalance?: string;
+    
+    OnHoldBalance?: string;
+}
+export declare namespace GetAccountBalanceResponse {
+    
+    const filterSensitiveLog: (obj: GetAccountBalanceResponse) => any;
+}
+export interface GetAssignmentRequest {
+    
+    AssignmentId: string | undefined;
+}
+export declare namespace GetAssignmentRequest {
+    
+    const filterSensitiveLog: (obj: GetAssignmentRequest) => any;
+}
+export interface GetAssignmentResponse {
+    
+    Assignment?: Assignment;
+    
+    HIT?: HIT;
+}
+export declare namespace GetAssignmentResponse {
+    
+    const filterSensitiveLog: (obj: GetAssignmentResponse) => any;
+}
+export interface GetFileUploadURLRequest {
+    
+    AssignmentId: string | undefined;
+    
+    QuestionIdentifier: string | undefined;
+}
+export declare namespace GetFileUploadURLRequest {
+    
+    const filterSensitiveLog: (obj: GetFileUploadURLRequest) => any;
+}
+export interface GetFileUploadURLResponse {
+    
+    FileUploadURL?: string;
+}
+export declare namespace GetFileUploadURLResponse {
+    
+    const filterSensitiveLog: (obj: GetFileUploadURLResponse) => any;
+}
+export interface GetHITRequest {
+    
+    HITId: string | undefined;
+}
+export declare namespace GetHITRequest {
+    
+    const filterSensitiveLog: (obj: GetHITRequest) => any;
+}
+export interface GetHITResponse {
+    
+    HIT?: HIT;
+}
+export declare namespace GetHITResponse {
+    
+    const filterSensitiveLog: (obj: GetHITResponse) => any;
+}
+export interface GetQualificationScoreRequest {
+    
+    QualificationTypeId: string | undefined;
+    
+    WorkerId: string | undefined;
+}
+export declare namespace GetQualificationScoreRequest {
+    
+    const filterSensitiveLog: (obj: GetQualificationScoreRequest) => any;
+}
+export declare enum QualificationStatus {
+    Granted = "Granted",
+    Revoked = "Revoked"
+}
+
+export interface Qualification {
+    
+    QualificationTypeId?: string;
+    
+    WorkerId?: string;
+    
+    GrantTime?: Date;
+    
+    IntegerValue?: number;
+    
+    LocaleValue?: Locale;
+    
+    Status?: QualificationStatus | string;
+}
+export declare namespace Qualification {
+    
+    const filterSensitiveLog: (obj: Qualification) => any;
+}
+export interface GetQualificationScoreResponse {
+    
+    Qualification?: Qualification;
+}
+export declare namespace GetQualificationScoreResponse {
+    
+    const filterSensitiveLog: (obj: GetQualificationScoreResponse) => any;
+}
+export interface GetQualificationTypeRequest {
+    
+    QualificationTypeId: string | undefined;
+}
+export declare namespace GetQualificationTypeRequest {
+    
+    const filterSensitiveLog: (obj: GetQualificationTypeRequest) => any;
+}
+export interface GetQualificationTypeResponse {
+    
+    QualificationType?: QualificationType;
+}
+export declare namespace GetQualificationTypeResponse {
+    
+    const filterSensitiveLog: (obj: GetQualificationTypeResponse) => any;
+}
+export interface ListAssignmentsForHITRequest {
+    
+    HITId: string | undefined;
+    
+    NextToken?: string;
+    MaxResults?: number;
+    
+    AssignmentStatuses?: (AssignmentStatus | string)[];
+}
+export declare namespace ListAssignmentsForHITRequest {
+    
+    const filterSensitiveLog: (obj: ListAssignmentsForHITRequest) => any;
+}
+export interface ListAssignmentsForHITResponse {
+    
+    NextToken?: string;
+    
+    NumResults?: number;
+    
+    Assignments?: Assignment[];
+}
+export declare namespace ListAssignmentsForHITResponse {
+    
+    const filterSensitiveLog: (obj: ListAssignmentsForHITResponse) => any;
+}
+export interface ListBonusPaymentsRequest {
+    
+    HITId?: string;
+    
+    AssignmentId?: string;
+    
+    NextToken?: string;
+    MaxResults?: number;
+}
+export declare namespace ListBonusPaymentsRequest {
+    
+    const filterSensitiveLog: (obj: ListBonusPaymentsRequest) => any;
+}
+export interface ListBonusPaymentsResponse {
+    
+    NumResults?: number;
+    
+    NextToken?: string;
+    
+    BonusPayments?: BonusPayment[];
+}
+export declare namespace ListBonusPaymentsResponse {
+    
+    const filterSensitiveLog: (obj: ListBonusPaymentsResponse) => any;
+}
+export interface ListHITsRequest {
+    
+    NextToken?: string;
+    MaxResults?: number;
+}
+export declare namespace ListHITsRequest {
+    
+    const filterSensitiveLog: (obj: ListHITsRequest) => any;
+}
+export interface ListHITsResponse {
+    
+    NextToken?: string;
+    
+    NumResults?: number;
+    
+    HITs?: HIT[];
+}
+export declare namespace ListHITsResponse {
+    
+    const filterSensitiveLog: (obj: ListHITsResponse) => any;
+}
+export interface ListHITsForQualificationTypeRequest {
+    
+    QualificationTypeId: string | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListHITsForQualificationTypeRequest {
+    
+    const filterSensitiveLog: (obj: ListHITsForQualificationTypeRequest) => any;
+}
+export interface ListHITsForQualificationTypeResponse {
+    
+    NextToken?: string;
+    
+    NumResults?: number;
+    
+    HITs?: HIT[];
+}
+export declare namespace ListHITsForQualificationTypeResponse {
+    
+    const filterSensitiveLog: (obj: ListHITsForQualificationTypeResponse) => any;
+}
+export interface ListQualificationRequestsRequest {
+    
+    QualificationTypeId?: string;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListQualificationRequestsRequest {
+    
+    const filterSensitiveLog: (obj: ListQualificationRequestsRequest) => any;
+}
+
+export interface QualificationRequest {
+    
+    QualificationRequestId?: string;
+    
+    QualificationTypeId?: string;
+    
+    WorkerId?: string;
+    
+    Test?: string;
+    
+    Answer?: string;
+    
+    SubmitTime?: Date;
+}
+export declare namespace QualificationRequest {
+    
+    const filterSensitiveLog: (obj: QualificationRequest) => any;
+}
+export interface ListQualificationRequestsResponse {
+    
+    NumResults?: number;
+    
+    NextToken?: string;
+    
+    QualificationRequests?: QualificationRequest[];
+}
+export declare namespace ListQualificationRequestsResponse {
+    
+    const filterSensitiveLog: (obj: ListQualificationRequestsResponse) => any;
+}
+export interface ListQualificationTypesRequest {
+    
+    Query?: string;
+    
+    MustBeRequestable: boolean | undefined;
+    
+    MustBeOwnedByCaller?: boolean;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListQualificationTypesRequest {
+    
+    const filterSensitiveLog: (obj: ListQualificationTypesRequest) => any;
+}
+export interface ListQualificationTypesResponse {
+    
+    NumResults?: number;
+    
+    NextToken?: string;
+    
+    QualificationTypes?: QualificationType[];
+}
+export declare namespace ListQualificationTypesResponse {
+    
+    const filterSensitiveLog: (obj: ListQualificationTypesResponse) => any;
+}
+export declare enum ReviewableHITStatus {
+    Reviewable = "Reviewable",
+    Reviewing = "Reviewing"
+}
+export interface ListReviewableHITsRequest {
+    
+    HITTypeId?: string;
+    
+    Status?: ReviewableHITStatus | string;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListReviewableHITsRequest {
+    
+    const filterSensitiveLog: (obj: ListReviewableHITsRequest) => any;
+}
+export interface ListReviewableHITsResponse {
+    
+    NextToken?: string;
+    
+    NumResults?: number;
+    
+    HITs?: HIT[];
+}
+export declare namespace ListReviewableHITsResponse {
+    
+    const filterSensitiveLog: (obj: ListReviewableHITsResponse) => any;
+}
+export declare enum ReviewPolicyLevel {
+    Assignment = "Assignment",
+    HIT = "HIT"
+}
+export interface ListReviewPolicyResultsForHITRequest {
+    
+    HITId: string | undefined;
+    
+    PolicyLevels?: (ReviewPolicyLevel | string)[];
+    
+    RetrieveActions?: boolean;
+    
+    RetrieveResults?: boolean;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListReviewPolicyResultsForHITRequest {
+    
+    const filterSensitiveLog: (obj: ListReviewPolicyResultsForHITRequest) => any;
+}
+export declare enum ReviewActionStatus {
+    Cancelled = "Cancelled",
+    Failed = "Failed",
+    Intended = "Intended",
+    Succeeded = "Succeeded"
+}
+
+export interface ReviewActionDetail {
+    
+    ActionId?: string;
+    
+    ActionName?: string;
+    
+    TargetId?: string;
+    
+    TargetType?: string;
+    
+    Status?: ReviewActionStatus | string;
+    
+    CompleteTime?: Date;
+    
+    Result?: string;
+    
+    ErrorCode?: string;
+}
+export declare namespace ReviewActionDetail {
+    
+    const filterSensitiveLog: (obj: ReviewActionDetail) => any;
+}
+
+export interface ReviewResultDetail {
+    
+    ActionId?: string;
+    
+    SubjectId?: string;
+    
+    SubjectType?: string;
+    
+    QuestionId?: string;
+    
+    Key?: string;
+    
+    Value?: string;
+}
+export declare namespace ReviewResultDetail {
+    
+    const filterSensitiveLog: (obj: ReviewResultDetail) => any;
+}
+
+export interface ReviewReport {
+    
+    ReviewResults?: ReviewResultDetail[];
+    
+    ReviewActions?: ReviewActionDetail[];
+}
+export declare namespace ReviewReport {
+    
+    const filterSensitiveLog: (obj: ReviewReport) => any;
+}
+export interface ListReviewPolicyResultsForHITResponse {
+    
+    HITId?: string;
+    
+    AssignmentReviewPolicy?: ReviewPolicy;
+    
+    HITReviewPolicy?: ReviewPolicy;
+    
+    AssignmentReviewReport?: ReviewReport;
+    
+    HITReviewReport?: ReviewReport;
+    
+    NextToken?: string;
+}
+export declare namespace ListReviewPolicyResultsForHITResponse {
+    
+    const filterSensitiveLog: (obj: ListReviewPolicyResultsForHITResponse) => any;
+}
+export interface ListWorkerBlocksRequest {
+    
+    NextToken?: string;
+    MaxResults?: number;
+}
+export declare namespace ListWorkerBlocksRequest {
+    
+    const filterSensitiveLog: (obj: ListWorkerBlocksRequest) => any;
+}
+
+export interface WorkerBlock {
+    
+    WorkerId?: string;
+    
+    Reason?: string;
+}
+export declare namespace WorkerBlock {
+    
+    const filterSensitiveLog: (obj: WorkerBlock) => any;
+}
+export interface ListWorkerBlocksResponse {
+    
+    NextToken?: string;
+    
+    NumResults?: number;
+    
+    WorkerBlocks?: WorkerBlock[];
+}
+export declare namespace ListWorkerBlocksResponse {
+    
+    const filterSensitiveLog: (obj: ListWorkerBlocksResponse) => any;
+}
+export interface ListWorkersWithQualificationTypeRequest {
+    
+    QualificationTypeId: string | undefined;
+    
+    Status?: QualificationStatus | string;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListWorkersWithQualificationTypeRequest {
+    
+    const filterSensitiveLog: (obj: ListWorkersWithQualificationTypeRequest) => any;
+}
+export interface ListWorkersWithQualificationTypeResponse {
+    
+    NextToken?: string;
+    
+    NumResults?: number;
+    
+    Qualifications?: Qualification[];
+}
+export declare namespace ListWorkersWithQualificationTypeResponse {
+    
+    const filterSensitiveLog: (obj: ListWorkersWithQualificationTypeResponse) => any;
+}
+export interface NotifyWorkersRequest {
+    
+    Subject: string | undefined;
+    
+    MessageText: string | undefined;
+    
+    WorkerIds: string[] | undefined;
+}
+export declare namespace NotifyWorkersRequest {
+    
+    const filterSensitiveLog: (obj: NotifyWorkersRequest) => any;
+}
+export declare enum NotifyWorkersFailureCode {
+    HardFailure = "HardFailure",
+    SoftFailure = "SoftFailure"
+}
+
+export interface NotifyWorkersFailureStatus {
+    
+    NotifyWorkersFailureCode?: NotifyWorkersFailureCode | string;
+    
+    NotifyWorkersFailureMessage?: string;
+    
+    WorkerId?: string;
+}
+export declare namespace NotifyWorkersFailureStatus {
+    
+    const filterSensitiveLog: (obj: NotifyWorkersFailureStatus) => any;
+}
+export interface NotifyWorkersResponse {
+    
+    NotifyWorkersFailureStatuses?: NotifyWorkersFailureStatus[];
+}
+export declare namespace NotifyWorkersResponse {
+    
+    const filterSensitiveLog: (obj: NotifyWorkersResponse) => any;
+}
+export interface RejectAssignmentRequest {
+    
+    AssignmentId: string | undefined;
+    
+    RequesterFeedback: string | undefined;
+}
+export declare namespace RejectAssignmentRequest {
+    
+    const filterSensitiveLog: (obj: RejectAssignmentRequest) => any;
+}
+export interface RejectAssignmentResponse {
+}
+export declare namespace RejectAssignmentResponse {
+    
+    const filterSensitiveLog: (obj: RejectAssignmentResponse) => any;
+}
+export interface RejectQualificationRequestRequest {
+    
+    QualificationRequestId: string | undefined;
+    
+    Reason?: string;
+}
+export declare namespace RejectQualificationRequestRequest {
+    
+    const filterSensitiveLog: (obj: RejectQualificationRequestRequest) => any;
+}
+export interface RejectQualificationRequestResponse {
+}
+export declare namespace RejectQualificationRequestResponse {
+    
+    const filterSensitiveLog: (obj: RejectQualificationRequestResponse) => any;
+}
+export interface SendBonusRequest {
+    
+    WorkerId: string | undefined;
+    
+    BonusAmount: string | undefined;
+    
+    AssignmentId: string | undefined;
+    
+    Reason: string | undefined;
+    
+    UniqueRequestToken?: string;
+}
+export declare namespace SendBonusRequest {
+    
+    const filterSensitiveLog: (obj: SendBonusRequest) => any;
+}
+export interface SendBonusResponse {
+}
+export declare namespace SendBonusResponse {
+    
+    const filterSensitiveLog: (obj: SendBonusResponse) => any;
+}
+export declare enum NotificationTransport {
+    Email = "Email",
+    SNS = "SNS",
+    SQS = "SQS"
+}
+
+export interface NotificationSpecification {
+    
+    Destination: string | undefined;
+    
+    Transport: NotificationTransport | string | undefined;
+    
+    Version: string | undefined;
+    
+    EventTypes: (EventType | string)[] | undefined;
+}
+export declare namespace NotificationSpecification {
+    
+    const filterSensitiveLog: (obj: NotificationSpecification) => any;
+}
+export interface SendTestEventNotificationRequest {
+    
+    Notification: NotificationSpecification | undefined;
+    
+    TestEventType: EventType | string | undefined;
+}
+export declare namespace SendTestEventNotificationRequest {
+    
+    const filterSensitiveLog: (obj: SendTestEventNotificationRequest) => any;
+}
+export interface SendTestEventNotificationResponse {
+}
+export declare namespace SendTestEventNotificationResponse {
+    
+    const filterSensitiveLog: (obj: SendTestEventNotificationResponse) => any;
+}
+export interface UpdateExpirationForHITRequest {
+    
+    HITId: string | undefined;
+    
+    ExpireAt: Date | undefined;
+}
+export declare namespace UpdateExpirationForHITRequest {
+    
+    const filterSensitiveLog: (obj: UpdateExpirationForHITRequest) => any;
+}
+export interface UpdateExpirationForHITResponse {
+}
+export declare namespace UpdateExpirationForHITResponse {
+    
+    const filterSensitiveLog: (obj: UpdateExpirationForHITResponse) => any;
+}
+export interface UpdateHITReviewStatusRequest {
+    
+    HITId: string | undefined;
+    
+    Revert?: boolean;
+}
+export declare namespace UpdateHITReviewStatusRequest {
+    
+    const filterSensitiveLog: (obj: UpdateHITReviewStatusRequest) => any;
+}
+export interface UpdateHITReviewStatusResponse {
+}
+export declare namespace UpdateHITReviewStatusResponse {
+    
+    const filterSensitiveLog: (obj: UpdateHITReviewStatusResponse) => any;
+}
+export interface UpdateHITTypeOfHITRequest {
+    
+    HITId: string | undefined;
+    
+    HITTypeId: string | undefined;
+}
+export declare namespace UpdateHITTypeOfHITRequest {
+    
+    const filterSensitiveLog: (obj: UpdateHITTypeOfHITRequest) => any;
+}
+export interface UpdateHITTypeOfHITResponse {
+}
+export declare namespace UpdateHITTypeOfHITResponse {
+    
+    const filterSensitiveLog: (obj: UpdateHITTypeOfHITResponse) => any;
+}
+export interface UpdateNotificationSettingsRequest {
+    
+    HITTypeId: string | undefined;
+    
+    Notification?: NotificationSpecification;
+    
+    Active?: boolean;
+}
+export declare namespace UpdateNotificationSettingsRequest {
+    
+    const filterSensitiveLog: (obj: UpdateNotificationSettingsRequest) => any;
+}
+export interface UpdateNotificationSettingsResponse {
+}
+export declare namespace UpdateNotificationSettingsResponse {
+    
+    const filterSensitiveLog: (obj: UpdateNotificationSettingsResponse) => any;
+}
+export interface UpdateQualificationTypeRequest {
+    
+    QualificationTypeId: string | undefined;
+    
+    Description?: string;
+    
+    QualificationTypeStatus?: QualificationTypeStatus | string;
+    
+    Test?: string;
+    
+    AnswerKey?: string;
+    
+    TestDurationInSeconds?: number;
+    
+    RetryDelayInSeconds?: number;
+    
+    AutoGranted?: boolean;
+    
+    AutoGrantedValue?: number;
+}
+export declare namespace UpdateQualificationTypeRequest {
+    
+    const filterSensitiveLog: (obj: UpdateQualificationTypeRequest) => any;
+}
+export interface UpdateQualificationTypeResponse {
+    
+    QualificationType?: QualificationType;
+}
+export declare namespace UpdateQualificationTypeResponse {
+    
+    const filterSensitiveLog: (obj: UpdateQualificationTypeResponse) => any;
+}