1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package mturk 4 5import ( 6 "bytes" 7 "context" 8 "encoding/json" 9 "fmt" 10 "github.com/aws/aws-sdk-go-v2/aws/protocol/restjson" 11 "github.com/aws/aws-sdk-go-v2/service/mturk/types" 12 smithy "github.com/aws/smithy-go" 13 smithyio "github.com/aws/smithy-go/io" 14 "github.com/aws/smithy-go/middleware" 15 "github.com/aws/smithy-go/ptr" 16 smithytime "github.com/aws/smithy-go/time" 17 smithyhttp "github.com/aws/smithy-go/transport/http" 18 "io" 19 "strings" 20) 21 22type awsAwsjson11_deserializeOpAcceptQualificationRequest struct { 23} 24 25func (*awsAwsjson11_deserializeOpAcceptQualificationRequest) ID() string { 26 return "OperationDeserializer" 27} 28 29func (m *awsAwsjson11_deserializeOpAcceptQualificationRequest) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 30 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 31) { 32 out, metadata, err = next.HandleDeserialize(ctx, in) 33 if err != nil { 34 return out, metadata, err 35 } 36 37 response, ok := out.RawResponse.(*smithyhttp.Response) 38 if !ok { 39 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 40 } 41 42 if response.StatusCode < 200 || response.StatusCode >= 300 { 43 return out, metadata, awsAwsjson11_deserializeOpErrorAcceptQualificationRequest(response, &metadata) 44 } 45 output := &AcceptQualificationRequestOutput{} 46 out.Result = output 47 48 var buff [1024]byte 49 ringBuffer := smithyio.NewRingBuffer(buff[:]) 50 51 body := io.TeeReader(response.Body, ringBuffer) 52 decoder := json.NewDecoder(body) 53 decoder.UseNumber() 54 var shape interface{} 55 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 56 var snapshot bytes.Buffer 57 io.Copy(&snapshot, ringBuffer) 58 err = &smithy.DeserializationError{ 59 Err: fmt.Errorf("failed to decode response body, %w", err), 60 Snapshot: snapshot.Bytes(), 61 } 62 return out, metadata, err 63 } 64 65 err = awsAwsjson11_deserializeOpDocumentAcceptQualificationRequestOutput(&output, shape) 66 if err != nil { 67 var snapshot bytes.Buffer 68 io.Copy(&snapshot, ringBuffer) 69 err = &smithy.DeserializationError{ 70 Err: fmt.Errorf("failed to decode response body, %w", err), 71 Snapshot: snapshot.Bytes(), 72 } 73 return out, metadata, err 74 } 75 76 return out, metadata, err 77} 78 79func awsAwsjson11_deserializeOpErrorAcceptQualificationRequest(response *smithyhttp.Response, metadata *middleware.Metadata) error { 80 var errorBuffer bytes.Buffer 81 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 82 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 83 } 84 errorBody := bytes.NewReader(errorBuffer.Bytes()) 85 86 errorCode := "UnknownError" 87 errorMessage := errorCode 88 89 code := response.Header.Get("X-Amzn-ErrorType") 90 if len(code) != 0 { 91 errorCode = restjson.SanitizeErrorCode(code) 92 } 93 94 var buff [1024]byte 95 ringBuffer := smithyio.NewRingBuffer(buff[:]) 96 97 body := io.TeeReader(errorBody, ringBuffer) 98 decoder := json.NewDecoder(body) 99 decoder.UseNumber() 100 code, message, err := restjson.GetErrorInfo(decoder) 101 if err != nil { 102 var snapshot bytes.Buffer 103 io.Copy(&snapshot, ringBuffer) 104 err = &smithy.DeserializationError{ 105 Err: fmt.Errorf("failed to decode response body, %w", err), 106 Snapshot: snapshot.Bytes(), 107 } 108 return err 109 } 110 111 errorBody.Seek(0, io.SeekStart) 112 if len(code) != 0 { 113 errorCode = restjson.SanitizeErrorCode(code) 114 } 115 if len(message) != 0 { 116 errorMessage = message 117 } 118 119 switch { 120 case strings.EqualFold("RequestError", errorCode): 121 return awsAwsjson11_deserializeErrorRequestError(response, errorBody) 122 123 case strings.EqualFold("ServiceFault", errorCode): 124 return awsAwsjson11_deserializeErrorServiceFault(response, errorBody) 125 126 default: 127 genericError := &smithy.GenericAPIError{ 128 Code: errorCode, 129 Message: errorMessage, 130 } 131 return genericError 132 133 } 134} 135 136type awsAwsjson11_deserializeOpApproveAssignment struct { 137} 138 139func (*awsAwsjson11_deserializeOpApproveAssignment) ID() string { 140 return "OperationDeserializer" 141} 142 143func (m *awsAwsjson11_deserializeOpApproveAssignment) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 144 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 145) { 146 out, metadata, err = next.HandleDeserialize(ctx, in) 147 if err != nil { 148 return out, metadata, err 149 } 150 151 response, ok := out.RawResponse.(*smithyhttp.Response) 152 if !ok { 153 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 154 } 155 156 if response.StatusCode < 200 || response.StatusCode >= 300 { 157 return out, metadata, awsAwsjson11_deserializeOpErrorApproveAssignment(response, &metadata) 158 } 159 output := &ApproveAssignmentOutput{} 160 out.Result = output 161 162 var buff [1024]byte 163 ringBuffer := smithyio.NewRingBuffer(buff[:]) 164 165 body := io.TeeReader(response.Body, ringBuffer) 166 decoder := json.NewDecoder(body) 167 decoder.UseNumber() 168 var shape interface{} 169 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 170 var snapshot bytes.Buffer 171 io.Copy(&snapshot, ringBuffer) 172 err = &smithy.DeserializationError{ 173 Err: fmt.Errorf("failed to decode response body, %w", err), 174 Snapshot: snapshot.Bytes(), 175 } 176 return out, metadata, err 177 } 178 179 err = awsAwsjson11_deserializeOpDocumentApproveAssignmentOutput(&output, shape) 180 if err != nil { 181 var snapshot bytes.Buffer 182 io.Copy(&snapshot, ringBuffer) 183 err = &smithy.DeserializationError{ 184 Err: fmt.Errorf("failed to decode response body, %w", err), 185 Snapshot: snapshot.Bytes(), 186 } 187 return out, metadata, err 188 } 189 190 return out, metadata, err 191} 192 193func awsAwsjson11_deserializeOpErrorApproveAssignment(response *smithyhttp.Response, metadata *middleware.Metadata) error { 194 var errorBuffer bytes.Buffer 195 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 196 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 197 } 198 errorBody := bytes.NewReader(errorBuffer.Bytes()) 199 200 errorCode := "UnknownError" 201 errorMessage := errorCode 202 203 code := response.Header.Get("X-Amzn-ErrorType") 204 if len(code) != 0 { 205 errorCode = restjson.SanitizeErrorCode(code) 206 } 207 208 var buff [1024]byte 209 ringBuffer := smithyio.NewRingBuffer(buff[:]) 210 211 body := io.TeeReader(errorBody, ringBuffer) 212 decoder := json.NewDecoder(body) 213 decoder.UseNumber() 214 code, message, err := restjson.GetErrorInfo(decoder) 215 if err != nil { 216 var snapshot bytes.Buffer 217 io.Copy(&snapshot, ringBuffer) 218 err = &smithy.DeserializationError{ 219 Err: fmt.Errorf("failed to decode response body, %w", err), 220 Snapshot: snapshot.Bytes(), 221 } 222 return err 223 } 224 225 errorBody.Seek(0, io.SeekStart) 226 if len(code) != 0 { 227 errorCode = restjson.SanitizeErrorCode(code) 228 } 229 if len(message) != 0 { 230 errorMessage = message 231 } 232 233 switch { 234 case strings.EqualFold("RequestError", errorCode): 235 return awsAwsjson11_deserializeErrorRequestError(response, errorBody) 236 237 case strings.EqualFold("ServiceFault", errorCode): 238 return awsAwsjson11_deserializeErrorServiceFault(response, errorBody) 239 240 default: 241 genericError := &smithy.GenericAPIError{ 242 Code: errorCode, 243 Message: errorMessage, 244 } 245 return genericError 246 247 } 248} 249 250type awsAwsjson11_deserializeOpAssociateQualificationWithWorker struct { 251} 252 253func (*awsAwsjson11_deserializeOpAssociateQualificationWithWorker) ID() string { 254 return "OperationDeserializer" 255} 256 257func (m *awsAwsjson11_deserializeOpAssociateQualificationWithWorker) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 258 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 259) { 260 out, metadata, err = next.HandleDeserialize(ctx, in) 261 if err != nil { 262 return out, metadata, err 263 } 264 265 response, ok := out.RawResponse.(*smithyhttp.Response) 266 if !ok { 267 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 268 } 269 270 if response.StatusCode < 200 || response.StatusCode >= 300 { 271 return out, metadata, awsAwsjson11_deserializeOpErrorAssociateQualificationWithWorker(response, &metadata) 272 } 273 output := &AssociateQualificationWithWorkerOutput{} 274 out.Result = output 275 276 var buff [1024]byte 277 ringBuffer := smithyio.NewRingBuffer(buff[:]) 278 279 body := io.TeeReader(response.Body, ringBuffer) 280 decoder := json.NewDecoder(body) 281 decoder.UseNumber() 282 var shape interface{} 283 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 284 var snapshot bytes.Buffer 285 io.Copy(&snapshot, ringBuffer) 286 err = &smithy.DeserializationError{ 287 Err: fmt.Errorf("failed to decode response body, %w", err), 288 Snapshot: snapshot.Bytes(), 289 } 290 return out, metadata, err 291 } 292 293 err = awsAwsjson11_deserializeOpDocumentAssociateQualificationWithWorkerOutput(&output, shape) 294 if err != nil { 295 var snapshot bytes.Buffer 296 io.Copy(&snapshot, ringBuffer) 297 err = &smithy.DeserializationError{ 298 Err: fmt.Errorf("failed to decode response body, %w", err), 299 Snapshot: snapshot.Bytes(), 300 } 301 return out, metadata, err 302 } 303 304 return out, metadata, err 305} 306 307func awsAwsjson11_deserializeOpErrorAssociateQualificationWithWorker(response *smithyhttp.Response, metadata *middleware.Metadata) error { 308 var errorBuffer bytes.Buffer 309 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 310 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 311 } 312 errorBody := bytes.NewReader(errorBuffer.Bytes()) 313 314 errorCode := "UnknownError" 315 errorMessage := errorCode 316 317 code := response.Header.Get("X-Amzn-ErrorType") 318 if len(code) != 0 { 319 errorCode = restjson.SanitizeErrorCode(code) 320 } 321 322 var buff [1024]byte 323 ringBuffer := smithyio.NewRingBuffer(buff[:]) 324 325 body := io.TeeReader(errorBody, ringBuffer) 326 decoder := json.NewDecoder(body) 327 decoder.UseNumber() 328 code, message, err := restjson.GetErrorInfo(decoder) 329 if err != nil { 330 var snapshot bytes.Buffer 331 io.Copy(&snapshot, ringBuffer) 332 err = &smithy.DeserializationError{ 333 Err: fmt.Errorf("failed to decode response body, %w", err), 334 Snapshot: snapshot.Bytes(), 335 } 336 return err 337 } 338 339 errorBody.Seek(0, io.SeekStart) 340 if len(code) != 0 { 341 errorCode = restjson.SanitizeErrorCode(code) 342 } 343 if len(message) != 0 { 344 errorMessage = message 345 } 346 347 switch { 348 case strings.EqualFold("RequestError", errorCode): 349 return awsAwsjson11_deserializeErrorRequestError(response, errorBody) 350 351 case strings.EqualFold("ServiceFault", errorCode): 352 return awsAwsjson11_deserializeErrorServiceFault(response, errorBody) 353 354 default: 355 genericError := &smithy.GenericAPIError{ 356 Code: errorCode, 357 Message: errorMessage, 358 } 359 return genericError 360 361 } 362} 363 364type awsAwsjson11_deserializeOpCreateAdditionalAssignmentsForHIT struct { 365} 366 367func (*awsAwsjson11_deserializeOpCreateAdditionalAssignmentsForHIT) ID() string { 368 return "OperationDeserializer" 369} 370 371func (m *awsAwsjson11_deserializeOpCreateAdditionalAssignmentsForHIT) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 372 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 373) { 374 out, metadata, err = next.HandleDeserialize(ctx, in) 375 if err != nil { 376 return out, metadata, err 377 } 378 379 response, ok := out.RawResponse.(*smithyhttp.Response) 380 if !ok { 381 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 382 } 383 384 if response.StatusCode < 200 || response.StatusCode >= 300 { 385 return out, metadata, awsAwsjson11_deserializeOpErrorCreateAdditionalAssignmentsForHIT(response, &metadata) 386 } 387 output := &CreateAdditionalAssignmentsForHITOutput{} 388 out.Result = output 389 390 var buff [1024]byte 391 ringBuffer := smithyio.NewRingBuffer(buff[:]) 392 393 body := io.TeeReader(response.Body, ringBuffer) 394 decoder := json.NewDecoder(body) 395 decoder.UseNumber() 396 var shape interface{} 397 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 398 var snapshot bytes.Buffer 399 io.Copy(&snapshot, ringBuffer) 400 err = &smithy.DeserializationError{ 401 Err: fmt.Errorf("failed to decode response body, %w", err), 402 Snapshot: snapshot.Bytes(), 403 } 404 return out, metadata, err 405 } 406 407 err = awsAwsjson11_deserializeOpDocumentCreateAdditionalAssignmentsForHITOutput(&output, shape) 408 if err != nil { 409 var snapshot bytes.Buffer 410 io.Copy(&snapshot, ringBuffer) 411 err = &smithy.DeserializationError{ 412 Err: fmt.Errorf("failed to decode response body, %w", err), 413 Snapshot: snapshot.Bytes(), 414 } 415 return out, metadata, err 416 } 417 418 return out, metadata, err 419} 420 421func awsAwsjson11_deserializeOpErrorCreateAdditionalAssignmentsForHIT(response *smithyhttp.Response, metadata *middleware.Metadata) error { 422 var errorBuffer bytes.Buffer 423 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 424 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 425 } 426 errorBody := bytes.NewReader(errorBuffer.Bytes()) 427 428 errorCode := "UnknownError" 429 errorMessage := errorCode 430 431 code := response.Header.Get("X-Amzn-ErrorType") 432 if len(code) != 0 { 433 errorCode = restjson.SanitizeErrorCode(code) 434 } 435 436 var buff [1024]byte 437 ringBuffer := smithyio.NewRingBuffer(buff[:]) 438 439 body := io.TeeReader(errorBody, ringBuffer) 440 decoder := json.NewDecoder(body) 441 decoder.UseNumber() 442 code, message, err := restjson.GetErrorInfo(decoder) 443 if err != nil { 444 var snapshot bytes.Buffer 445 io.Copy(&snapshot, ringBuffer) 446 err = &smithy.DeserializationError{ 447 Err: fmt.Errorf("failed to decode response body, %w", err), 448 Snapshot: snapshot.Bytes(), 449 } 450 return err 451 } 452 453 errorBody.Seek(0, io.SeekStart) 454 if len(code) != 0 { 455 errorCode = restjson.SanitizeErrorCode(code) 456 } 457 if len(message) != 0 { 458 errorMessage = message 459 } 460 461 switch { 462 case strings.EqualFold("RequestError", errorCode): 463 return awsAwsjson11_deserializeErrorRequestError(response, errorBody) 464 465 case strings.EqualFold("ServiceFault", errorCode): 466 return awsAwsjson11_deserializeErrorServiceFault(response, errorBody) 467 468 default: 469 genericError := &smithy.GenericAPIError{ 470 Code: errorCode, 471 Message: errorMessage, 472 } 473 return genericError 474 475 } 476} 477 478type awsAwsjson11_deserializeOpCreateHIT struct { 479} 480 481func (*awsAwsjson11_deserializeOpCreateHIT) ID() string { 482 return "OperationDeserializer" 483} 484 485func (m *awsAwsjson11_deserializeOpCreateHIT) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 486 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 487) { 488 out, metadata, err = next.HandleDeserialize(ctx, in) 489 if err != nil { 490 return out, metadata, err 491 } 492 493 response, ok := out.RawResponse.(*smithyhttp.Response) 494 if !ok { 495 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 496 } 497 498 if response.StatusCode < 200 || response.StatusCode >= 300 { 499 return out, metadata, awsAwsjson11_deserializeOpErrorCreateHIT(response, &metadata) 500 } 501 output := &CreateHITOutput{} 502 out.Result = output 503 504 var buff [1024]byte 505 ringBuffer := smithyio.NewRingBuffer(buff[:]) 506 507 body := io.TeeReader(response.Body, ringBuffer) 508 decoder := json.NewDecoder(body) 509 decoder.UseNumber() 510 var shape interface{} 511 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 512 var snapshot bytes.Buffer 513 io.Copy(&snapshot, ringBuffer) 514 err = &smithy.DeserializationError{ 515 Err: fmt.Errorf("failed to decode response body, %w", err), 516 Snapshot: snapshot.Bytes(), 517 } 518 return out, metadata, err 519 } 520 521 err = awsAwsjson11_deserializeOpDocumentCreateHITOutput(&output, shape) 522 if err != nil { 523 var snapshot bytes.Buffer 524 io.Copy(&snapshot, ringBuffer) 525 err = &smithy.DeserializationError{ 526 Err: fmt.Errorf("failed to decode response body, %w", err), 527 Snapshot: snapshot.Bytes(), 528 } 529 return out, metadata, err 530 } 531 532 return out, metadata, err 533} 534 535func awsAwsjson11_deserializeOpErrorCreateHIT(response *smithyhttp.Response, metadata *middleware.Metadata) error { 536 var errorBuffer bytes.Buffer 537 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 538 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 539 } 540 errorBody := bytes.NewReader(errorBuffer.Bytes()) 541 542 errorCode := "UnknownError" 543 errorMessage := errorCode 544 545 code := response.Header.Get("X-Amzn-ErrorType") 546 if len(code) != 0 { 547 errorCode = restjson.SanitizeErrorCode(code) 548 } 549 550 var buff [1024]byte 551 ringBuffer := smithyio.NewRingBuffer(buff[:]) 552 553 body := io.TeeReader(errorBody, ringBuffer) 554 decoder := json.NewDecoder(body) 555 decoder.UseNumber() 556 code, message, err := restjson.GetErrorInfo(decoder) 557 if err != nil { 558 var snapshot bytes.Buffer 559 io.Copy(&snapshot, ringBuffer) 560 err = &smithy.DeserializationError{ 561 Err: fmt.Errorf("failed to decode response body, %w", err), 562 Snapshot: snapshot.Bytes(), 563 } 564 return err 565 } 566 567 errorBody.Seek(0, io.SeekStart) 568 if len(code) != 0 { 569 errorCode = restjson.SanitizeErrorCode(code) 570 } 571 if len(message) != 0 { 572 errorMessage = message 573 } 574 575 switch { 576 case strings.EqualFold("RequestError", errorCode): 577 return awsAwsjson11_deserializeErrorRequestError(response, errorBody) 578 579 case strings.EqualFold("ServiceFault", errorCode): 580 return awsAwsjson11_deserializeErrorServiceFault(response, errorBody) 581 582 default: 583 genericError := &smithy.GenericAPIError{ 584 Code: errorCode, 585 Message: errorMessage, 586 } 587 return genericError 588 589 } 590} 591 592type awsAwsjson11_deserializeOpCreateHITType struct { 593} 594 595func (*awsAwsjson11_deserializeOpCreateHITType) ID() string { 596 return "OperationDeserializer" 597} 598 599func (m *awsAwsjson11_deserializeOpCreateHITType) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 600 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 601) { 602 out, metadata, err = next.HandleDeserialize(ctx, in) 603 if err != nil { 604 return out, metadata, err 605 } 606 607 response, ok := out.RawResponse.(*smithyhttp.Response) 608 if !ok { 609 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 610 } 611 612 if response.StatusCode < 200 || response.StatusCode >= 300 { 613 return out, metadata, awsAwsjson11_deserializeOpErrorCreateHITType(response, &metadata) 614 } 615 output := &CreateHITTypeOutput{} 616 out.Result = output 617 618 var buff [1024]byte 619 ringBuffer := smithyio.NewRingBuffer(buff[:]) 620 621 body := io.TeeReader(response.Body, ringBuffer) 622 decoder := json.NewDecoder(body) 623 decoder.UseNumber() 624 var shape interface{} 625 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 626 var snapshot bytes.Buffer 627 io.Copy(&snapshot, ringBuffer) 628 err = &smithy.DeserializationError{ 629 Err: fmt.Errorf("failed to decode response body, %w", err), 630 Snapshot: snapshot.Bytes(), 631 } 632 return out, metadata, err 633 } 634 635 err = awsAwsjson11_deserializeOpDocumentCreateHITTypeOutput(&output, shape) 636 if err != nil { 637 var snapshot bytes.Buffer 638 io.Copy(&snapshot, ringBuffer) 639 err = &smithy.DeserializationError{ 640 Err: fmt.Errorf("failed to decode response body, %w", err), 641 Snapshot: snapshot.Bytes(), 642 } 643 return out, metadata, err 644 } 645 646 return out, metadata, err 647} 648 649func awsAwsjson11_deserializeOpErrorCreateHITType(response *smithyhttp.Response, metadata *middleware.Metadata) error { 650 var errorBuffer bytes.Buffer 651 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 652 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 653 } 654 errorBody := bytes.NewReader(errorBuffer.Bytes()) 655 656 errorCode := "UnknownError" 657 errorMessage := errorCode 658 659 code := response.Header.Get("X-Amzn-ErrorType") 660 if len(code) != 0 { 661 errorCode = restjson.SanitizeErrorCode(code) 662 } 663 664 var buff [1024]byte 665 ringBuffer := smithyio.NewRingBuffer(buff[:]) 666 667 body := io.TeeReader(errorBody, ringBuffer) 668 decoder := json.NewDecoder(body) 669 decoder.UseNumber() 670 code, message, err := restjson.GetErrorInfo(decoder) 671 if err != nil { 672 var snapshot bytes.Buffer 673 io.Copy(&snapshot, ringBuffer) 674 err = &smithy.DeserializationError{ 675 Err: fmt.Errorf("failed to decode response body, %w", err), 676 Snapshot: snapshot.Bytes(), 677 } 678 return err 679 } 680 681 errorBody.Seek(0, io.SeekStart) 682 if len(code) != 0 { 683 errorCode = restjson.SanitizeErrorCode(code) 684 } 685 if len(message) != 0 { 686 errorMessage = message 687 } 688 689 switch { 690 case strings.EqualFold("RequestError", errorCode): 691 return awsAwsjson11_deserializeErrorRequestError(response, errorBody) 692 693 case strings.EqualFold("ServiceFault", errorCode): 694 return awsAwsjson11_deserializeErrorServiceFault(response, errorBody) 695 696 default: 697 genericError := &smithy.GenericAPIError{ 698 Code: errorCode, 699 Message: errorMessage, 700 } 701 return genericError 702 703 } 704} 705 706type awsAwsjson11_deserializeOpCreateHITWithHITType struct { 707} 708 709func (*awsAwsjson11_deserializeOpCreateHITWithHITType) ID() string { 710 return "OperationDeserializer" 711} 712 713func (m *awsAwsjson11_deserializeOpCreateHITWithHITType) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 714 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 715) { 716 out, metadata, err = next.HandleDeserialize(ctx, in) 717 if err != nil { 718 return out, metadata, err 719 } 720 721 response, ok := out.RawResponse.(*smithyhttp.Response) 722 if !ok { 723 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 724 } 725 726 if response.StatusCode < 200 || response.StatusCode >= 300 { 727 return out, metadata, awsAwsjson11_deserializeOpErrorCreateHITWithHITType(response, &metadata) 728 } 729 output := &CreateHITWithHITTypeOutput{} 730 out.Result = output 731 732 var buff [1024]byte 733 ringBuffer := smithyio.NewRingBuffer(buff[:]) 734 735 body := io.TeeReader(response.Body, ringBuffer) 736 decoder := json.NewDecoder(body) 737 decoder.UseNumber() 738 var shape interface{} 739 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 740 var snapshot bytes.Buffer 741 io.Copy(&snapshot, ringBuffer) 742 err = &smithy.DeserializationError{ 743 Err: fmt.Errorf("failed to decode response body, %w", err), 744 Snapshot: snapshot.Bytes(), 745 } 746 return out, metadata, err 747 } 748 749 err = awsAwsjson11_deserializeOpDocumentCreateHITWithHITTypeOutput(&output, shape) 750 if err != nil { 751 var snapshot bytes.Buffer 752 io.Copy(&snapshot, ringBuffer) 753 err = &smithy.DeserializationError{ 754 Err: fmt.Errorf("failed to decode response body, %w", err), 755 Snapshot: snapshot.Bytes(), 756 } 757 return out, metadata, err 758 } 759 760 return out, metadata, err 761} 762 763func awsAwsjson11_deserializeOpErrorCreateHITWithHITType(response *smithyhttp.Response, metadata *middleware.Metadata) error { 764 var errorBuffer bytes.Buffer 765 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 766 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 767 } 768 errorBody := bytes.NewReader(errorBuffer.Bytes()) 769 770 errorCode := "UnknownError" 771 errorMessage := errorCode 772 773 code := response.Header.Get("X-Amzn-ErrorType") 774 if len(code) != 0 { 775 errorCode = restjson.SanitizeErrorCode(code) 776 } 777 778 var buff [1024]byte 779 ringBuffer := smithyio.NewRingBuffer(buff[:]) 780 781 body := io.TeeReader(errorBody, ringBuffer) 782 decoder := json.NewDecoder(body) 783 decoder.UseNumber() 784 code, message, err := restjson.GetErrorInfo(decoder) 785 if err != nil { 786 var snapshot bytes.Buffer 787 io.Copy(&snapshot, ringBuffer) 788 err = &smithy.DeserializationError{ 789 Err: fmt.Errorf("failed to decode response body, %w", err), 790 Snapshot: snapshot.Bytes(), 791 } 792 return err 793 } 794 795 errorBody.Seek(0, io.SeekStart) 796 if len(code) != 0 { 797 errorCode = restjson.SanitizeErrorCode(code) 798 } 799 if len(message) != 0 { 800 errorMessage = message 801 } 802 803 switch { 804 case strings.EqualFold("RequestError", errorCode): 805 return awsAwsjson11_deserializeErrorRequestError(response, errorBody) 806 807 case strings.EqualFold("ServiceFault", errorCode): 808 return awsAwsjson11_deserializeErrorServiceFault(response, errorBody) 809 810 default: 811 genericError := &smithy.GenericAPIError{ 812 Code: errorCode, 813 Message: errorMessage, 814 } 815 return genericError 816 817 } 818} 819 820type awsAwsjson11_deserializeOpCreateQualificationType struct { 821} 822 823func (*awsAwsjson11_deserializeOpCreateQualificationType) ID() string { 824 return "OperationDeserializer" 825} 826 827func (m *awsAwsjson11_deserializeOpCreateQualificationType) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 828 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 829) { 830 out, metadata, err = next.HandleDeserialize(ctx, in) 831 if err != nil { 832 return out, metadata, err 833 } 834 835 response, ok := out.RawResponse.(*smithyhttp.Response) 836 if !ok { 837 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 838 } 839 840 if response.StatusCode < 200 || response.StatusCode >= 300 { 841 return out, metadata, awsAwsjson11_deserializeOpErrorCreateQualificationType(response, &metadata) 842 } 843 output := &CreateQualificationTypeOutput{} 844 out.Result = output 845 846 var buff [1024]byte 847 ringBuffer := smithyio.NewRingBuffer(buff[:]) 848 849 body := io.TeeReader(response.Body, ringBuffer) 850 decoder := json.NewDecoder(body) 851 decoder.UseNumber() 852 var shape interface{} 853 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 854 var snapshot bytes.Buffer 855 io.Copy(&snapshot, ringBuffer) 856 err = &smithy.DeserializationError{ 857 Err: fmt.Errorf("failed to decode response body, %w", err), 858 Snapshot: snapshot.Bytes(), 859 } 860 return out, metadata, err 861 } 862 863 err = awsAwsjson11_deserializeOpDocumentCreateQualificationTypeOutput(&output, shape) 864 if err != nil { 865 var snapshot bytes.Buffer 866 io.Copy(&snapshot, ringBuffer) 867 err = &smithy.DeserializationError{ 868 Err: fmt.Errorf("failed to decode response body, %w", err), 869 Snapshot: snapshot.Bytes(), 870 } 871 return out, metadata, err 872 } 873 874 return out, metadata, err 875} 876 877func awsAwsjson11_deserializeOpErrorCreateQualificationType(response *smithyhttp.Response, metadata *middleware.Metadata) error { 878 var errorBuffer bytes.Buffer 879 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 880 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 881 } 882 errorBody := bytes.NewReader(errorBuffer.Bytes()) 883 884 errorCode := "UnknownError" 885 errorMessage := errorCode 886 887 code := response.Header.Get("X-Amzn-ErrorType") 888 if len(code) != 0 { 889 errorCode = restjson.SanitizeErrorCode(code) 890 } 891 892 var buff [1024]byte 893 ringBuffer := smithyio.NewRingBuffer(buff[:]) 894 895 body := io.TeeReader(errorBody, ringBuffer) 896 decoder := json.NewDecoder(body) 897 decoder.UseNumber() 898 code, message, err := restjson.GetErrorInfo(decoder) 899 if err != nil { 900 var snapshot bytes.Buffer 901 io.Copy(&snapshot, ringBuffer) 902 err = &smithy.DeserializationError{ 903 Err: fmt.Errorf("failed to decode response body, %w", err), 904 Snapshot: snapshot.Bytes(), 905 } 906 return err 907 } 908 909 errorBody.Seek(0, io.SeekStart) 910 if len(code) != 0 { 911 errorCode = restjson.SanitizeErrorCode(code) 912 } 913 if len(message) != 0 { 914 errorMessage = message 915 } 916 917 switch { 918 case strings.EqualFold("RequestError", errorCode): 919 return awsAwsjson11_deserializeErrorRequestError(response, errorBody) 920 921 case strings.EqualFold("ServiceFault", errorCode): 922 return awsAwsjson11_deserializeErrorServiceFault(response, errorBody) 923 924 default: 925 genericError := &smithy.GenericAPIError{ 926 Code: errorCode, 927 Message: errorMessage, 928 } 929 return genericError 930 931 } 932} 933 934type awsAwsjson11_deserializeOpCreateWorkerBlock struct { 935} 936 937func (*awsAwsjson11_deserializeOpCreateWorkerBlock) ID() string { 938 return "OperationDeserializer" 939} 940 941func (m *awsAwsjson11_deserializeOpCreateWorkerBlock) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 942 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 943) { 944 out, metadata, err = next.HandleDeserialize(ctx, in) 945 if err != nil { 946 return out, metadata, err 947 } 948 949 response, ok := out.RawResponse.(*smithyhttp.Response) 950 if !ok { 951 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 952 } 953 954 if response.StatusCode < 200 || response.StatusCode >= 300 { 955 return out, metadata, awsAwsjson11_deserializeOpErrorCreateWorkerBlock(response, &metadata) 956 } 957 output := &CreateWorkerBlockOutput{} 958 out.Result = output 959 960 var buff [1024]byte 961 ringBuffer := smithyio.NewRingBuffer(buff[:]) 962 963 body := io.TeeReader(response.Body, ringBuffer) 964 decoder := json.NewDecoder(body) 965 decoder.UseNumber() 966 var shape interface{} 967 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 968 var snapshot bytes.Buffer 969 io.Copy(&snapshot, ringBuffer) 970 err = &smithy.DeserializationError{ 971 Err: fmt.Errorf("failed to decode response body, %w", err), 972 Snapshot: snapshot.Bytes(), 973 } 974 return out, metadata, err 975 } 976 977 err = awsAwsjson11_deserializeOpDocumentCreateWorkerBlockOutput(&output, shape) 978 if err != nil { 979 var snapshot bytes.Buffer 980 io.Copy(&snapshot, ringBuffer) 981 err = &smithy.DeserializationError{ 982 Err: fmt.Errorf("failed to decode response body, %w", err), 983 Snapshot: snapshot.Bytes(), 984 } 985 return out, metadata, err 986 } 987 988 return out, metadata, err 989} 990 991func awsAwsjson11_deserializeOpErrorCreateWorkerBlock(response *smithyhttp.Response, metadata *middleware.Metadata) error { 992 var errorBuffer bytes.Buffer 993 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 994 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 995 } 996 errorBody := bytes.NewReader(errorBuffer.Bytes()) 997 998 errorCode := "UnknownError" 999 errorMessage := errorCode 1000 1001 code := response.Header.Get("X-Amzn-ErrorType") 1002 if len(code) != 0 { 1003 errorCode = restjson.SanitizeErrorCode(code) 1004 } 1005 1006 var buff [1024]byte 1007 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1008 1009 body := io.TeeReader(errorBody, ringBuffer) 1010 decoder := json.NewDecoder(body) 1011 decoder.UseNumber() 1012 code, message, err := restjson.GetErrorInfo(decoder) 1013 if err != nil { 1014 var snapshot bytes.Buffer 1015 io.Copy(&snapshot, ringBuffer) 1016 err = &smithy.DeserializationError{ 1017 Err: fmt.Errorf("failed to decode response body, %w", err), 1018 Snapshot: snapshot.Bytes(), 1019 } 1020 return err 1021 } 1022 1023 errorBody.Seek(0, io.SeekStart) 1024 if len(code) != 0 { 1025 errorCode = restjson.SanitizeErrorCode(code) 1026 } 1027 if len(message) != 0 { 1028 errorMessage = message 1029 } 1030 1031 switch { 1032 case strings.EqualFold("RequestError", errorCode): 1033 return awsAwsjson11_deserializeErrorRequestError(response, errorBody) 1034 1035 case strings.EqualFold("ServiceFault", errorCode): 1036 return awsAwsjson11_deserializeErrorServiceFault(response, errorBody) 1037 1038 default: 1039 genericError := &smithy.GenericAPIError{ 1040 Code: errorCode, 1041 Message: errorMessage, 1042 } 1043 return genericError 1044 1045 } 1046} 1047 1048type awsAwsjson11_deserializeOpDeleteHIT struct { 1049} 1050 1051func (*awsAwsjson11_deserializeOpDeleteHIT) ID() string { 1052 return "OperationDeserializer" 1053} 1054 1055func (m *awsAwsjson11_deserializeOpDeleteHIT) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1056 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1057) { 1058 out, metadata, err = next.HandleDeserialize(ctx, in) 1059 if err != nil { 1060 return out, metadata, err 1061 } 1062 1063 response, ok := out.RawResponse.(*smithyhttp.Response) 1064 if !ok { 1065 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1066 } 1067 1068 if response.StatusCode < 200 || response.StatusCode >= 300 { 1069 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteHIT(response, &metadata) 1070 } 1071 output := &DeleteHITOutput{} 1072 out.Result = output 1073 1074 var buff [1024]byte 1075 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1076 1077 body := io.TeeReader(response.Body, ringBuffer) 1078 decoder := json.NewDecoder(body) 1079 decoder.UseNumber() 1080 var shape interface{} 1081 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1082 var snapshot bytes.Buffer 1083 io.Copy(&snapshot, ringBuffer) 1084 err = &smithy.DeserializationError{ 1085 Err: fmt.Errorf("failed to decode response body, %w", err), 1086 Snapshot: snapshot.Bytes(), 1087 } 1088 return out, metadata, err 1089 } 1090 1091 err = awsAwsjson11_deserializeOpDocumentDeleteHITOutput(&output, shape) 1092 if err != nil { 1093 var snapshot bytes.Buffer 1094 io.Copy(&snapshot, ringBuffer) 1095 err = &smithy.DeserializationError{ 1096 Err: fmt.Errorf("failed to decode response body, %w", err), 1097 Snapshot: snapshot.Bytes(), 1098 } 1099 return out, metadata, err 1100 } 1101 1102 return out, metadata, err 1103} 1104 1105func awsAwsjson11_deserializeOpErrorDeleteHIT(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1106 var errorBuffer bytes.Buffer 1107 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1108 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1109 } 1110 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1111 1112 errorCode := "UnknownError" 1113 errorMessage := errorCode 1114 1115 code := response.Header.Get("X-Amzn-ErrorType") 1116 if len(code) != 0 { 1117 errorCode = restjson.SanitizeErrorCode(code) 1118 } 1119 1120 var buff [1024]byte 1121 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1122 1123 body := io.TeeReader(errorBody, ringBuffer) 1124 decoder := json.NewDecoder(body) 1125 decoder.UseNumber() 1126 code, message, err := restjson.GetErrorInfo(decoder) 1127 if err != nil { 1128 var snapshot bytes.Buffer 1129 io.Copy(&snapshot, ringBuffer) 1130 err = &smithy.DeserializationError{ 1131 Err: fmt.Errorf("failed to decode response body, %w", err), 1132 Snapshot: snapshot.Bytes(), 1133 } 1134 return err 1135 } 1136 1137 errorBody.Seek(0, io.SeekStart) 1138 if len(code) != 0 { 1139 errorCode = restjson.SanitizeErrorCode(code) 1140 } 1141 if len(message) != 0 { 1142 errorMessage = message 1143 } 1144 1145 switch { 1146 case strings.EqualFold("RequestError", errorCode): 1147 return awsAwsjson11_deserializeErrorRequestError(response, errorBody) 1148 1149 case strings.EqualFold("ServiceFault", errorCode): 1150 return awsAwsjson11_deserializeErrorServiceFault(response, errorBody) 1151 1152 default: 1153 genericError := &smithy.GenericAPIError{ 1154 Code: errorCode, 1155 Message: errorMessage, 1156 } 1157 return genericError 1158 1159 } 1160} 1161 1162type awsAwsjson11_deserializeOpDeleteQualificationType struct { 1163} 1164 1165func (*awsAwsjson11_deserializeOpDeleteQualificationType) ID() string { 1166 return "OperationDeserializer" 1167} 1168 1169func (m *awsAwsjson11_deserializeOpDeleteQualificationType) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1170 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1171) { 1172 out, metadata, err = next.HandleDeserialize(ctx, in) 1173 if err != nil { 1174 return out, metadata, err 1175 } 1176 1177 response, ok := out.RawResponse.(*smithyhttp.Response) 1178 if !ok { 1179 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1180 } 1181 1182 if response.StatusCode < 200 || response.StatusCode >= 300 { 1183 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteQualificationType(response, &metadata) 1184 } 1185 output := &DeleteQualificationTypeOutput{} 1186 out.Result = output 1187 1188 var buff [1024]byte 1189 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1190 1191 body := io.TeeReader(response.Body, ringBuffer) 1192 decoder := json.NewDecoder(body) 1193 decoder.UseNumber() 1194 var shape interface{} 1195 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1196 var snapshot bytes.Buffer 1197 io.Copy(&snapshot, ringBuffer) 1198 err = &smithy.DeserializationError{ 1199 Err: fmt.Errorf("failed to decode response body, %w", err), 1200 Snapshot: snapshot.Bytes(), 1201 } 1202 return out, metadata, err 1203 } 1204 1205 err = awsAwsjson11_deserializeOpDocumentDeleteQualificationTypeOutput(&output, shape) 1206 if err != nil { 1207 var snapshot bytes.Buffer 1208 io.Copy(&snapshot, ringBuffer) 1209 err = &smithy.DeserializationError{ 1210 Err: fmt.Errorf("failed to decode response body, %w", err), 1211 Snapshot: snapshot.Bytes(), 1212 } 1213 return out, metadata, err 1214 } 1215 1216 return out, metadata, err 1217} 1218 1219func awsAwsjson11_deserializeOpErrorDeleteQualificationType(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1220 var errorBuffer bytes.Buffer 1221 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1222 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1223 } 1224 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1225 1226 errorCode := "UnknownError" 1227 errorMessage := errorCode 1228 1229 code := response.Header.Get("X-Amzn-ErrorType") 1230 if len(code) != 0 { 1231 errorCode = restjson.SanitizeErrorCode(code) 1232 } 1233 1234 var buff [1024]byte 1235 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1236 1237 body := io.TeeReader(errorBody, ringBuffer) 1238 decoder := json.NewDecoder(body) 1239 decoder.UseNumber() 1240 code, message, err := restjson.GetErrorInfo(decoder) 1241 if err != nil { 1242 var snapshot bytes.Buffer 1243 io.Copy(&snapshot, ringBuffer) 1244 err = &smithy.DeserializationError{ 1245 Err: fmt.Errorf("failed to decode response body, %w", err), 1246 Snapshot: snapshot.Bytes(), 1247 } 1248 return err 1249 } 1250 1251 errorBody.Seek(0, io.SeekStart) 1252 if len(code) != 0 { 1253 errorCode = restjson.SanitizeErrorCode(code) 1254 } 1255 if len(message) != 0 { 1256 errorMessage = message 1257 } 1258 1259 switch { 1260 case strings.EqualFold("RequestError", errorCode): 1261 return awsAwsjson11_deserializeErrorRequestError(response, errorBody) 1262 1263 case strings.EqualFold("ServiceFault", errorCode): 1264 return awsAwsjson11_deserializeErrorServiceFault(response, errorBody) 1265 1266 default: 1267 genericError := &smithy.GenericAPIError{ 1268 Code: errorCode, 1269 Message: errorMessage, 1270 } 1271 return genericError 1272 1273 } 1274} 1275 1276type awsAwsjson11_deserializeOpDeleteWorkerBlock struct { 1277} 1278 1279func (*awsAwsjson11_deserializeOpDeleteWorkerBlock) ID() string { 1280 return "OperationDeserializer" 1281} 1282 1283func (m *awsAwsjson11_deserializeOpDeleteWorkerBlock) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1284 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1285) { 1286 out, metadata, err = next.HandleDeserialize(ctx, in) 1287 if err != nil { 1288 return out, metadata, err 1289 } 1290 1291 response, ok := out.RawResponse.(*smithyhttp.Response) 1292 if !ok { 1293 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1294 } 1295 1296 if response.StatusCode < 200 || response.StatusCode >= 300 { 1297 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteWorkerBlock(response, &metadata) 1298 } 1299 output := &DeleteWorkerBlockOutput{} 1300 out.Result = output 1301 1302 var buff [1024]byte 1303 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1304 1305 body := io.TeeReader(response.Body, ringBuffer) 1306 decoder := json.NewDecoder(body) 1307 decoder.UseNumber() 1308 var shape interface{} 1309 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1310 var snapshot bytes.Buffer 1311 io.Copy(&snapshot, ringBuffer) 1312 err = &smithy.DeserializationError{ 1313 Err: fmt.Errorf("failed to decode response body, %w", err), 1314 Snapshot: snapshot.Bytes(), 1315 } 1316 return out, metadata, err 1317 } 1318 1319 err = awsAwsjson11_deserializeOpDocumentDeleteWorkerBlockOutput(&output, shape) 1320 if err != nil { 1321 var snapshot bytes.Buffer 1322 io.Copy(&snapshot, ringBuffer) 1323 err = &smithy.DeserializationError{ 1324 Err: fmt.Errorf("failed to decode response body, %w", err), 1325 Snapshot: snapshot.Bytes(), 1326 } 1327 return out, metadata, err 1328 } 1329 1330 return out, metadata, err 1331} 1332 1333func awsAwsjson11_deserializeOpErrorDeleteWorkerBlock(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1334 var errorBuffer bytes.Buffer 1335 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1336 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1337 } 1338 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1339 1340 errorCode := "UnknownError" 1341 errorMessage := errorCode 1342 1343 code := response.Header.Get("X-Amzn-ErrorType") 1344 if len(code) != 0 { 1345 errorCode = restjson.SanitizeErrorCode(code) 1346 } 1347 1348 var buff [1024]byte 1349 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1350 1351 body := io.TeeReader(errorBody, ringBuffer) 1352 decoder := json.NewDecoder(body) 1353 decoder.UseNumber() 1354 code, message, err := restjson.GetErrorInfo(decoder) 1355 if err != nil { 1356 var snapshot bytes.Buffer 1357 io.Copy(&snapshot, ringBuffer) 1358 err = &smithy.DeserializationError{ 1359 Err: fmt.Errorf("failed to decode response body, %w", err), 1360 Snapshot: snapshot.Bytes(), 1361 } 1362 return err 1363 } 1364 1365 errorBody.Seek(0, io.SeekStart) 1366 if len(code) != 0 { 1367 errorCode = restjson.SanitizeErrorCode(code) 1368 } 1369 if len(message) != 0 { 1370 errorMessage = message 1371 } 1372 1373 switch { 1374 case strings.EqualFold("RequestError", errorCode): 1375 return awsAwsjson11_deserializeErrorRequestError(response, errorBody) 1376 1377 case strings.EqualFold("ServiceFault", errorCode): 1378 return awsAwsjson11_deserializeErrorServiceFault(response, errorBody) 1379 1380 default: 1381 genericError := &smithy.GenericAPIError{ 1382 Code: errorCode, 1383 Message: errorMessage, 1384 } 1385 return genericError 1386 1387 } 1388} 1389 1390type awsAwsjson11_deserializeOpDisassociateQualificationFromWorker struct { 1391} 1392 1393func (*awsAwsjson11_deserializeOpDisassociateQualificationFromWorker) ID() string { 1394 return "OperationDeserializer" 1395} 1396 1397func (m *awsAwsjson11_deserializeOpDisassociateQualificationFromWorker) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1398 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1399) { 1400 out, metadata, err = next.HandleDeserialize(ctx, in) 1401 if err != nil { 1402 return out, metadata, err 1403 } 1404 1405 response, ok := out.RawResponse.(*smithyhttp.Response) 1406 if !ok { 1407 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1408 } 1409 1410 if response.StatusCode < 200 || response.StatusCode >= 300 { 1411 return out, metadata, awsAwsjson11_deserializeOpErrorDisassociateQualificationFromWorker(response, &metadata) 1412 } 1413 output := &DisassociateQualificationFromWorkerOutput{} 1414 out.Result = output 1415 1416 var buff [1024]byte 1417 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1418 1419 body := io.TeeReader(response.Body, ringBuffer) 1420 decoder := json.NewDecoder(body) 1421 decoder.UseNumber() 1422 var shape interface{} 1423 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1424 var snapshot bytes.Buffer 1425 io.Copy(&snapshot, ringBuffer) 1426 err = &smithy.DeserializationError{ 1427 Err: fmt.Errorf("failed to decode response body, %w", err), 1428 Snapshot: snapshot.Bytes(), 1429 } 1430 return out, metadata, err 1431 } 1432 1433 err = awsAwsjson11_deserializeOpDocumentDisassociateQualificationFromWorkerOutput(&output, shape) 1434 if err != nil { 1435 var snapshot bytes.Buffer 1436 io.Copy(&snapshot, ringBuffer) 1437 err = &smithy.DeserializationError{ 1438 Err: fmt.Errorf("failed to decode response body, %w", err), 1439 Snapshot: snapshot.Bytes(), 1440 } 1441 return out, metadata, err 1442 } 1443 1444 return out, metadata, err 1445} 1446 1447func awsAwsjson11_deserializeOpErrorDisassociateQualificationFromWorker(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1448 var errorBuffer bytes.Buffer 1449 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1450 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1451 } 1452 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1453 1454 errorCode := "UnknownError" 1455 errorMessage := errorCode 1456 1457 code := response.Header.Get("X-Amzn-ErrorType") 1458 if len(code) != 0 { 1459 errorCode = restjson.SanitizeErrorCode(code) 1460 } 1461 1462 var buff [1024]byte 1463 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1464 1465 body := io.TeeReader(errorBody, ringBuffer) 1466 decoder := json.NewDecoder(body) 1467 decoder.UseNumber() 1468 code, message, err := restjson.GetErrorInfo(decoder) 1469 if err != nil { 1470 var snapshot bytes.Buffer 1471 io.Copy(&snapshot, ringBuffer) 1472 err = &smithy.DeserializationError{ 1473 Err: fmt.Errorf("failed to decode response body, %w", err), 1474 Snapshot: snapshot.Bytes(), 1475 } 1476 return err 1477 } 1478 1479 errorBody.Seek(0, io.SeekStart) 1480 if len(code) != 0 { 1481 errorCode = restjson.SanitizeErrorCode(code) 1482 } 1483 if len(message) != 0 { 1484 errorMessage = message 1485 } 1486 1487 switch { 1488 case strings.EqualFold("RequestError", errorCode): 1489 return awsAwsjson11_deserializeErrorRequestError(response, errorBody) 1490 1491 case strings.EqualFold("ServiceFault", errorCode): 1492 return awsAwsjson11_deserializeErrorServiceFault(response, errorBody) 1493 1494 default: 1495 genericError := &smithy.GenericAPIError{ 1496 Code: errorCode, 1497 Message: errorMessage, 1498 } 1499 return genericError 1500 1501 } 1502} 1503 1504type awsAwsjson11_deserializeOpGetAccountBalance struct { 1505} 1506 1507func (*awsAwsjson11_deserializeOpGetAccountBalance) ID() string { 1508 return "OperationDeserializer" 1509} 1510 1511func (m *awsAwsjson11_deserializeOpGetAccountBalance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1512 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1513) { 1514 out, metadata, err = next.HandleDeserialize(ctx, in) 1515 if err != nil { 1516 return out, metadata, err 1517 } 1518 1519 response, ok := out.RawResponse.(*smithyhttp.Response) 1520 if !ok { 1521 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1522 } 1523 1524 if response.StatusCode < 200 || response.StatusCode >= 300 { 1525 return out, metadata, awsAwsjson11_deserializeOpErrorGetAccountBalance(response, &metadata) 1526 } 1527 output := &GetAccountBalanceOutput{} 1528 out.Result = output 1529 1530 var buff [1024]byte 1531 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1532 1533 body := io.TeeReader(response.Body, ringBuffer) 1534 decoder := json.NewDecoder(body) 1535 decoder.UseNumber() 1536 var shape interface{} 1537 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1538 var snapshot bytes.Buffer 1539 io.Copy(&snapshot, ringBuffer) 1540 err = &smithy.DeserializationError{ 1541 Err: fmt.Errorf("failed to decode response body, %w", err), 1542 Snapshot: snapshot.Bytes(), 1543 } 1544 return out, metadata, err 1545 } 1546 1547 err = awsAwsjson11_deserializeOpDocumentGetAccountBalanceOutput(&output, shape) 1548 if err != nil { 1549 var snapshot bytes.Buffer 1550 io.Copy(&snapshot, ringBuffer) 1551 err = &smithy.DeserializationError{ 1552 Err: fmt.Errorf("failed to decode response body, %w", err), 1553 Snapshot: snapshot.Bytes(), 1554 } 1555 return out, metadata, err 1556 } 1557 1558 return out, metadata, err 1559} 1560 1561func awsAwsjson11_deserializeOpErrorGetAccountBalance(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1562 var errorBuffer bytes.Buffer 1563 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1564 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1565 } 1566 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1567 1568 errorCode := "UnknownError" 1569 errorMessage := errorCode 1570 1571 code := response.Header.Get("X-Amzn-ErrorType") 1572 if len(code) != 0 { 1573 errorCode = restjson.SanitizeErrorCode(code) 1574 } 1575 1576 var buff [1024]byte 1577 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1578 1579 body := io.TeeReader(errorBody, ringBuffer) 1580 decoder := json.NewDecoder(body) 1581 decoder.UseNumber() 1582 code, message, err := restjson.GetErrorInfo(decoder) 1583 if err != nil { 1584 var snapshot bytes.Buffer 1585 io.Copy(&snapshot, ringBuffer) 1586 err = &smithy.DeserializationError{ 1587 Err: fmt.Errorf("failed to decode response body, %w", err), 1588 Snapshot: snapshot.Bytes(), 1589 } 1590 return err 1591 } 1592 1593 errorBody.Seek(0, io.SeekStart) 1594 if len(code) != 0 { 1595 errorCode = restjson.SanitizeErrorCode(code) 1596 } 1597 if len(message) != 0 { 1598 errorMessage = message 1599 } 1600 1601 switch { 1602 case strings.EqualFold("RequestError", errorCode): 1603 return awsAwsjson11_deserializeErrorRequestError(response, errorBody) 1604 1605 case strings.EqualFold("ServiceFault", errorCode): 1606 return awsAwsjson11_deserializeErrorServiceFault(response, errorBody) 1607 1608 default: 1609 genericError := &smithy.GenericAPIError{ 1610 Code: errorCode, 1611 Message: errorMessage, 1612 } 1613 return genericError 1614 1615 } 1616} 1617 1618type awsAwsjson11_deserializeOpGetAssignment struct { 1619} 1620 1621func (*awsAwsjson11_deserializeOpGetAssignment) ID() string { 1622 return "OperationDeserializer" 1623} 1624 1625func (m *awsAwsjson11_deserializeOpGetAssignment) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1626 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1627) { 1628 out, metadata, err = next.HandleDeserialize(ctx, in) 1629 if err != nil { 1630 return out, metadata, err 1631 } 1632 1633 response, ok := out.RawResponse.(*smithyhttp.Response) 1634 if !ok { 1635 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1636 } 1637 1638 if response.StatusCode < 200 || response.StatusCode >= 300 { 1639 return out, metadata, awsAwsjson11_deserializeOpErrorGetAssignment(response, &metadata) 1640 } 1641 output := &GetAssignmentOutput{} 1642 out.Result = output 1643 1644 var buff [1024]byte 1645 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1646 1647 body := io.TeeReader(response.Body, ringBuffer) 1648 decoder := json.NewDecoder(body) 1649 decoder.UseNumber() 1650 var shape interface{} 1651 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1652 var snapshot bytes.Buffer 1653 io.Copy(&snapshot, ringBuffer) 1654 err = &smithy.DeserializationError{ 1655 Err: fmt.Errorf("failed to decode response body, %w", err), 1656 Snapshot: snapshot.Bytes(), 1657 } 1658 return out, metadata, err 1659 } 1660 1661 err = awsAwsjson11_deserializeOpDocumentGetAssignmentOutput(&output, shape) 1662 if err != nil { 1663 var snapshot bytes.Buffer 1664 io.Copy(&snapshot, ringBuffer) 1665 err = &smithy.DeserializationError{ 1666 Err: fmt.Errorf("failed to decode response body, %w", err), 1667 Snapshot: snapshot.Bytes(), 1668 } 1669 return out, metadata, err 1670 } 1671 1672 return out, metadata, err 1673} 1674 1675func awsAwsjson11_deserializeOpErrorGetAssignment(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1676 var errorBuffer bytes.Buffer 1677 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1678 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1679 } 1680 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1681 1682 errorCode := "UnknownError" 1683 errorMessage := errorCode 1684 1685 code := response.Header.Get("X-Amzn-ErrorType") 1686 if len(code) != 0 { 1687 errorCode = restjson.SanitizeErrorCode(code) 1688 } 1689 1690 var buff [1024]byte 1691 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1692 1693 body := io.TeeReader(errorBody, ringBuffer) 1694 decoder := json.NewDecoder(body) 1695 decoder.UseNumber() 1696 code, message, err := restjson.GetErrorInfo(decoder) 1697 if err != nil { 1698 var snapshot bytes.Buffer 1699 io.Copy(&snapshot, ringBuffer) 1700 err = &smithy.DeserializationError{ 1701 Err: fmt.Errorf("failed to decode response body, %w", err), 1702 Snapshot: snapshot.Bytes(), 1703 } 1704 return err 1705 } 1706 1707 errorBody.Seek(0, io.SeekStart) 1708 if len(code) != 0 { 1709 errorCode = restjson.SanitizeErrorCode(code) 1710 } 1711 if len(message) != 0 { 1712 errorMessage = message 1713 } 1714 1715 switch { 1716 case strings.EqualFold("RequestError", errorCode): 1717 return awsAwsjson11_deserializeErrorRequestError(response, errorBody) 1718 1719 case strings.EqualFold("ServiceFault", errorCode): 1720 return awsAwsjson11_deserializeErrorServiceFault(response, errorBody) 1721 1722 default: 1723 genericError := &smithy.GenericAPIError{ 1724 Code: errorCode, 1725 Message: errorMessage, 1726 } 1727 return genericError 1728 1729 } 1730} 1731 1732type awsAwsjson11_deserializeOpGetFileUploadURL struct { 1733} 1734 1735func (*awsAwsjson11_deserializeOpGetFileUploadURL) ID() string { 1736 return "OperationDeserializer" 1737} 1738 1739func (m *awsAwsjson11_deserializeOpGetFileUploadURL) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1740 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1741) { 1742 out, metadata, err = next.HandleDeserialize(ctx, in) 1743 if err != nil { 1744 return out, metadata, err 1745 } 1746 1747 response, ok := out.RawResponse.(*smithyhttp.Response) 1748 if !ok { 1749 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1750 } 1751 1752 if response.StatusCode < 200 || response.StatusCode >= 300 { 1753 return out, metadata, awsAwsjson11_deserializeOpErrorGetFileUploadURL(response, &metadata) 1754 } 1755 output := &GetFileUploadURLOutput{} 1756 out.Result = output 1757 1758 var buff [1024]byte 1759 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1760 1761 body := io.TeeReader(response.Body, ringBuffer) 1762 decoder := json.NewDecoder(body) 1763 decoder.UseNumber() 1764 var shape interface{} 1765 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1766 var snapshot bytes.Buffer 1767 io.Copy(&snapshot, ringBuffer) 1768 err = &smithy.DeserializationError{ 1769 Err: fmt.Errorf("failed to decode response body, %w", err), 1770 Snapshot: snapshot.Bytes(), 1771 } 1772 return out, metadata, err 1773 } 1774 1775 err = awsAwsjson11_deserializeOpDocumentGetFileUploadURLOutput(&output, shape) 1776 if err != nil { 1777 var snapshot bytes.Buffer 1778 io.Copy(&snapshot, ringBuffer) 1779 err = &smithy.DeserializationError{ 1780 Err: fmt.Errorf("failed to decode response body, %w", err), 1781 Snapshot: snapshot.Bytes(), 1782 } 1783 return out, metadata, err 1784 } 1785 1786 return out, metadata, err 1787} 1788 1789func awsAwsjson11_deserializeOpErrorGetFileUploadURL(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1790 var errorBuffer bytes.Buffer 1791 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1792 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1793 } 1794 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1795 1796 errorCode := "UnknownError" 1797 errorMessage := errorCode 1798 1799 code := response.Header.Get("X-Amzn-ErrorType") 1800 if len(code) != 0 { 1801 errorCode = restjson.SanitizeErrorCode(code) 1802 } 1803 1804 var buff [1024]byte 1805 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1806 1807 body := io.TeeReader(errorBody, ringBuffer) 1808 decoder := json.NewDecoder(body) 1809 decoder.UseNumber() 1810 code, message, err := restjson.GetErrorInfo(decoder) 1811 if err != nil { 1812 var snapshot bytes.Buffer 1813 io.Copy(&snapshot, ringBuffer) 1814 err = &smithy.DeserializationError{ 1815 Err: fmt.Errorf("failed to decode response body, %w", err), 1816 Snapshot: snapshot.Bytes(), 1817 } 1818 return err 1819 } 1820 1821 errorBody.Seek(0, io.SeekStart) 1822 if len(code) != 0 { 1823 errorCode = restjson.SanitizeErrorCode(code) 1824 } 1825 if len(message) != 0 { 1826 errorMessage = message 1827 } 1828 1829 switch { 1830 case strings.EqualFold("RequestError", errorCode): 1831 return awsAwsjson11_deserializeErrorRequestError(response, errorBody) 1832 1833 case strings.EqualFold("ServiceFault", errorCode): 1834 return awsAwsjson11_deserializeErrorServiceFault(response, errorBody) 1835 1836 default: 1837 genericError := &smithy.GenericAPIError{ 1838 Code: errorCode, 1839 Message: errorMessage, 1840 } 1841 return genericError 1842 1843 } 1844} 1845 1846type awsAwsjson11_deserializeOpGetHIT struct { 1847} 1848 1849func (*awsAwsjson11_deserializeOpGetHIT) ID() string { 1850 return "OperationDeserializer" 1851} 1852 1853func (m *awsAwsjson11_deserializeOpGetHIT) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1854 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1855) { 1856 out, metadata, err = next.HandleDeserialize(ctx, in) 1857 if err != nil { 1858 return out, metadata, err 1859 } 1860 1861 response, ok := out.RawResponse.(*smithyhttp.Response) 1862 if !ok { 1863 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1864 } 1865 1866 if response.StatusCode < 200 || response.StatusCode >= 300 { 1867 return out, metadata, awsAwsjson11_deserializeOpErrorGetHIT(response, &metadata) 1868 } 1869 output := &GetHITOutput{} 1870 out.Result = output 1871 1872 var buff [1024]byte 1873 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1874 1875 body := io.TeeReader(response.Body, ringBuffer) 1876 decoder := json.NewDecoder(body) 1877 decoder.UseNumber() 1878 var shape interface{} 1879 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1880 var snapshot bytes.Buffer 1881 io.Copy(&snapshot, ringBuffer) 1882 err = &smithy.DeserializationError{ 1883 Err: fmt.Errorf("failed to decode response body, %w", err), 1884 Snapshot: snapshot.Bytes(), 1885 } 1886 return out, metadata, err 1887 } 1888 1889 err = awsAwsjson11_deserializeOpDocumentGetHITOutput(&output, shape) 1890 if err != nil { 1891 var snapshot bytes.Buffer 1892 io.Copy(&snapshot, ringBuffer) 1893 err = &smithy.DeserializationError{ 1894 Err: fmt.Errorf("failed to decode response body, %w", err), 1895 Snapshot: snapshot.Bytes(), 1896 } 1897 return out, metadata, err 1898 } 1899 1900 return out, metadata, err 1901} 1902 1903func awsAwsjson11_deserializeOpErrorGetHIT(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1904 var errorBuffer bytes.Buffer 1905 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1906 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1907 } 1908 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1909 1910 errorCode := "UnknownError" 1911 errorMessage := errorCode 1912 1913 code := response.Header.Get("X-Amzn-ErrorType") 1914 if len(code) != 0 { 1915 errorCode = restjson.SanitizeErrorCode(code) 1916 } 1917 1918 var buff [1024]byte 1919 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1920 1921 body := io.TeeReader(errorBody, ringBuffer) 1922 decoder := json.NewDecoder(body) 1923 decoder.UseNumber() 1924 code, message, err := restjson.GetErrorInfo(decoder) 1925 if err != nil { 1926 var snapshot bytes.Buffer 1927 io.Copy(&snapshot, ringBuffer) 1928 err = &smithy.DeserializationError{ 1929 Err: fmt.Errorf("failed to decode response body, %w", err), 1930 Snapshot: snapshot.Bytes(), 1931 } 1932 return err 1933 } 1934 1935 errorBody.Seek(0, io.SeekStart) 1936 if len(code) != 0 { 1937 errorCode = restjson.SanitizeErrorCode(code) 1938 } 1939 if len(message) != 0 { 1940 errorMessage = message 1941 } 1942 1943 switch { 1944 case strings.EqualFold("RequestError", errorCode): 1945 return awsAwsjson11_deserializeErrorRequestError(response, errorBody) 1946 1947 case strings.EqualFold("ServiceFault", errorCode): 1948 return awsAwsjson11_deserializeErrorServiceFault(response, errorBody) 1949 1950 default: 1951 genericError := &smithy.GenericAPIError{ 1952 Code: errorCode, 1953 Message: errorMessage, 1954 } 1955 return genericError 1956 1957 } 1958} 1959 1960type awsAwsjson11_deserializeOpGetQualificationScore struct { 1961} 1962 1963func (*awsAwsjson11_deserializeOpGetQualificationScore) ID() string { 1964 return "OperationDeserializer" 1965} 1966 1967func (m *awsAwsjson11_deserializeOpGetQualificationScore) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1968 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1969) { 1970 out, metadata, err = next.HandleDeserialize(ctx, in) 1971 if err != nil { 1972 return out, metadata, err 1973 } 1974 1975 response, ok := out.RawResponse.(*smithyhttp.Response) 1976 if !ok { 1977 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1978 } 1979 1980 if response.StatusCode < 200 || response.StatusCode >= 300 { 1981 return out, metadata, awsAwsjson11_deserializeOpErrorGetQualificationScore(response, &metadata) 1982 } 1983 output := &GetQualificationScoreOutput{} 1984 out.Result = output 1985 1986 var buff [1024]byte 1987 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1988 1989 body := io.TeeReader(response.Body, ringBuffer) 1990 decoder := json.NewDecoder(body) 1991 decoder.UseNumber() 1992 var shape interface{} 1993 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1994 var snapshot bytes.Buffer 1995 io.Copy(&snapshot, ringBuffer) 1996 err = &smithy.DeserializationError{ 1997 Err: fmt.Errorf("failed to decode response body, %w", err), 1998 Snapshot: snapshot.Bytes(), 1999 } 2000 return out, metadata, err 2001 } 2002 2003 err = awsAwsjson11_deserializeOpDocumentGetQualificationScoreOutput(&output, shape) 2004 if err != nil { 2005 var snapshot bytes.Buffer 2006 io.Copy(&snapshot, ringBuffer) 2007 err = &smithy.DeserializationError{ 2008 Err: fmt.Errorf("failed to decode response body, %w", err), 2009 Snapshot: snapshot.Bytes(), 2010 } 2011 return out, metadata, err 2012 } 2013 2014 return out, metadata, err 2015} 2016 2017func awsAwsjson11_deserializeOpErrorGetQualificationScore(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2018 var errorBuffer bytes.Buffer 2019 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2020 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2021 } 2022 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2023 2024 errorCode := "UnknownError" 2025 errorMessage := errorCode 2026 2027 code := response.Header.Get("X-Amzn-ErrorType") 2028 if len(code) != 0 { 2029 errorCode = restjson.SanitizeErrorCode(code) 2030 } 2031 2032 var buff [1024]byte 2033 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2034 2035 body := io.TeeReader(errorBody, ringBuffer) 2036 decoder := json.NewDecoder(body) 2037 decoder.UseNumber() 2038 code, message, err := restjson.GetErrorInfo(decoder) 2039 if err != nil { 2040 var snapshot bytes.Buffer 2041 io.Copy(&snapshot, ringBuffer) 2042 err = &smithy.DeserializationError{ 2043 Err: fmt.Errorf("failed to decode response body, %w", err), 2044 Snapshot: snapshot.Bytes(), 2045 } 2046 return err 2047 } 2048 2049 errorBody.Seek(0, io.SeekStart) 2050 if len(code) != 0 { 2051 errorCode = restjson.SanitizeErrorCode(code) 2052 } 2053 if len(message) != 0 { 2054 errorMessage = message 2055 } 2056 2057 switch { 2058 case strings.EqualFold("RequestError", errorCode): 2059 return awsAwsjson11_deserializeErrorRequestError(response, errorBody) 2060 2061 case strings.EqualFold("ServiceFault", errorCode): 2062 return awsAwsjson11_deserializeErrorServiceFault(response, errorBody) 2063 2064 default: 2065 genericError := &smithy.GenericAPIError{ 2066 Code: errorCode, 2067 Message: errorMessage, 2068 } 2069 return genericError 2070 2071 } 2072} 2073 2074type awsAwsjson11_deserializeOpGetQualificationType struct { 2075} 2076 2077func (*awsAwsjson11_deserializeOpGetQualificationType) ID() string { 2078 return "OperationDeserializer" 2079} 2080 2081func (m *awsAwsjson11_deserializeOpGetQualificationType) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2082 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2083) { 2084 out, metadata, err = next.HandleDeserialize(ctx, in) 2085 if err != nil { 2086 return out, metadata, err 2087 } 2088 2089 response, ok := out.RawResponse.(*smithyhttp.Response) 2090 if !ok { 2091 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2092 } 2093 2094 if response.StatusCode < 200 || response.StatusCode >= 300 { 2095 return out, metadata, awsAwsjson11_deserializeOpErrorGetQualificationType(response, &metadata) 2096 } 2097 output := &GetQualificationTypeOutput{} 2098 out.Result = output 2099 2100 var buff [1024]byte 2101 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2102 2103 body := io.TeeReader(response.Body, ringBuffer) 2104 decoder := json.NewDecoder(body) 2105 decoder.UseNumber() 2106 var shape interface{} 2107 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2108 var snapshot bytes.Buffer 2109 io.Copy(&snapshot, ringBuffer) 2110 err = &smithy.DeserializationError{ 2111 Err: fmt.Errorf("failed to decode response body, %w", err), 2112 Snapshot: snapshot.Bytes(), 2113 } 2114 return out, metadata, err 2115 } 2116 2117 err = awsAwsjson11_deserializeOpDocumentGetQualificationTypeOutput(&output, shape) 2118 if err != nil { 2119 var snapshot bytes.Buffer 2120 io.Copy(&snapshot, ringBuffer) 2121 err = &smithy.DeserializationError{ 2122 Err: fmt.Errorf("failed to decode response body, %w", err), 2123 Snapshot: snapshot.Bytes(), 2124 } 2125 return out, metadata, err 2126 } 2127 2128 return out, metadata, err 2129} 2130 2131func awsAwsjson11_deserializeOpErrorGetQualificationType(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2132 var errorBuffer bytes.Buffer 2133 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2134 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2135 } 2136 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2137 2138 errorCode := "UnknownError" 2139 errorMessage := errorCode 2140 2141 code := response.Header.Get("X-Amzn-ErrorType") 2142 if len(code) != 0 { 2143 errorCode = restjson.SanitizeErrorCode(code) 2144 } 2145 2146 var buff [1024]byte 2147 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2148 2149 body := io.TeeReader(errorBody, ringBuffer) 2150 decoder := json.NewDecoder(body) 2151 decoder.UseNumber() 2152 code, message, err := restjson.GetErrorInfo(decoder) 2153 if err != nil { 2154 var snapshot bytes.Buffer 2155 io.Copy(&snapshot, ringBuffer) 2156 err = &smithy.DeserializationError{ 2157 Err: fmt.Errorf("failed to decode response body, %w", err), 2158 Snapshot: snapshot.Bytes(), 2159 } 2160 return err 2161 } 2162 2163 errorBody.Seek(0, io.SeekStart) 2164 if len(code) != 0 { 2165 errorCode = restjson.SanitizeErrorCode(code) 2166 } 2167 if len(message) != 0 { 2168 errorMessage = message 2169 } 2170 2171 switch { 2172 case strings.EqualFold("RequestError", errorCode): 2173 return awsAwsjson11_deserializeErrorRequestError(response, errorBody) 2174 2175 case strings.EqualFold("ServiceFault", errorCode): 2176 return awsAwsjson11_deserializeErrorServiceFault(response, errorBody) 2177 2178 default: 2179 genericError := &smithy.GenericAPIError{ 2180 Code: errorCode, 2181 Message: errorMessage, 2182 } 2183 return genericError 2184 2185 } 2186} 2187 2188type awsAwsjson11_deserializeOpListAssignmentsForHIT struct { 2189} 2190 2191func (*awsAwsjson11_deserializeOpListAssignmentsForHIT) ID() string { 2192 return "OperationDeserializer" 2193} 2194 2195func (m *awsAwsjson11_deserializeOpListAssignmentsForHIT) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2196 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2197) { 2198 out, metadata, err = next.HandleDeserialize(ctx, in) 2199 if err != nil { 2200 return out, metadata, err 2201 } 2202 2203 response, ok := out.RawResponse.(*smithyhttp.Response) 2204 if !ok { 2205 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2206 } 2207 2208 if response.StatusCode < 200 || response.StatusCode >= 300 { 2209 return out, metadata, awsAwsjson11_deserializeOpErrorListAssignmentsForHIT(response, &metadata) 2210 } 2211 output := &ListAssignmentsForHITOutput{} 2212 out.Result = output 2213 2214 var buff [1024]byte 2215 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2216 2217 body := io.TeeReader(response.Body, ringBuffer) 2218 decoder := json.NewDecoder(body) 2219 decoder.UseNumber() 2220 var shape interface{} 2221 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2222 var snapshot bytes.Buffer 2223 io.Copy(&snapshot, ringBuffer) 2224 err = &smithy.DeserializationError{ 2225 Err: fmt.Errorf("failed to decode response body, %w", err), 2226 Snapshot: snapshot.Bytes(), 2227 } 2228 return out, metadata, err 2229 } 2230 2231 err = awsAwsjson11_deserializeOpDocumentListAssignmentsForHITOutput(&output, shape) 2232 if err != nil { 2233 var snapshot bytes.Buffer 2234 io.Copy(&snapshot, ringBuffer) 2235 err = &smithy.DeserializationError{ 2236 Err: fmt.Errorf("failed to decode response body, %w", err), 2237 Snapshot: snapshot.Bytes(), 2238 } 2239 return out, metadata, err 2240 } 2241 2242 return out, metadata, err 2243} 2244 2245func awsAwsjson11_deserializeOpErrorListAssignmentsForHIT(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2246 var errorBuffer bytes.Buffer 2247 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2248 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2249 } 2250 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2251 2252 errorCode := "UnknownError" 2253 errorMessage := errorCode 2254 2255 code := response.Header.Get("X-Amzn-ErrorType") 2256 if len(code) != 0 { 2257 errorCode = restjson.SanitizeErrorCode(code) 2258 } 2259 2260 var buff [1024]byte 2261 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2262 2263 body := io.TeeReader(errorBody, ringBuffer) 2264 decoder := json.NewDecoder(body) 2265 decoder.UseNumber() 2266 code, message, err := restjson.GetErrorInfo(decoder) 2267 if err != nil { 2268 var snapshot bytes.Buffer 2269 io.Copy(&snapshot, ringBuffer) 2270 err = &smithy.DeserializationError{ 2271 Err: fmt.Errorf("failed to decode response body, %w", err), 2272 Snapshot: snapshot.Bytes(), 2273 } 2274 return err 2275 } 2276 2277 errorBody.Seek(0, io.SeekStart) 2278 if len(code) != 0 { 2279 errorCode = restjson.SanitizeErrorCode(code) 2280 } 2281 if len(message) != 0 { 2282 errorMessage = message 2283 } 2284 2285 switch { 2286 case strings.EqualFold("RequestError", errorCode): 2287 return awsAwsjson11_deserializeErrorRequestError(response, errorBody) 2288 2289 case strings.EqualFold("ServiceFault", errorCode): 2290 return awsAwsjson11_deserializeErrorServiceFault(response, errorBody) 2291 2292 default: 2293 genericError := &smithy.GenericAPIError{ 2294 Code: errorCode, 2295 Message: errorMessage, 2296 } 2297 return genericError 2298 2299 } 2300} 2301 2302type awsAwsjson11_deserializeOpListBonusPayments struct { 2303} 2304 2305func (*awsAwsjson11_deserializeOpListBonusPayments) ID() string { 2306 return "OperationDeserializer" 2307} 2308 2309func (m *awsAwsjson11_deserializeOpListBonusPayments) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2310 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2311) { 2312 out, metadata, err = next.HandleDeserialize(ctx, in) 2313 if err != nil { 2314 return out, metadata, err 2315 } 2316 2317 response, ok := out.RawResponse.(*smithyhttp.Response) 2318 if !ok { 2319 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2320 } 2321 2322 if response.StatusCode < 200 || response.StatusCode >= 300 { 2323 return out, metadata, awsAwsjson11_deserializeOpErrorListBonusPayments(response, &metadata) 2324 } 2325 output := &ListBonusPaymentsOutput{} 2326 out.Result = output 2327 2328 var buff [1024]byte 2329 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2330 2331 body := io.TeeReader(response.Body, ringBuffer) 2332 decoder := json.NewDecoder(body) 2333 decoder.UseNumber() 2334 var shape interface{} 2335 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2336 var snapshot bytes.Buffer 2337 io.Copy(&snapshot, ringBuffer) 2338 err = &smithy.DeserializationError{ 2339 Err: fmt.Errorf("failed to decode response body, %w", err), 2340 Snapshot: snapshot.Bytes(), 2341 } 2342 return out, metadata, err 2343 } 2344 2345 err = awsAwsjson11_deserializeOpDocumentListBonusPaymentsOutput(&output, shape) 2346 if err != nil { 2347 var snapshot bytes.Buffer 2348 io.Copy(&snapshot, ringBuffer) 2349 err = &smithy.DeserializationError{ 2350 Err: fmt.Errorf("failed to decode response body, %w", err), 2351 Snapshot: snapshot.Bytes(), 2352 } 2353 return out, metadata, err 2354 } 2355 2356 return out, metadata, err 2357} 2358 2359func awsAwsjson11_deserializeOpErrorListBonusPayments(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2360 var errorBuffer bytes.Buffer 2361 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2362 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2363 } 2364 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2365 2366 errorCode := "UnknownError" 2367 errorMessage := errorCode 2368 2369 code := response.Header.Get("X-Amzn-ErrorType") 2370 if len(code) != 0 { 2371 errorCode = restjson.SanitizeErrorCode(code) 2372 } 2373 2374 var buff [1024]byte 2375 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2376 2377 body := io.TeeReader(errorBody, ringBuffer) 2378 decoder := json.NewDecoder(body) 2379 decoder.UseNumber() 2380 code, message, err := restjson.GetErrorInfo(decoder) 2381 if err != nil { 2382 var snapshot bytes.Buffer 2383 io.Copy(&snapshot, ringBuffer) 2384 err = &smithy.DeserializationError{ 2385 Err: fmt.Errorf("failed to decode response body, %w", err), 2386 Snapshot: snapshot.Bytes(), 2387 } 2388 return err 2389 } 2390 2391 errorBody.Seek(0, io.SeekStart) 2392 if len(code) != 0 { 2393 errorCode = restjson.SanitizeErrorCode(code) 2394 } 2395 if len(message) != 0 { 2396 errorMessage = message 2397 } 2398 2399 switch { 2400 case strings.EqualFold("RequestError", errorCode): 2401 return awsAwsjson11_deserializeErrorRequestError(response, errorBody) 2402 2403 case strings.EqualFold("ServiceFault", errorCode): 2404 return awsAwsjson11_deserializeErrorServiceFault(response, errorBody) 2405 2406 default: 2407 genericError := &smithy.GenericAPIError{ 2408 Code: errorCode, 2409 Message: errorMessage, 2410 } 2411 return genericError 2412 2413 } 2414} 2415 2416type awsAwsjson11_deserializeOpListHITs struct { 2417} 2418 2419func (*awsAwsjson11_deserializeOpListHITs) ID() string { 2420 return "OperationDeserializer" 2421} 2422 2423func (m *awsAwsjson11_deserializeOpListHITs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2424 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2425) { 2426 out, metadata, err = next.HandleDeserialize(ctx, in) 2427 if err != nil { 2428 return out, metadata, err 2429 } 2430 2431 response, ok := out.RawResponse.(*smithyhttp.Response) 2432 if !ok { 2433 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2434 } 2435 2436 if response.StatusCode < 200 || response.StatusCode >= 300 { 2437 return out, metadata, awsAwsjson11_deserializeOpErrorListHITs(response, &metadata) 2438 } 2439 output := &ListHITsOutput{} 2440 out.Result = output 2441 2442 var buff [1024]byte 2443 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2444 2445 body := io.TeeReader(response.Body, ringBuffer) 2446 decoder := json.NewDecoder(body) 2447 decoder.UseNumber() 2448 var shape interface{} 2449 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2450 var snapshot bytes.Buffer 2451 io.Copy(&snapshot, ringBuffer) 2452 err = &smithy.DeserializationError{ 2453 Err: fmt.Errorf("failed to decode response body, %w", err), 2454 Snapshot: snapshot.Bytes(), 2455 } 2456 return out, metadata, err 2457 } 2458 2459 err = awsAwsjson11_deserializeOpDocumentListHITsOutput(&output, shape) 2460 if err != nil { 2461 var snapshot bytes.Buffer 2462 io.Copy(&snapshot, ringBuffer) 2463 err = &smithy.DeserializationError{ 2464 Err: fmt.Errorf("failed to decode response body, %w", err), 2465 Snapshot: snapshot.Bytes(), 2466 } 2467 return out, metadata, err 2468 } 2469 2470 return out, metadata, err 2471} 2472 2473func awsAwsjson11_deserializeOpErrorListHITs(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2474 var errorBuffer bytes.Buffer 2475 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2476 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2477 } 2478 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2479 2480 errorCode := "UnknownError" 2481 errorMessage := errorCode 2482 2483 code := response.Header.Get("X-Amzn-ErrorType") 2484 if len(code) != 0 { 2485 errorCode = restjson.SanitizeErrorCode(code) 2486 } 2487 2488 var buff [1024]byte 2489 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2490 2491 body := io.TeeReader(errorBody, ringBuffer) 2492 decoder := json.NewDecoder(body) 2493 decoder.UseNumber() 2494 code, message, err := restjson.GetErrorInfo(decoder) 2495 if err != nil { 2496 var snapshot bytes.Buffer 2497 io.Copy(&snapshot, ringBuffer) 2498 err = &smithy.DeserializationError{ 2499 Err: fmt.Errorf("failed to decode response body, %w", err), 2500 Snapshot: snapshot.Bytes(), 2501 } 2502 return err 2503 } 2504 2505 errorBody.Seek(0, io.SeekStart) 2506 if len(code) != 0 { 2507 errorCode = restjson.SanitizeErrorCode(code) 2508 } 2509 if len(message) != 0 { 2510 errorMessage = message 2511 } 2512 2513 switch { 2514 case strings.EqualFold("RequestError", errorCode): 2515 return awsAwsjson11_deserializeErrorRequestError(response, errorBody) 2516 2517 case strings.EqualFold("ServiceFault", errorCode): 2518 return awsAwsjson11_deserializeErrorServiceFault(response, errorBody) 2519 2520 default: 2521 genericError := &smithy.GenericAPIError{ 2522 Code: errorCode, 2523 Message: errorMessage, 2524 } 2525 return genericError 2526 2527 } 2528} 2529 2530type awsAwsjson11_deserializeOpListHITsForQualificationType struct { 2531} 2532 2533func (*awsAwsjson11_deserializeOpListHITsForQualificationType) ID() string { 2534 return "OperationDeserializer" 2535} 2536 2537func (m *awsAwsjson11_deserializeOpListHITsForQualificationType) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2538 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2539) { 2540 out, metadata, err = next.HandleDeserialize(ctx, in) 2541 if err != nil { 2542 return out, metadata, err 2543 } 2544 2545 response, ok := out.RawResponse.(*smithyhttp.Response) 2546 if !ok { 2547 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2548 } 2549 2550 if response.StatusCode < 200 || response.StatusCode >= 300 { 2551 return out, metadata, awsAwsjson11_deserializeOpErrorListHITsForQualificationType(response, &metadata) 2552 } 2553 output := &ListHITsForQualificationTypeOutput{} 2554 out.Result = output 2555 2556 var buff [1024]byte 2557 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2558 2559 body := io.TeeReader(response.Body, ringBuffer) 2560 decoder := json.NewDecoder(body) 2561 decoder.UseNumber() 2562 var shape interface{} 2563 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2564 var snapshot bytes.Buffer 2565 io.Copy(&snapshot, ringBuffer) 2566 err = &smithy.DeserializationError{ 2567 Err: fmt.Errorf("failed to decode response body, %w", err), 2568 Snapshot: snapshot.Bytes(), 2569 } 2570 return out, metadata, err 2571 } 2572 2573 err = awsAwsjson11_deserializeOpDocumentListHITsForQualificationTypeOutput(&output, shape) 2574 if err != nil { 2575 var snapshot bytes.Buffer 2576 io.Copy(&snapshot, ringBuffer) 2577 err = &smithy.DeserializationError{ 2578 Err: fmt.Errorf("failed to decode response body, %w", err), 2579 Snapshot: snapshot.Bytes(), 2580 } 2581 return out, metadata, err 2582 } 2583 2584 return out, metadata, err 2585} 2586 2587func awsAwsjson11_deserializeOpErrorListHITsForQualificationType(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2588 var errorBuffer bytes.Buffer 2589 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2590 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2591 } 2592 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2593 2594 errorCode := "UnknownError" 2595 errorMessage := errorCode 2596 2597 code := response.Header.Get("X-Amzn-ErrorType") 2598 if len(code) != 0 { 2599 errorCode = restjson.SanitizeErrorCode(code) 2600 } 2601 2602 var buff [1024]byte 2603 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2604 2605 body := io.TeeReader(errorBody, ringBuffer) 2606 decoder := json.NewDecoder(body) 2607 decoder.UseNumber() 2608 code, message, err := restjson.GetErrorInfo(decoder) 2609 if err != nil { 2610 var snapshot bytes.Buffer 2611 io.Copy(&snapshot, ringBuffer) 2612 err = &smithy.DeserializationError{ 2613 Err: fmt.Errorf("failed to decode response body, %w", err), 2614 Snapshot: snapshot.Bytes(), 2615 } 2616 return err 2617 } 2618 2619 errorBody.Seek(0, io.SeekStart) 2620 if len(code) != 0 { 2621 errorCode = restjson.SanitizeErrorCode(code) 2622 } 2623 if len(message) != 0 { 2624 errorMessage = message 2625 } 2626 2627 switch { 2628 case strings.EqualFold("RequestError", errorCode): 2629 return awsAwsjson11_deserializeErrorRequestError(response, errorBody) 2630 2631 case strings.EqualFold("ServiceFault", errorCode): 2632 return awsAwsjson11_deserializeErrorServiceFault(response, errorBody) 2633 2634 default: 2635 genericError := &smithy.GenericAPIError{ 2636 Code: errorCode, 2637 Message: errorMessage, 2638 } 2639 return genericError 2640 2641 } 2642} 2643 2644type awsAwsjson11_deserializeOpListQualificationRequests struct { 2645} 2646 2647func (*awsAwsjson11_deserializeOpListQualificationRequests) ID() string { 2648 return "OperationDeserializer" 2649} 2650 2651func (m *awsAwsjson11_deserializeOpListQualificationRequests) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2652 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2653) { 2654 out, metadata, err = next.HandleDeserialize(ctx, in) 2655 if err != nil { 2656 return out, metadata, err 2657 } 2658 2659 response, ok := out.RawResponse.(*smithyhttp.Response) 2660 if !ok { 2661 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2662 } 2663 2664 if response.StatusCode < 200 || response.StatusCode >= 300 { 2665 return out, metadata, awsAwsjson11_deserializeOpErrorListQualificationRequests(response, &metadata) 2666 } 2667 output := &ListQualificationRequestsOutput{} 2668 out.Result = output 2669 2670 var buff [1024]byte 2671 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2672 2673 body := io.TeeReader(response.Body, ringBuffer) 2674 decoder := json.NewDecoder(body) 2675 decoder.UseNumber() 2676 var shape interface{} 2677 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2678 var snapshot bytes.Buffer 2679 io.Copy(&snapshot, ringBuffer) 2680 err = &smithy.DeserializationError{ 2681 Err: fmt.Errorf("failed to decode response body, %w", err), 2682 Snapshot: snapshot.Bytes(), 2683 } 2684 return out, metadata, err 2685 } 2686 2687 err = awsAwsjson11_deserializeOpDocumentListQualificationRequestsOutput(&output, shape) 2688 if err != nil { 2689 var snapshot bytes.Buffer 2690 io.Copy(&snapshot, ringBuffer) 2691 err = &smithy.DeserializationError{ 2692 Err: fmt.Errorf("failed to decode response body, %w", err), 2693 Snapshot: snapshot.Bytes(), 2694 } 2695 return out, metadata, err 2696 } 2697 2698 return out, metadata, err 2699} 2700 2701func awsAwsjson11_deserializeOpErrorListQualificationRequests(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2702 var errorBuffer bytes.Buffer 2703 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2704 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2705 } 2706 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2707 2708 errorCode := "UnknownError" 2709 errorMessage := errorCode 2710 2711 code := response.Header.Get("X-Amzn-ErrorType") 2712 if len(code) != 0 { 2713 errorCode = restjson.SanitizeErrorCode(code) 2714 } 2715 2716 var buff [1024]byte 2717 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2718 2719 body := io.TeeReader(errorBody, ringBuffer) 2720 decoder := json.NewDecoder(body) 2721 decoder.UseNumber() 2722 code, message, err := restjson.GetErrorInfo(decoder) 2723 if err != nil { 2724 var snapshot bytes.Buffer 2725 io.Copy(&snapshot, ringBuffer) 2726 err = &smithy.DeserializationError{ 2727 Err: fmt.Errorf("failed to decode response body, %w", err), 2728 Snapshot: snapshot.Bytes(), 2729 } 2730 return err 2731 } 2732 2733 errorBody.Seek(0, io.SeekStart) 2734 if len(code) != 0 { 2735 errorCode = restjson.SanitizeErrorCode(code) 2736 } 2737 if len(message) != 0 { 2738 errorMessage = message 2739 } 2740 2741 switch { 2742 case strings.EqualFold("RequestError", errorCode): 2743 return awsAwsjson11_deserializeErrorRequestError(response, errorBody) 2744 2745 case strings.EqualFold("ServiceFault", errorCode): 2746 return awsAwsjson11_deserializeErrorServiceFault(response, errorBody) 2747 2748 default: 2749 genericError := &smithy.GenericAPIError{ 2750 Code: errorCode, 2751 Message: errorMessage, 2752 } 2753 return genericError 2754 2755 } 2756} 2757 2758type awsAwsjson11_deserializeOpListQualificationTypes struct { 2759} 2760 2761func (*awsAwsjson11_deserializeOpListQualificationTypes) ID() string { 2762 return "OperationDeserializer" 2763} 2764 2765func (m *awsAwsjson11_deserializeOpListQualificationTypes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2766 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2767) { 2768 out, metadata, err = next.HandleDeserialize(ctx, in) 2769 if err != nil { 2770 return out, metadata, err 2771 } 2772 2773 response, ok := out.RawResponse.(*smithyhttp.Response) 2774 if !ok { 2775 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2776 } 2777 2778 if response.StatusCode < 200 || response.StatusCode >= 300 { 2779 return out, metadata, awsAwsjson11_deserializeOpErrorListQualificationTypes(response, &metadata) 2780 } 2781 output := &ListQualificationTypesOutput{} 2782 out.Result = output 2783 2784 var buff [1024]byte 2785 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2786 2787 body := io.TeeReader(response.Body, ringBuffer) 2788 decoder := json.NewDecoder(body) 2789 decoder.UseNumber() 2790 var shape interface{} 2791 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2792 var snapshot bytes.Buffer 2793 io.Copy(&snapshot, ringBuffer) 2794 err = &smithy.DeserializationError{ 2795 Err: fmt.Errorf("failed to decode response body, %w", err), 2796 Snapshot: snapshot.Bytes(), 2797 } 2798 return out, metadata, err 2799 } 2800 2801 err = awsAwsjson11_deserializeOpDocumentListQualificationTypesOutput(&output, shape) 2802 if err != nil { 2803 var snapshot bytes.Buffer 2804 io.Copy(&snapshot, ringBuffer) 2805 err = &smithy.DeserializationError{ 2806 Err: fmt.Errorf("failed to decode response body, %w", err), 2807 Snapshot: snapshot.Bytes(), 2808 } 2809 return out, metadata, err 2810 } 2811 2812 return out, metadata, err 2813} 2814 2815func awsAwsjson11_deserializeOpErrorListQualificationTypes(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2816 var errorBuffer bytes.Buffer 2817 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2818 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2819 } 2820 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2821 2822 errorCode := "UnknownError" 2823 errorMessage := errorCode 2824 2825 code := response.Header.Get("X-Amzn-ErrorType") 2826 if len(code) != 0 { 2827 errorCode = restjson.SanitizeErrorCode(code) 2828 } 2829 2830 var buff [1024]byte 2831 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2832 2833 body := io.TeeReader(errorBody, ringBuffer) 2834 decoder := json.NewDecoder(body) 2835 decoder.UseNumber() 2836 code, message, err := restjson.GetErrorInfo(decoder) 2837 if err != nil { 2838 var snapshot bytes.Buffer 2839 io.Copy(&snapshot, ringBuffer) 2840 err = &smithy.DeserializationError{ 2841 Err: fmt.Errorf("failed to decode response body, %w", err), 2842 Snapshot: snapshot.Bytes(), 2843 } 2844 return err 2845 } 2846 2847 errorBody.Seek(0, io.SeekStart) 2848 if len(code) != 0 { 2849 errorCode = restjson.SanitizeErrorCode(code) 2850 } 2851 if len(message) != 0 { 2852 errorMessage = message 2853 } 2854 2855 switch { 2856 case strings.EqualFold("RequestError", errorCode): 2857 return awsAwsjson11_deserializeErrorRequestError(response, errorBody) 2858 2859 case strings.EqualFold("ServiceFault", errorCode): 2860 return awsAwsjson11_deserializeErrorServiceFault(response, errorBody) 2861 2862 default: 2863 genericError := &smithy.GenericAPIError{ 2864 Code: errorCode, 2865 Message: errorMessage, 2866 } 2867 return genericError 2868 2869 } 2870} 2871 2872type awsAwsjson11_deserializeOpListReviewableHITs struct { 2873} 2874 2875func (*awsAwsjson11_deserializeOpListReviewableHITs) ID() string { 2876 return "OperationDeserializer" 2877} 2878 2879func (m *awsAwsjson11_deserializeOpListReviewableHITs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2880 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2881) { 2882 out, metadata, err = next.HandleDeserialize(ctx, in) 2883 if err != nil { 2884 return out, metadata, err 2885 } 2886 2887 response, ok := out.RawResponse.(*smithyhttp.Response) 2888 if !ok { 2889 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2890 } 2891 2892 if response.StatusCode < 200 || response.StatusCode >= 300 { 2893 return out, metadata, awsAwsjson11_deserializeOpErrorListReviewableHITs(response, &metadata) 2894 } 2895 output := &ListReviewableHITsOutput{} 2896 out.Result = output 2897 2898 var buff [1024]byte 2899 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2900 2901 body := io.TeeReader(response.Body, ringBuffer) 2902 decoder := json.NewDecoder(body) 2903 decoder.UseNumber() 2904 var shape interface{} 2905 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2906 var snapshot bytes.Buffer 2907 io.Copy(&snapshot, ringBuffer) 2908 err = &smithy.DeserializationError{ 2909 Err: fmt.Errorf("failed to decode response body, %w", err), 2910 Snapshot: snapshot.Bytes(), 2911 } 2912 return out, metadata, err 2913 } 2914 2915 err = awsAwsjson11_deserializeOpDocumentListReviewableHITsOutput(&output, shape) 2916 if err != nil { 2917 var snapshot bytes.Buffer 2918 io.Copy(&snapshot, ringBuffer) 2919 err = &smithy.DeserializationError{ 2920 Err: fmt.Errorf("failed to decode response body, %w", err), 2921 Snapshot: snapshot.Bytes(), 2922 } 2923 return out, metadata, err 2924 } 2925 2926 return out, metadata, err 2927} 2928 2929func awsAwsjson11_deserializeOpErrorListReviewableHITs(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2930 var errorBuffer bytes.Buffer 2931 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2932 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2933 } 2934 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2935 2936 errorCode := "UnknownError" 2937 errorMessage := errorCode 2938 2939 code := response.Header.Get("X-Amzn-ErrorType") 2940 if len(code) != 0 { 2941 errorCode = restjson.SanitizeErrorCode(code) 2942 } 2943 2944 var buff [1024]byte 2945 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2946 2947 body := io.TeeReader(errorBody, ringBuffer) 2948 decoder := json.NewDecoder(body) 2949 decoder.UseNumber() 2950 code, message, err := restjson.GetErrorInfo(decoder) 2951 if err != nil { 2952 var snapshot bytes.Buffer 2953 io.Copy(&snapshot, ringBuffer) 2954 err = &smithy.DeserializationError{ 2955 Err: fmt.Errorf("failed to decode response body, %w", err), 2956 Snapshot: snapshot.Bytes(), 2957 } 2958 return err 2959 } 2960 2961 errorBody.Seek(0, io.SeekStart) 2962 if len(code) != 0 { 2963 errorCode = restjson.SanitizeErrorCode(code) 2964 } 2965 if len(message) != 0 { 2966 errorMessage = message 2967 } 2968 2969 switch { 2970 case strings.EqualFold("RequestError", errorCode): 2971 return awsAwsjson11_deserializeErrorRequestError(response, errorBody) 2972 2973 case strings.EqualFold("ServiceFault", errorCode): 2974 return awsAwsjson11_deserializeErrorServiceFault(response, errorBody) 2975 2976 default: 2977 genericError := &smithy.GenericAPIError{ 2978 Code: errorCode, 2979 Message: errorMessage, 2980 } 2981 return genericError 2982 2983 } 2984} 2985 2986type awsAwsjson11_deserializeOpListReviewPolicyResultsForHIT struct { 2987} 2988 2989func (*awsAwsjson11_deserializeOpListReviewPolicyResultsForHIT) ID() string { 2990 return "OperationDeserializer" 2991} 2992 2993func (m *awsAwsjson11_deserializeOpListReviewPolicyResultsForHIT) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2994 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2995) { 2996 out, metadata, err = next.HandleDeserialize(ctx, in) 2997 if err != nil { 2998 return out, metadata, err 2999 } 3000 3001 response, ok := out.RawResponse.(*smithyhttp.Response) 3002 if !ok { 3003 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3004 } 3005 3006 if response.StatusCode < 200 || response.StatusCode >= 300 { 3007 return out, metadata, awsAwsjson11_deserializeOpErrorListReviewPolicyResultsForHIT(response, &metadata) 3008 } 3009 output := &ListReviewPolicyResultsForHITOutput{} 3010 out.Result = output 3011 3012 var buff [1024]byte 3013 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3014 3015 body := io.TeeReader(response.Body, ringBuffer) 3016 decoder := json.NewDecoder(body) 3017 decoder.UseNumber() 3018 var shape interface{} 3019 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3020 var snapshot bytes.Buffer 3021 io.Copy(&snapshot, ringBuffer) 3022 err = &smithy.DeserializationError{ 3023 Err: fmt.Errorf("failed to decode response body, %w", err), 3024 Snapshot: snapshot.Bytes(), 3025 } 3026 return out, metadata, err 3027 } 3028 3029 err = awsAwsjson11_deserializeOpDocumentListReviewPolicyResultsForHITOutput(&output, shape) 3030 if err != nil { 3031 var snapshot bytes.Buffer 3032 io.Copy(&snapshot, ringBuffer) 3033 err = &smithy.DeserializationError{ 3034 Err: fmt.Errorf("failed to decode response body, %w", err), 3035 Snapshot: snapshot.Bytes(), 3036 } 3037 return out, metadata, err 3038 } 3039 3040 return out, metadata, err 3041} 3042 3043func awsAwsjson11_deserializeOpErrorListReviewPolicyResultsForHIT(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3044 var errorBuffer bytes.Buffer 3045 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3046 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3047 } 3048 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3049 3050 errorCode := "UnknownError" 3051 errorMessage := errorCode 3052 3053 code := response.Header.Get("X-Amzn-ErrorType") 3054 if len(code) != 0 { 3055 errorCode = restjson.SanitizeErrorCode(code) 3056 } 3057 3058 var buff [1024]byte 3059 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3060 3061 body := io.TeeReader(errorBody, ringBuffer) 3062 decoder := json.NewDecoder(body) 3063 decoder.UseNumber() 3064 code, message, err := restjson.GetErrorInfo(decoder) 3065 if err != nil { 3066 var snapshot bytes.Buffer 3067 io.Copy(&snapshot, ringBuffer) 3068 err = &smithy.DeserializationError{ 3069 Err: fmt.Errorf("failed to decode response body, %w", err), 3070 Snapshot: snapshot.Bytes(), 3071 } 3072 return err 3073 } 3074 3075 errorBody.Seek(0, io.SeekStart) 3076 if len(code) != 0 { 3077 errorCode = restjson.SanitizeErrorCode(code) 3078 } 3079 if len(message) != 0 { 3080 errorMessage = message 3081 } 3082 3083 switch { 3084 case strings.EqualFold("RequestError", errorCode): 3085 return awsAwsjson11_deserializeErrorRequestError(response, errorBody) 3086 3087 case strings.EqualFold("ServiceFault", errorCode): 3088 return awsAwsjson11_deserializeErrorServiceFault(response, errorBody) 3089 3090 default: 3091 genericError := &smithy.GenericAPIError{ 3092 Code: errorCode, 3093 Message: errorMessage, 3094 } 3095 return genericError 3096 3097 } 3098} 3099 3100type awsAwsjson11_deserializeOpListWorkerBlocks struct { 3101} 3102 3103func (*awsAwsjson11_deserializeOpListWorkerBlocks) ID() string { 3104 return "OperationDeserializer" 3105} 3106 3107func (m *awsAwsjson11_deserializeOpListWorkerBlocks) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3108 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3109) { 3110 out, metadata, err = next.HandleDeserialize(ctx, in) 3111 if err != nil { 3112 return out, metadata, err 3113 } 3114 3115 response, ok := out.RawResponse.(*smithyhttp.Response) 3116 if !ok { 3117 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3118 } 3119 3120 if response.StatusCode < 200 || response.StatusCode >= 300 { 3121 return out, metadata, awsAwsjson11_deserializeOpErrorListWorkerBlocks(response, &metadata) 3122 } 3123 output := &ListWorkerBlocksOutput{} 3124 out.Result = output 3125 3126 var buff [1024]byte 3127 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3128 3129 body := io.TeeReader(response.Body, ringBuffer) 3130 decoder := json.NewDecoder(body) 3131 decoder.UseNumber() 3132 var shape interface{} 3133 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3134 var snapshot bytes.Buffer 3135 io.Copy(&snapshot, ringBuffer) 3136 err = &smithy.DeserializationError{ 3137 Err: fmt.Errorf("failed to decode response body, %w", err), 3138 Snapshot: snapshot.Bytes(), 3139 } 3140 return out, metadata, err 3141 } 3142 3143 err = awsAwsjson11_deserializeOpDocumentListWorkerBlocksOutput(&output, shape) 3144 if err != nil { 3145 var snapshot bytes.Buffer 3146 io.Copy(&snapshot, ringBuffer) 3147 err = &smithy.DeserializationError{ 3148 Err: fmt.Errorf("failed to decode response body, %w", err), 3149 Snapshot: snapshot.Bytes(), 3150 } 3151 return out, metadata, err 3152 } 3153 3154 return out, metadata, err 3155} 3156 3157func awsAwsjson11_deserializeOpErrorListWorkerBlocks(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3158 var errorBuffer bytes.Buffer 3159 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3160 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3161 } 3162 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3163 3164 errorCode := "UnknownError" 3165 errorMessage := errorCode 3166 3167 code := response.Header.Get("X-Amzn-ErrorType") 3168 if len(code) != 0 { 3169 errorCode = restjson.SanitizeErrorCode(code) 3170 } 3171 3172 var buff [1024]byte 3173 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3174 3175 body := io.TeeReader(errorBody, ringBuffer) 3176 decoder := json.NewDecoder(body) 3177 decoder.UseNumber() 3178 code, message, err := restjson.GetErrorInfo(decoder) 3179 if err != nil { 3180 var snapshot bytes.Buffer 3181 io.Copy(&snapshot, ringBuffer) 3182 err = &smithy.DeserializationError{ 3183 Err: fmt.Errorf("failed to decode response body, %w", err), 3184 Snapshot: snapshot.Bytes(), 3185 } 3186 return err 3187 } 3188 3189 errorBody.Seek(0, io.SeekStart) 3190 if len(code) != 0 { 3191 errorCode = restjson.SanitizeErrorCode(code) 3192 } 3193 if len(message) != 0 { 3194 errorMessage = message 3195 } 3196 3197 switch { 3198 case strings.EqualFold("RequestError", errorCode): 3199 return awsAwsjson11_deserializeErrorRequestError(response, errorBody) 3200 3201 case strings.EqualFold("ServiceFault", errorCode): 3202 return awsAwsjson11_deserializeErrorServiceFault(response, errorBody) 3203 3204 default: 3205 genericError := &smithy.GenericAPIError{ 3206 Code: errorCode, 3207 Message: errorMessage, 3208 } 3209 return genericError 3210 3211 } 3212} 3213 3214type awsAwsjson11_deserializeOpListWorkersWithQualificationType struct { 3215} 3216 3217func (*awsAwsjson11_deserializeOpListWorkersWithQualificationType) ID() string { 3218 return "OperationDeserializer" 3219} 3220 3221func (m *awsAwsjson11_deserializeOpListWorkersWithQualificationType) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3222 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3223) { 3224 out, metadata, err = next.HandleDeserialize(ctx, in) 3225 if err != nil { 3226 return out, metadata, err 3227 } 3228 3229 response, ok := out.RawResponse.(*smithyhttp.Response) 3230 if !ok { 3231 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3232 } 3233 3234 if response.StatusCode < 200 || response.StatusCode >= 300 { 3235 return out, metadata, awsAwsjson11_deserializeOpErrorListWorkersWithQualificationType(response, &metadata) 3236 } 3237 output := &ListWorkersWithQualificationTypeOutput{} 3238 out.Result = output 3239 3240 var buff [1024]byte 3241 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3242 3243 body := io.TeeReader(response.Body, ringBuffer) 3244 decoder := json.NewDecoder(body) 3245 decoder.UseNumber() 3246 var shape interface{} 3247 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3248 var snapshot bytes.Buffer 3249 io.Copy(&snapshot, ringBuffer) 3250 err = &smithy.DeserializationError{ 3251 Err: fmt.Errorf("failed to decode response body, %w", err), 3252 Snapshot: snapshot.Bytes(), 3253 } 3254 return out, metadata, err 3255 } 3256 3257 err = awsAwsjson11_deserializeOpDocumentListWorkersWithQualificationTypeOutput(&output, shape) 3258 if err != nil { 3259 var snapshot bytes.Buffer 3260 io.Copy(&snapshot, ringBuffer) 3261 err = &smithy.DeserializationError{ 3262 Err: fmt.Errorf("failed to decode response body, %w", err), 3263 Snapshot: snapshot.Bytes(), 3264 } 3265 return out, metadata, err 3266 } 3267 3268 return out, metadata, err 3269} 3270 3271func awsAwsjson11_deserializeOpErrorListWorkersWithQualificationType(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3272 var errorBuffer bytes.Buffer 3273 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3274 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3275 } 3276 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3277 3278 errorCode := "UnknownError" 3279 errorMessage := errorCode 3280 3281 code := response.Header.Get("X-Amzn-ErrorType") 3282 if len(code) != 0 { 3283 errorCode = restjson.SanitizeErrorCode(code) 3284 } 3285 3286 var buff [1024]byte 3287 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3288 3289 body := io.TeeReader(errorBody, ringBuffer) 3290 decoder := json.NewDecoder(body) 3291 decoder.UseNumber() 3292 code, message, err := restjson.GetErrorInfo(decoder) 3293 if err != nil { 3294 var snapshot bytes.Buffer 3295 io.Copy(&snapshot, ringBuffer) 3296 err = &smithy.DeserializationError{ 3297 Err: fmt.Errorf("failed to decode response body, %w", err), 3298 Snapshot: snapshot.Bytes(), 3299 } 3300 return err 3301 } 3302 3303 errorBody.Seek(0, io.SeekStart) 3304 if len(code) != 0 { 3305 errorCode = restjson.SanitizeErrorCode(code) 3306 } 3307 if len(message) != 0 { 3308 errorMessage = message 3309 } 3310 3311 switch { 3312 case strings.EqualFold("RequestError", errorCode): 3313 return awsAwsjson11_deserializeErrorRequestError(response, errorBody) 3314 3315 case strings.EqualFold("ServiceFault", errorCode): 3316 return awsAwsjson11_deserializeErrorServiceFault(response, errorBody) 3317 3318 default: 3319 genericError := &smithy.GenericAPIError{ 3320 Code: errorCode, 3321 Message: errorMessage, 3322 } 3323 return genericError 3324 3325 } 3326} 3327 3328type awsAwsjson11_deserializeOpNotifyWorkers struct { 3329} 3330 3331func (*awsAwsjson11_deserializeOpNotifyWorkers) ID() string { 3332 return "OperationDeserializer" 3333} 3334 3335func (m *awsAwsjson11_deserializeOpNotifyWorkers) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3336 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3337) { 3338 out, metadata, err = next.HandleDeserialize(ctx, in) 3339 if err != nil { 3340 return out, metadata, err 3341 } 3342 3343 response, ok := out.RawResponse.(*smithyhttp.Response) 3344 if !ok { 3345 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3346 } 3347 3348 if response.StatusCode < 200 || response.StatusCode >= 300 { 3349 return out, metadata, awsAwsjson11_deserializeOpErrorNotifyWorkers(response, &metadata) 3350 } 3351 output := &NotifyWorkersOutput{} 3352 out.Result = output 3353 3354 var buff [1024]byte 3355 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3356 3357 body := io.TeeReader(response.Body, ringBuffer) 3358 decoder := json.NewDecoder(body) 3359 decoder.UseNumber() 3360 var shape interface{} 3361 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3362 var snapshot bytes.Buffer 3363 io.Copy(&snapshot, ringBuffer) 3364 err = &smithy.DeserializationError{ 3365 Err: fmt.Errorf("failed to decode response body, %w", err), 3366 Snapshot: snapshot.Bytes(), 3367 } 3368 return out, metadata, err 3369 } 3370 3371 err = awsAwsjson11_deserializeOpDocumentNotifyWorkersOutput(&output, shape) 3372 if err != nil { 3373 var snapshot bytes.Buffer 3374 io.Copy(&snapshot, ringBuffer) 3375 err = &smithy.DeserializationError{ 3376 Err: fmt.Errorf("failed to decode response body, %w", err), 3377 Snapshot: snapshot.Bytes(), 3378 } 3379 return out, metadata, err 3380 } 3381 3382 return out, metadata, err 3383} 3384 3385func awsAwsjson11_deserializeOpErrorNotifyWorkers(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3386 var errorBuffer bytes.Buffer 3387 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3388 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3389 } 3390 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3391 3392 errorCode := "UnknownError" 3393 errorMessage := errorCode 3394 3395 code := response.Header.Get("X-Amzn-ErrorType") 3396 if len(code) != 0 { 3397 errorCode = restjson.SanitizeErrorCode(code) 3398 } 3399 3400 var buff [1024]byte 3401 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3402 3403 body := io.TeeReader(errorBody, ringBuffer) 3404 decoder := json.NewDecoder(body) 3405 decoder.UseNumber() 3406 code, message, err := restjson.GetErrorInfo(decoder) 3407 if err != nil { 3408 var snapshot bytes.Buffer 3409 io.Copy(&snapshot, ringBuffer) 3410 err = &smithy.DeserializationError{ 3411 Err: fmt.Errorf("failed to decode response body, %w", err), 3412 Snapshot: snapshot.Bytes(), 3413 } 3414 return err 3415 } 3416 3417 errorBody.Seek(0, io.SeekStart) 3418 if len(code) != 0 { 3419 errorCode = restjson.SanitizeErrorCode(code) 3420 } 3421 if len(message) != 0 { 3422 errorMessage = message 3423 } 3424 3425 switch { 3426 case strings.EqualFold("RequestError", errorCode): 3427 return awsAwsjson11_deserializeErrorRequestError(response, errorBody) 3428 3429 case strings.EqualFold("ServiceFault", errorCode): 3430 return awsAwsjson11_deserializeErrorServiceFault(response, errorBody) 3431 3432 default: 3433 genericError := &smithy.GenericAPIError{ 3434 Code: errorCode, 3435 Message: errorMessage, 3436 } 3437 return genericError 3438 3439 } 3440} 3441 3442type awsAwsjson11_deserializeOpRejectAssignment struct { 3443} 3444 3445func (*awsAwsjson11_deserializeOpRejectAssignment) ID() string { 3446 return "OperationDeserializer" 3447} 3448 3449func (m *awsAwsjson11_deserializeOpRejectAssignment) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3450 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3451) { 3452 out, metadata, err = next.HandleDeserialize(ctx, in) 3453 if err != nil { 3454 return out, metadata, err 3455 } 3456 3457 response, ok := out.RawResponse.(*smithyhttp.Response) 3458 if !ok { 3459 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3460 } 3461 3462 if response.StatusCode < 200 || response.StatusCode >= 300 { 3463 return out, metadata, awsAwsjson11_deserializeOpErrorRejectAssignment(response, &metadata) 3464 } 3465 output := &RejectAssignmentOutput{} 3466 out.Result = output 3467 3468 var buff [1024]byte 3469 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3470 3471 body := io.TeeReader(response.Body, ringBuffer) 3472 decoder := json.NewDecoder(body) 3473 decoder.UseNumber() 3474 var shape interface{} 3475 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3476 var snapshot bytes.Buffer 3477 io.Copy(&snapshot, ringBuffer) 3478 err = &smithy.DeserializationError{ 3479 Err: fmt.Errorf("failed to decode response body, %w", err), 3480 Snapshot: snapshot.Bytes(), 3481 } 3482 return out, metadata, err 3483 } 3484 3485 err = awsAwsjson11_deserializeOpDocumentRejectAssignmentOutput(&output, shape) 3486 if err != nil { 3487 var snapshot bytes.Buffer 3488 io.Copy(&snapshot, ringBuffer) 3489 err = &smithy.DeserializationError{ 3490 Err: fmt.Errorf("failed to decode response body, %w", err), 3491 Snapshot: snapshot.Bytes(), 3492 } 3493 return out, metadata, err 3494 } 3495 3496 return out, metadata, err 3497} 3498 3499func awsAwsjson11_deserializeOpErrorRejectAssignment(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3500 var errorBuffer bytes.Buffer 3501 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3502 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3503 } 3504 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3505 3506 errorCode := "UnknownError" 3507 errorMessage := errorCode 3508 3509 code := response.Header.Get("X-Amzn-ErrorType") 3510 if len(code) != 0 { 3511 errorCode = restjson.SanitizeErrorCode(code) 3512 } 3513 3514 var buff [1024]byte 3515 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3516 3517 body := io.TeeReader(errorBody, ringBuffer) 3518 decoder := json.NewDecoder(body) 3519 decoder.UseNumber() 3520 code, message, err := restjson.GetErrorInfo(decoder) 3521 if err != nil { 3522 var snapshot bytes.Buffer 3523 io.Copy(&snapshot, ringBuffer) 3524 err = &smithy.DeserializationError{ 3525 Err: fmt.Errorf("failed to decode response body, %w", err), 3526 Snapshot: snapshot.Bytes(), 3527 } 3528 return err 3529 } 3530 3531 errorBody.Seek(0, io.SeekStart) 3532 if len(code) != 0 { 3533 errorCode = restjson.SanitizeErrorCode(code) 3534 } 3535 if len(message) != 0 { 3536 errorMessage = message 3537 } 3538 3539 switch { 3540 case strings.EqualFold("RequestError", errorCode): 3541 return awsAwsjson11_deserializeErrorRequestError(response, errorBody) 3542 3543 case strings.EqualFold("ServiceFault", errorCode): 3544 return awsAwsjson11_deserializeErrorServiceFault(response, errorBody) 3545 3546 default: 3547 genericError := &smithy.GenericAPIError{ 3548 Code: errorCode, 3549 Message: errorMessage, 3550 } 3551 return genericError 3552 3553 } 3554} 3555 3556type awsAwsjson11_deserializeOpRejectQualificationRequest struct { 3557} 3558 3559func (*awsAwsjson11_deserializeOpRejectQualificationRequest) ID() string { 3560 return "OperationDeserializer" 3561} 3562 3563func (m *awsAwsjson11_deserializeOpRejectQualificationRequest) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3564 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3565) { 3566 out, metadata, err = next.HandleDeserialize(ctx, in) 3567 if err != nil { 3568 return out, metadata, err 3569 } 3570 3571 response, ok := out.RawResponse.(*smithyhttp.Response) 3572 if !ok { 3573 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3574 } 3575 3576 if response.StatusCode < 200 || response.StatusCode >= 300 { 3577 return out, metadata, awsAwsjson11_deserializeOpErrorRejectQualificationRequest(response, &metadata) 3578 } 3579 output := &RejectQualificationRequestOutput{} 3580 out.Result = output 3581 3582 var buff [1024]byte 3583 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3584 3585 body := io.TeeReader(response.Body, ringBuffer) 3586 decoder := json.NewDecoder(body) 3587 decoder.UseNumber() 3588 var shape interface{} 3589 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3590 var snapshot bytes.Buffer 3591 io.Copy(&snapshot, ringBuffer) 3592 err = &smithy.DeserializationError{ 3593 Err: fmt.Errorf("failed to decode response body, %w", err), 3594 Snapshot: snapshot.Bytes(), 3595 } 3596 return out, metadata, err 3597 } 3598 3599 err = awsAwsjson11_deserializeOpDocumentRejectQualificationRequestOutput(&output, shape) 3600 if err != nil { 3601 var snapshot bytes.Buffer 3602 io.Copy(&snapshot, ringBuffer) 3603 err = &smithy.DeserializationError{ 3604 Err: fmt.Errorf("failed to decode response body, %w", err), 3605 Snapshot: snapshot.Bytes(), 3606 } 3607 return out, metadata, err 3608 } 3609 3610 return out, metadata, err 3611} 3612 3613func awsAwsjson11_deserializeOpErrorRejectQualificationRequest(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3614 var errorBuffer bytes.Buffer 3615 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3616 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3617 } 3618 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3619 3620 errorCode := "UnknownError" 3621 errorMessage := errorCode 3622 3623 code := response.Header.Get("X-Amzn-ErrorType") 3624 if len(code) != 0 { 3625 errorCode = restjson.SanitizeErrorCode(code) 3626 } 3627 3628 var buff [1024]byte 3629 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3630 3631 body := io.TeeReader(errorBody, ringBuffer) 3632 decoder := json.NewDecoder(body) 3633 decoder.UseNumber() 3634 code, message, err := restjson.GetErrorInfo(decoder) 3635 if err != nil { 3636 var snapshot bytes.Buffer 3637 io.Copy(&snapshot, ringBuffer) 3638 err = &smithy.DeserializationError{ 3639 Err: fmt.Errorf("failed to decode response body, %w", err), 3640 Snapshot: snapshot.Bytes(), 3641 } 3642 return err 3643 } 3644 3645 errorBody.Seek(0, io.SeekStart) 3646 if len(code) != 0 { 3647 errorCode = restjson.SanitizeErrorCode(code) 3648 } 3649 if len(message) != 0 { 3650 errorMessage = message 3651 } 3652 3653 switch { 3654 case strings.EqualFold("RequestError", errorCode): 3655 return awsAwsjson11_deserializeErrorRequestError(response, errorBody) 3656 3657 case strings.EqualFold("ServiceFault", errorCode): 3658 return awsAwsjson11_deserializeErrorServiceFault(response, errorBody) 3659 3660 default: 3661 genericError := &smithy.GenericAPIError{ 3662 Code: errorCode, 3663 Message: errorMessage, 3664 } 3665 return genericError 3666 3667 } 3668} 3669 3670type awsAwsjson11_deserializeOpSendBonus struct { 3671} 3672 3673func (*awsAwsjson11_deserializeOpSendBonus) ID() string { 3674 return "OperationDeserializer" 3675} 3676 3677func (m *awsAwsjson11_deserializeOpSendBonus) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3678 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3679) { 3680 out, metadata, err = next.HandleDeserialize(ctx, in) 3681 if err != nil { 3682 return out, metadata, err 3683 } 3684 3685 response, ok := out.RawResponse.(*smithyhttp.Response) 3686 if !ok { 3687 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3688 } 3689 3690 if response.StatusCode < 200 || response.StatusCode >= 300 { 3691 return out, metadata, awsAwsjson11_deserializeOpErrorSendBonus(response, &metadata) 3692 } 3693 output := &SendBonusOutput{} 3694 out.Result = output 3695 3696 var buff [1024]byte 3697 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3698 3699 body := io.TeeReader(response.Body, ringBuffer) 3700 decoder := json.NewDecoder(body) 3701 decoder.UseNumber() 3702 var shape interface{} 3703 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3704 var snapshot bytes.Buffer 3705 io.Copy(&snapshot, ringBuffer) 3706 err = &smithy.DeserializationError{ 3707 Err: fmt.Errorf("failed to decode response body, %w", err), 3708 Snapshot: snapshot.Bytes(), 3709 } 3710 return out, metadata, err 3711 } 3712 3713 err = awsAwsjson11_deserializeOpDocumentSendBonusOutput(&output, shape) 3714 if err != nil { 3715 var snapshot bytes.Buffer 3716 io.Copy(&snapshot, ringBuffer) 3717 err = &smithy.DeserializationError{ 3718 Err: fmt.Errorf("failed to decode response body, %w", err), 3719 Snapshot: snapshot.Bytes(), 3720 } 3721 return out, metadata, err 3722 } 3723 3724 return out, metadata, err 3725} 3726 3727func awsAwsjson11_deserializeOpErrorSendBonus(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3728 var errorBuffer bytes.Buffer 3729 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3730 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3731 } 3732 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3733 3734 errorCode := "UnknownError" 3735 errorMessage := errorCode 3736 3737 code := response.Header.Get("X-Amzn-ErrorType") 3738 if len(code) != 0 { 3739 errorCode = restjson.SanitizeErrorCode(code) 3740 } 3741 3742 var buff [1024]byte 3743 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3744 3745 body := io.TeeReader(errorBody, ringBuffer) 3746 decoder := json.NewDecoder(body) 3747 decoder.UseNumber() 3748 code, message, err := restjson.GetErrorInfo(decoder) 3749 if err != nil { 3750 var snapshot bytes.Buffer 3751 io.Copy(&snapshot, ringBuffer) 3752 err = &smithy.DeserializationError{ 3753 Err: fmt.Errorf("failed to decode response body, %w", err), 3754 Snapshot: snapshot.Bytes(), 3755 } 3756 return err 3757 } 3758 3759 errorBody.Seek(0, io.SeekStart) 3760 if len(code) != 0 { 3761 errorCode = restjson.SanitizeErrorCode(code) 3762 } 3763 if len(message) != 0 { 3764 errorMessage = message 3765 } 3766 3767 switch { 3768 case strings.EqualFold("RequestError", errorCode): 3769 return awsAwsjson11_deserializeErrorRequestError(response, errorBody) 3770 3771 case strings.EqualFold("ServiceFault", errorCode): 3772 return awsAwsjson11_deserializeErrorServiceFault(response, errorBody) 3773 3774 default: 3775 genericError := &smithy.GenericAPIError{ 3776 Code: errorCode, 3777 Message: errorMessage, 3778 } 3779 return genericError 3780 3781 } 3782} 3783 3784type awsAwsjson11_deserializeOpSendTestEventNotification struct { 3785} 3786 3787func (*awsAwsjson11_deserializeOpSendTestEventNotification) ID() string { 3788 return "OperationDeserializer" 3789} 3790 3791func (m *awsAwsjson11_deserializeOpSendTestEventNotification) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3792 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3793) { 3794 out, metadata, err = next.HandleDeserialize(ctx, in) 3795 if err != nil { 3796 return out, metadata, err 3797 } 3798 3799 response, ok := out.RawResponse.(*smithyhttp.Response) 3800 if !ok { 3801 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3802 } 3803 3804 if response.StatusCode < 200 || response.StatusCode >= 300 { 3805 return out, metadata, awsAwsjson11_deserializeOpErrorSendTestEventNotification(response, &metadata) 3806 } 3807 output := &SendTestEventNotificationOutput{} 3808 out.Result = output 3809 3810 var buff [1024]byte 3811 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3812 3813 body := io.TeeReader(response.Body, ringBuffer) 3814 decoder := json.NewDecoder(body) 3815 decoder.UseNumber() 3816 var shape interface{} 3817 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3818 var snapshot bytes.Buffer 3819 io.Copy(&snapshot, ringBuffer) 3820 err = &smithy.DeserializationError{ 3821 Err: fmt.Errorf("failed to decode response body, %w", err), 3822 Snapshot: snapshot.Bytes(), 3823 } 3824 return out, metadata, err 3825 } 3826 3827 err = awsAwsjson11_deserializeOpDocumentSendTestEventNotificationOutput(&output, shape) 3828 if err != nil { 3829 var snapshot bytes.Buffer 3830 io.Copy(&snapshot, ringBuffer) 3831 err = &smithy.DeserializationError{ 3832 Err: fmt.Errorf("failed to decode response body, %w", err), 3833 Snapshot: snapshot.Bytes(), 3834 } 3835 return out, metadata, err 3836 } 3837 3838 return out, metadata, err 3839} 3840 3841func awsAwsjson11_deserializeOpErrorSendTestEventNotification(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3842 var errorBuffer bytes.Buffer 3843 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3844 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3845 } 3846 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3847 3848 errorCode := "UnknownError" 3849 errorMessage := errorCode 3850 3851 code := response.Header.Get("X-Amzn-ErrorType") 3852 if len(code) != 0 { 3853 errorCode = restjson.SanitizeErrorCode(code) 3854 } 3855 3856 var buff [1024]byte 3857 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3858 3859 body := io.TeeReader(errorBody, ringBuffer) 3860 decoder := json.NewDecoder(body) 3861 decoder.UseNumber() 3862 code, message, err := restjson.GetErrorInfo(decoder) 3863 if err != nil { 3864 var snapshot bytes.Buffer 3865 io.Copy(&snapshot, ringBuffer) 3866 err = &smithy.DeserializationError{ 3867 Err: fmt.Errorf("failed to decode response body, %w", err), 3868 Snapshot: snapshot.Bytes(), 3869 } 3870 return err 3871 } 3872 3873 errorBody.Seek(0, io.SeekStart) 3874 if len(code) != 0 { 3875 errorCode = restjson.SanitizeErrorCode(code) 3876 } 3877 if len(message) != 0 { 3878 errorMessage = message 3879 } 3880 3881 switch { 3882 case strings.EqualFold("RequestError", errorCode): 3883 return awsAwsjson11_deserializeErrorRequestError(response, errorBody) 3884 3885 case strings.EqualFold("ServiceFault", errorCode): 3886 return awsAwsjson11_deserializeErrorServiceFault(response, errorBody) 3887 3888 default: 3889 genericError := &smithy.GenericAPIError{ 3890 Code: errorCode, 3891 Message: errorMessage, 3892 } 3893 return genericError 3894 3895 } 3896} 3897 3898type awsAwsjson11_deserializeOpUpdateExpirationForHIT struct { 3899} 3900 3901func (*awsAwsjson11_deserializeOpUpdateExpirationForHIT) ID() string { 3902 return "OperationDeserializer" 3903} 3904 3905func (m *awsAwsjson11_deserializeOpUpdateExpirationForHIT) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3906 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3907) { 3908 out, metadata, err = next.HandleDeserialize(ctx, in) 3909 if err != nil { 3910 return out, metadata, err 3911 } 3912 3913 response, ok := out.RawResponse.(*smithyhttp.Response) 3914 if !ok { 3915 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3916 } 3917 3918 if response.StatusCode < 200 || response.StatusCode >= 300 { 3919 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateExpirationForHIT(response, &metadata) 3920 } 3921 output := &UpdateExpirationForHITOutput{} 3922 out.Result = output 3923 3924 var buff [1024]byte 3925 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3926 3927 body := io.TeeReader(response.Body, ringBuffer) 3928 decoder := json.NewDecoder(body) 3929 decoder.UseNumber() 3930 var shape interface{} 3931 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3932 var snapshot bytes.Buffer 3933 io.Copy(&snapshot, ringBuffer) 3934 err = &smithy.DeserializationError{ 3935 Err: fmt.Errorf("failed to decode response body, %w", err), 3936 Snapshot: snapshot.Bytes(), 3937 } 3938 return out, metadata, err 3939 } 3940 3941 err = awsAwsjson11_deserializeOpDocumentUpdateExpirationForHITOutput(&output, shape) 3942 if err != nil { 3943 var snapshot bytes.Buffer 3944 io.Copy(&snapshot, ringBuffer) 3945 err = &smithy.DeserializationError{ 3946 Err: fmt.Errorf("failed to decode response body, %w", err), 3947 Snapshot: snapshot.Bytes(), 3948 } 3949 return out, metadata, err 3950 } 3951 3952 return out, metadata, err 3953} 3954 3955func awsAwsjson11_deserializeOpErrorUpdateExpirationForHIT(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3956 var errorBuffer bytes.Buffer 3957 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3958 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3959 } 3960 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3961 3962 errorCode := "UnknownError" 3963 errorMessage := errorCode 3964 3965 code := response.Header.Get("X-Amzn-ErrorType") 3966 if len(code) != 0 { 3967 errorCode = restjson.SanitizeErrorCode(code) 3968 } 3969 3970 var buff [1024]byte 3971 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3972 3973 body := io.TeeReader(errorBody, ringBuffer) 3974 decoder := json.NewDecoder(body) 3975 decoder.UseNumber() 3976 code, message, err := restjson.GetErrorInfo(decoder) 3977 if err != nil { 3978 var snapshot bytes.Buffer 3979 io.Copy(&snapshot, ringBuffer) 3980 err = &smithy.DeserializationError{ 3981 Err: fmt.Errorf("failed to decode response body, %w", err), 3982 Snapshot: snapshot.Bytes(), 3983 } 3984 return err 3985 } 3986 3987 errorBody.Seek(0, io.SeekStart) 3988 if len(code) != 0 { 3989 errorCode = restjson.SanitizeErrorCode(code) 3990 } 3991 if len(message) != 0 { 3992 errorMessage = message 3993 } 3994 3995 switch { 3996 case strings.EqualFold("RequestError", errorCode): 3997 return awsAwsjson11_deserializeErrorRequestError(response, errorBody) 3998 3999 case strings.EqualFold("ServiceFault", errorCode): 4000 return awsAwsjson11_deserializeErrorServiceFault(response, errorBody) 4001 4002 default: 4003 genericError := &smithy.GenericAPIError{ 4004 Code: errorCode, 4005 Message: errorMessage, 4006 } 4007 return genericError 4008 4009 } 4010} 4011 4012type awsAwsjson11_deserializeOpUpdateHITReviewStatus struct { 4013} 4014 4015func (*awsAwsjson11_deserializeOpUpdateHITReviewStatus) ID() string { 4016 return "OperationDeserializer" 4017} 4018 4019func (m *awsAwsjson11_deserializeOpUpdateHITReviewStatus) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4020 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4021) { 4022 out, metadata, err = next.HandleDeserialize(ctx, in) 4023 if err != nil { 4024 return out, metadata, err 4025 } 4026 4027 response, ok := out.RawResponse.(*smithyhttp.Response) 4028 if !ok { 4029 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4030 } 4031 4032 if response.StatusCode < 200 || response.StatusCode >= 300 { 4033 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateHITReviewStatus(response, &metadata) 4034 } 4035 output := &UpdateHITReviewStatusOutput{} 4036 out.Result = output 4037 4038 var buff [1024]byte 4039 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4040 4041 body := io.TeeReader(response.Body, ringBuffer) 4042 decoder := json.NewDecoder(body) 4043 decoder.UseNumber() 4044 var shape interface{} 4045 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4046 var snapshot bytes.Buffer 4047 io.Copy(&snapshot, ringBuffer) 4048 err = &smithy.DeserializationError{ 4049 Err: fmt.Errorf("failed to decode response body, %w", err), 4050 Snapshot: snapshot.Bytes(), 4051 } 4052 return out, metadata, err 4053 } 4054 4055 err = awsAwsjson11_deserializeOpDocumentUpdateHITReviewStatusOutput(&output, shape) 4056 if err != nil { 4057 var snapshot bytes.Buffer 4058 io.Copy(&snapshot, ringBuffer) 4059 err = &smithy.DeserializationError{ 4060 Err: fmt.Errorf("failed to decode response body, %w", err), 4061 Snapshot: snapshot.Bytes(), 4062 } 4063 return out, metadata, err 4064 } 4065 4066 return out, metadata, err 4067} 4068 4069func awsAwsjson11_deserializeOpErrorUpdateHITReviewStatus(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4070 var errorBuffer bytes.Buffer 4071 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4072 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4073 } 4074 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4075 4076 errorCode := "UnknownError" 4077 errorMessage := errorCode 4078 4079 code := response.Header.Get("X-Amzn-ErrorType") 4080 if len(code) != 0 { 4081 errorCode = restjson.SanitizeErrorCode(code) 4082 } 4083 4084 var buff [1024]byte 4085 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4086 4087 body := io.TeeReader(errorBody, ringBuffer) 4088 decoder := json.NewDecoder(body) 4089 decoder.UseNumber() 4090 code, message, err := restjson.GetErrorInfo(decoder) 4091 if err != nil { 4092 var snapshot bytes.Buffer 4093 io.Copy(&snapshot, ringBuffer) 4094 err = &smithy.DeserializationError{ 4095 Err: fmt.Errorf("failed to decode response body, %w", err), 4096 Snapshot: snapshot.Bytes(), 4097 } 4098 return err 4099 } 4100 4101 errorBody.Seek(0, io.SeekStart) 4102 if len(code) != 0 { 4103 errorCode = restjson.SanitizeErrorCode(code) 4104 } 4105 if len(message) != 0 { 4106 errorMessage = message 4107 } 4108 4109 switch { 4110 case strings.EqualFold("RequestError", errorCode): 4111 return awsAwsjson11_deserializeErrorRequestError(response, errorBody) 4112 4113 case strings.EqualFold("ServiceFault", errorCode): 4114 return awsAwsjson11_deserializeErrorServiceFault(response, errorBody) 4115 4116 default: 4117 genericError := &smithy.GenericAPIError{ 4118 Code: errorCode, 4119 Message: errorMessage, 4120 } 4121 return genericError 4122 4123 } 4124} 4125 4126type awsAwsjson11_deserializeOpUpdateHITTypeOfHIT struct { 4127} 4128 4129func (*awsAwsjson11_deserializeOpUpdateHITTypeOfHIT) ID() string { 4130 return "OperationDeserializer" 4131} 4132 4133func (m *awsAwsjson11_deserializeOpUpdateHITTypeOfHIT) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4134 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4135) { 4136 out, metadata, err = next.HandleDeserialize(ctx, in) 4137 if err != nil { 4138 return out, metadata, err 4139 } 4140 4141 response, ok := out.RawResponse.(*smithyhttp.Response) 4142 if !ok { 4143 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4144 } 4145 4146 if response.StatusCode < 200 || response.StatusCode >= 300 { 4147 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateHITTypeOfHIT(response, &metadata) 4148 } 4149 output := &UpdateHITTypeOfHITOutput{} 4150 out.Result = output 4151 4152 var buff [1024]byte 4153 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4154 4155 body := io.TeeReader(response.Body, ringBuffer) 4156 decoder := json.NewDecoder(body) 4157 decoder.UseNumber() 4158 var shape interface{} 4159 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4160 var snapshot bytes.Buffer 4161 io.Copy(&snapshot, ringBuffer) 4162 err = &smithy.DeserializationError{ 4163 Err: fmt.Errorf("failed to decode response body, %w", err), 4164 Snapshot: snapshot.Bytes(), 4165 } 4166 return out, metadata, err 4167 } 4168 4169 err = awsAwsjson11_deserializeOpDocumentUpdateHITTypeOfHITOutput(&output, shape) 4170 if err != nil { 4171 var snapshot bytes.Buffer 4172 io.Copy(&snapshot, ringBuffer) 4173 err = &smithy.DeserializationError{ 4174 Err: fmt.Errorf("failed to decode response body, %w", err), 4175 Snapshot: snapshot.Bytes(), 4176 } 4177 return out, metadata, err 4178 } 4179 4180 return out, metadata, err 4181} 4182 4183func awsAwsjson11_deserializeOpErrorUpdateHITTypeOfHIT(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4184 var errorBuffer bytes.Buffer 4185 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4186 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4187 } 4188 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4189 4190 errorCode := "UnknownError" 4191 errorMessage := errorCode 4192 4193 code := response.Header.Get("X-Amzn-ErrorType") 4194 if len(code) != 0 { 4195 errorCode = restjson.SanitizeErrorCode(code) 4196 } 4197 4198 var buff [1024]byte 4199 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4200 4201 body := io.TeeReader(errorBody, ringBuffer) 4202 decoder := json.NewDecoder(body) 4203 decoder.UseNumber() 4204 code, message, err := restjson.GetErrorInfo(decoder) 4205 if err != nil { 4206 var snapshot bytes.Buffer 4207 io.Copy(&snapshot, ringBuffer) 4208 err = &smithy.DeserializationError{ 4209 Err: fmt.Errorf("failed to decode response body, %w", err), 4210 Snapshot: snapshot.Bytes(), 4211 } 4212 return err 4213 } 4214 4215 errorBody.Seek(0, io.SeekStart) 4216 if len(code) != 0 { 4217 errorCode = restjson.SanitizeErrorCode(code) 4218 } 4219 if len(message) != 0 { 4220 errorMessage = message 4221 } 4222 4223 switch { 4224 case strings.EqualFold("RequestError", errorCode): 4225 return awsAwsjson11_deserializeErrorRequestError(response, errorBody) 4226 4227 case strings.EqualFold("ServiceFault", errorCode): 4228 return awsAwsjson11_deserializeErrorServiceFault(response, errorBody) 4229 4230 default: 4231 genericError := &smithy.GenericAPIError{ 4232 Code: errorCode, 4233 Message: errorMessage, 4234 } 4235 return genericError 4236 4237 } 4238} 4239 4240type awsAwsjson11_deserializeOpUpdateNotificationSettings struct { 4241} 4242 4243func (*awsAwsjson11_deserializeOpUpdateNotificationSettings) ID() string { 4244 return "OperationDeserializer" 4245} 4246 4247func (m *awsAwsjson11_deserializeOpUpdateNotificationSettings) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4248 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4249) { 4250 out, metadata, err = next.HandleDeserialize(ctx, in) 4251 if err != nil { 4252 return out, metadata, err 4253 } 4254 4255 response, ok := out.RawResponse.(*smithyhttp.Response) 4256 if !ok { 4257 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4258 } 4259 4260 if response.StatusCode < 200 || response.StatusCode >= 300 { 4261 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateNotificationSettings(response, &metadata) 4262 } 4263 output := &UpdateNotificationSettingsOutput{} 4264 out.Result = output 4265 4266 var buff [1024]byte 4267 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4268 4269 body := io.TeeReader(response.Body, ringBuffer) 4270 decoder := json.NewDecoder(body) 4271 decoder.UseNumber() 4272 var shape interface{} 4273 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4274 var snapshot bytes.Buffer 4275 io.Copy(&snapshot, ringBuffer) 4276 err = &smithy.DeserializationError{ 4277 Err: fmt.Errorf("failed to decode response body, %w", err), 4278 Snapshot: snapshot.Bytes(), 4279 } 4280 return out, metadata, err 4281 } 4282 4283 err = awsAwsjson11_deserializeOpDocumentUpdateNotificationSettingsOutput(&output, shape) 4284 if err != nil { 4285 var snapshot bytes.Buffer 4286 io.Copy(&snapshot, ringBuffer) 4287 err = &smithy.DeserializationError{ 4288 Err: fmt.Errorf("failed to decode response body, %w", err), 4289 Snapshot: snapshot.Bytes(), 4290 } 4291 return out, metadata, err 4292 } 4293 4294 return out, metadata, err 4295} 4296 4297func awsAwsjson11_deserializeOpErrorUpdateNotificationSettings(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4298 var errorBuffer bytes.Buffer 4299 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4300 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4301 } 4302 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4303 4304 errorCode := "UnknownError" 4305 errorMessage := errorCode 4306 4307 code := response.Header.Get("X-Amzn-ErrorType") 4308 if len(code) != 0 { 4309 errorCode = restjson.SanitizeErrorCode(code) 4310 } 4311 4312 var buff [1024]byte 4313 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4314 4315 body := io.TeeReader(errorBody, ringBuffer) 4316 decoder := json.NewDecoder(body) 4317 decoder.UseNumber() 4318 code, message, err := restjson.GetErrorInfo(decoder) 4319 if err != nil { 4320 var snapshot bytes.Buffer 4321 io.Copy(&snapshot, ringBuffer) 4322 err = &smithy.DeserializationError{ 4323 Err: fmt.Errorf("failed to decode response body, %w", err), 4324 Snapshot: snapshot.Bytes(), 4325 } 4326 return err 4327 } 4328 4329 errorBody.Seek(0, io.SeekStart) 4330 if len(code) != 0 { 4331 errorCode = restjson.SanitizeErrorCode(code) 4332 } 4333 if len(message) != 0 { 4334 errorMessage = message 4335 } 4336 4337 switch { 4338 case strings.EqualFold("RequestError", errorCode): 4339 return awsAwsjson11_deserializeErrorRequestError(response, errorBody) 4340 4341 case strings.EqualFold("ServiceFault", errorCode): 4342 return awsAwsjson11_deserializeErrorServiceFault(response, errorBody) 4343 4344 default: 4345 genericError := &smithy.GenericAPIError{ 4346 Code: errorCode, 4347 Message: errorMessage, 4348 } 4349 return genericError 4350 4351 } 4352} 4353 4354type awsAwsjson11_deserializeOpUpdateQualificationType struct { 4355} 4356 4357func (*awsAwsjson11_deserializeOpUpdateQualificationType) ID() string { 4358 return "OperationDeserializer" 4359} 4360 4361func (m *awsAwsjson11_deserializeOpUpdateQualificationType) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4362 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4363) { 4364 out, metadata, err = next.HandleDeserialize(ctx, in) 4365 if err != nil { 4366 return out, metadata, err 4367 } 4368 4369 response, ok := out.RawResponse.(*smithyhttp.Response) 4370 if !ok { 4371 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4372 } 4373 4374 if response.StatusCode < 200 || response.StatusCode >= 300 { 4375 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateQualificationType(response, &metadata) 4376 } 4377 output := &UpdateQualificationTypeOutput{} 4378 out.Result = output 4379 4380 var buff [1024]byte 4381 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4382 4383 body := io.TeeReader(response.Body, ringBuffer) 4384 decoder := json.NewDecoder(body) 4385 decoder.UseNumber() 4386 var shape interface{} 4387 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4388 var snapshot bytes.Buffer 4389 io.Copy(&snapshot, ringBuffer) 4390 err = &smithy.DeserializationError{ 4391 Err: fmt.Errorf("failed to decode response body, %w", err), 4392 Snapshot: snapshot.Bytes(), 4393 } 4394 return out, metadata, err 4395 } 4396 4397 err = awsAwsjson11_deserializeOpDocumentUpdateQualificationTypeOutput(&output, shape) 4398 if err != nil { 4399 var snapshot bytes.Buffer 4400 io.Copy(&snapshot, ringBuffer) 4401 err = &smithy.DeserializationError{ 4402 Err: fmt.Errorf("failed to decode response body, %w", err), 4403 Snapshot: snapshot.Bytes(), 4404 } 4405 return out, metadata, err 4406 } 4407 4408 return out, metadata, err 4409} 4410 4411func awsAwsjson11_deserializeOpErrorUpdateQualificationType(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4412 var errorBuffer bytes.Buffer 4413 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4414 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4415 } 4416 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4417 4418 errorCode := "UnknownError" 4419 errorMessage := errorCode 4420 4421 code := response.Header.Get("X-Amzn-ErrorType") 4422 if len(code) != 0 { 4423 errorCode = restjson.SanitizeErrorCode(code) 4424 } 4425 4426 var buff [1024]byte 4427 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4428 4429 body := io.TeeReader(errorBody, ringBuffer) 4430 decoder := json.NewDecoder(body) 4431 decoder.UseNumber() 4432 code, message, err := restjson.GetErrorInfo(decoder) 4433 if err != nil { 4434 var snapshot bytes.Buffer 4435 io.Copy(&snapshot, ringBuffer) 4436 err = &smithy.DeserializationError{ 4437 Err: fmt.Errorf("failed to decode response body, %w", err), 4438 Snapshot: snapshot.Bytes(), 4439 } 4440 return err 4441 } 4442 4443 errorBody.Seek(0, io.SeekStart) 4444 if len(code) != 0 { 4445 errorCode = restjson.SanitizeErrorCode(code) 4446 } 4447 if len(message) != 0 { 4448 errorMessage = message 4449 } 4450 4451 switch { 4452 case strings.EqualFold("RequestError", errorCode): 4453 return awsAwsjson11_deserializeErrorRequestError(response, errorBody) 4454 4455 case strings.EqualFold("ServiceFault", errorCode): 4456 return awsAwsjson11_deserializeErrorServiceFault(response, errorBody) 4457 4458 default: 4459 genericError := &smithy.GenericAPIError{ 4460 Code: errorCode, 4461 Message: errorMessage, 4462 } 4463 return genericError 4464 4465 } 4466} 4467 4468func awsAwsjson11_deserializeErrorRequestError(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4469 var buff [1024]byte 4470 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4471 4472 body := io.TeeReader(errorBody, ringBuffer) 4473 decoder := json.NewDecoder(body) 4474 decoder.UseNumber() 4475 var shape interface{} 4476 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4477 var snapshot bytes.Buffer 4478 io.Copy(&snapshot, ringBuffer) 4479 err = &smithy.DeserializationError{ 4480 Err: fmt.Errorf("failed to decode response body, %w", err), 4481 Snapshot: snapshot.Bytes(), 4482 } 4483 return err 4484 } 4485 4486 output := &types.RequestError{} 4487 err := awsAwsjson11_deserializeDocumentRequestError(&output, shape) 4488 4489 if err != nil { 4490 var snapshot bytes.Buffer 4491 io.Copy(&snapshot, ringBuffer) 4492 err = &smithy.DeserializationError{ 4493 Err: fmt.Errorf("failed to decode response body, %w", err), 4494 Snapshot: snapshot.Bytes(), 4495 } 4496 return err 4497 } 4498 4499 errorBody.Seek(0, io.SeekStart) 4500 return output 4501} 4502 4503func awsAwsjson11_deserializeErrorServiceFault(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4504 var buff [1024]byte 4505 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4506 4507 body := io.TeeReader(errorBody, ringBuffer) 4508 decoder := json.NewDecoder(body) 4509 decoder.UseNumber() 4510 var shape interface{} 4511 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4512 var snapshot bytes.Buffer 4513 io.Copy(&snapshot, ringBuffer) 4514 err = &smithy.DeserializationError{ 4515 Err: fmt.Errorf("failed to decode response body, %w", err), 4516 Snapshot: snapshot.Bytes(), 4517 } 4518 return err 4519 } 4520 4521 output := &types.ServiceFault{} 4522 err := awsAwsjson11_deserializeDocumentServiceFault(&output, shape) 4523 4524 if err != nil { 4525 var snapshot bytes.Buffer 4526 io.Copy(&snapshot, ringBuffer) 4527 err = &smithy.DeserializationError{ 4528 Err: fmt.Errorf("failed to decode response body, %w", err), 4529 Snapshot: snapshot.Bytes(), 4530 } 4531 return err 4532 } 4533 4534 errorBody.Seek(0, io.SeekStart) 4535 return output 4536} 4537 4538func awsAwsjson11_deserializeDocumentAssignment(v **types.Assignment, value interface{}) error { 4539 if v == nil { 4540 return fmt.Errorf("unexpected nil of type %T", v) 4541 } 4542 if value == nil { 4543 return nil 4544 } 4545 4546 shape, ok := value.(map[string]interface{}) 4547 if !ok { 4548 return fmt.Errorf("unexpected JSON type %v", value) 4549 } 4550 4551 var sv *types.Assignment 4552 if *v == nil { 4553 sv = &types.Assignment{} 4554 } else { 4555 sv = *v 4556 } 4557 4558 for key, value := range shape { 4559 switch key { 4560 case "AcceptTime": 4561 if value != nil { 4562 switch jtv := value.(type) { 4563 case json.Number: 4564 f64, err := jtv.Float64() 4565 if err != nil { 4566 return err 4567 } 4568 sv.AcceptTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 4569 4570 default: 4571 return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value) 4572 4573 } 4574 } 4575 4576 case "Answer": 4577 if value != nil { 4578 jtv, ok := value.(string) 4579 if !ok { 4580 return fmt.Errorf("expected String to be of type string, got %T instead", value) 4581 } 4582 sv.Answer = ptr.String(jtv) 4583 } 4584 4585 case "ApprovalTime": 4586 if value != nil { 4587 switch jtv := value.(type) { 4588 case json.Number: 4589 f64, err := jtv.Float64() 4590 if err != nil { 4591 return err 4592 } 4593 sv.ApprovalTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 4594 4595 default: 4596 return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value) 4597 4598 } 4599 } 4600 4601 case "AssignmentId": 4602 if value != nil { 4603 jtv, ok := value.(string) 4604 if !ok { 4605 return fmt.Errorf("expected EntityId to be of type string, got %T instead", value) 4606 } 4607 sv.AssignmentId = ptr.String(jtv) 4608 } 4609 4610 case "AssignmentStatus": 4611 if value != nil { 4612 jtv, ok := value.(string) 4613 if !ok { 4614 return fmt.Errorf("expected AssignmentStatus to be of type string, got %T instead", value) 4615 } 4616 sv.AssignmentStatus = types.AssignmentStatus(jtv) 4617 } 4618 4619 case "AutoApprovalTime": 4620 if value != nil { 4621 switch jtv := value.(type) { 4622 case json.Number: 4623 f64, err := jtv.Float64() 4624 if err != nil { 4625 return err 4626 } 4627 sv.AutoApprovalTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 4628 4629 default: 4630 return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value) 4631 4632 } 4633 } 4634 4635 case "Deadline": 4636 if value != nil { 4637 switch jtv := value.(type) { 4638 case json.Number: 4639 f64, err := jtv.Float64() 4640 if err != nil { 4641 return err 4642 } 4643 sv.Deadline = ptr.Time(smithytime.ParseEpochSeconds(f64)) 4644 4645 default: 4646 return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value) 4647 4648 } 4649 } 4650 4651 case "HITId": 4652 if value != nil { 4653 jtv, ok := value.(string) 4654 if !ok { 4655 return fmt.Errorf("expected EntityId to be of type string, got %T instead", value) 4656 } 4657 sv.HITId = ptr.String(jtv) 4658 } 4659 4660 case "RejectionTime": 4661 if value != nil { 4662 switch jtv := value.(type) { 4663 case json.Number: 4664 f64, err := jtv.Float64() 4665 if err != nil { 4666 return err 4667 } 4668 sv.RejectionTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 4669 4670 default: 4671 return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value) 4672 4673 } 4674 } 4675 4676 case "RequesterFeedback": 4677 if value != nil { 4678 jtv, ok := value.(string) 4679 if !ok { 4680 return fmt.Errorf("expected String to be of type string, got %T instead", value) 4681 } 4682 sv.RequesterFeedback = ptr.String(jtv) 4683 } 4684 4685 case "SubmitTime": 4686 if value != nil { 4687 switch jtv := value.(type) { 4688 case json.Number: 4689 f64, err := jtv.Float64() 4690 if err != nil { 4691 return err 4692 } 4693 sv.SubmitTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 4694 4695 default: 4696 return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value) 4697 4698 } 4699 } 4700 4701 case "WorkerId": 4702 if value != nil { 4703 jtv, ok := value.(string) 4704 if !ok { 4705 return fmt.Errorf("expected CustomerId to be of type string, got %T instead", value) 4706 } 4707 sv.WorkerId = ptr.String(jtv) 4708 } 4709 4710 default: 4711 _, _ = key, value 4712 4713 } 4714 } 4715 *v = sv 4716 return nil 4717} 4718 4719func awsAwsjson11_deserializeDocumentAssignmentList(v *[]types.Assignment, value interface{}) error { 4720 if v == nil { 4721 return fmt.Errorf("unexpected nil of type %T", v) 4722 } 4723 if value == nil { 4724 return nil 4725 } 4726 4727 shape, ok := value.([]interface{}) 4728 if !ok { 4729 return fmt.Errorf("unexpected JSON type %v", value) 4730 } 4731 4732 var cv []types.Assignment 4733 if *v == nil { 4734 cv = []types.Assignment{} 4735 } else { 4736 cv = *v 4737 } 4738 4739 for _, value := range shape { 4740 var col types.Assignment 4741 destAddr := &col 4742 if err := awsAwsjson11_deserializeDocumentAssignment(&destAddr, value); err != nil { 4743 return err 4744 } 4745 col = *destAddr 4746 cv = append(cv, col) 4747 4748 } 4749 *v = cv 4750 return nil 4751} 4752 4753func awsAwsjson11_deserializeDocumentBonusPayment(v **types.BonusPayment, value interface{}) error { 4754 if v == nil { 4755 return fmt.Errorf("unexpected nil of type %T", v) 4756 } 4757 if value == nil { 4758 return nil 4759 } 4760 4761 shape, ok := value.(map[string]interface{}) 4762 if !ok { 4763 return fmt.Errorf("unexpected JSON type %v", value) 4764 } 4765 4766 var sv *types.BonusPayment 4767 if *v == nil { 4768 sv = &types.BonusPayment{} 4769 } else { 4770 sv = *v 4771 } 4772 4773 for key, value := range shape { 4774 switch key { 4775 case "AssignmentId": 4776 if value != nil { 4777 jtv, ok := value.(string) 4778 if !ok { 4779 return fmt.Errorf("expected EntityId to be of type string, got %T instead", value) 4780 } 4781 sv.AssignmentId = ptr.String(jtv) 4782 } 4783 4784 case "BonusAmount": 4785 if value != nil { 4786 jtv, ok := value.(string) 4787 if !ok { 4788 return fmt.Errorf("expected CurrencyAmount to be of type string, got %T instead", value) 4789 } 4790 sv.BonusAmount = ptr.String(jtv) 4791 } 4792 4793 case "GrantTime": 4794 if value != nil { 4795 switch jtv := value.(type) { 4796 case json.Number: 4797 f64, err := jtv.Float64() 4798 if err != nil { 4799 return err 4800 } 4801 sv.GrantTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 4802 4803 default: 4804 return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value) 4805 4806 } 4807 } 4808 4809 case "Reason": 4810 if value != nil { 4811 jtv, ok := value.(string) 4812 if !ok { 4813 return fmt.Errorf("expected String to be of type string, got %T instead", value) 4814 } 4815 sv.Reason = ptr.String(jtv) 4816 } 4817 4818 case "WorkerId": 4819 if value != nil { 4820 jtv, ok := value.(string) 4821 if !ok { 4822 return fmt.Errorf("expected CustomerId to be of type string, got %T instead", value) 4823 } 4824 sv.WorkerId = ptr.String(jtv) 4825 } 4826 4827 default: 4828 _, _ = key, value 4829 4830 } 4831 } 4832 *v = sv 4833 return nil 4834} 4835 4836func awsAwsjson11_deserializeDocumentBonusPaymentList(v *[]types.BonusPayment, value interface{}) error { 4837 if v == nil { 4838 return fmt.Errorf("unexpected nil of type %T", v) 4839 } 4840 if value == nil { 4841 return nil 4842 } 4843 4844 shape, ok := value.([]interface{}) 4845 if !ok { 4846 return fmt.Errorf("unexpected JSON type %v", value) 4847 } 4848 4849 var cv []types.BonusPayment 4850 if *v == nil { 4851 cv = []types.BonusPayment{} 4852 } else { 4853 cv = *v 4854 } 4855 4856 for _, value := range shape { 4857 var col types.BonusPayment 4858 destAddr := &col 4859 if err := awsAwsjson11_deserializeDocumentBonusPayment(&destAddr, value); err != nil { 4860 return err 4861 } 4862 col = *destAddr 4863 cv = append(cv, col) 4864 4865 } 4866 *v = cv 4867 return nil 4868} 4869 4870func awsAwsjson11_deserializeDocumentHIT(v **types.HIT, value interface{}) error { 4871 if v == nil { 4872 return fmt.Errorf("unexpected nil of type %T", v) 4873 } 4874 if value == nil { 4875 return nil 4876 } 4877 4878 shape, ok := value.(map[string]interface{}) 4879 if !ok { 4880 return fmt.Errorf("unexpected JSON type %v", value) 4881 } 4882 4883 var sv *types.HIT 4884 if *v == nil { 4885 sv = &types.HIT{} 4886 } else { 4887 sv = *v 4888 } 4889 4890 for key, value := range shape { 4891 switch key { 4892 case "AssignmentDurationInSeconds": 4893 if value != nil { 4894 jtv, ok := value.(json.Number) 4895 if !ok { 4896 return fmt.Errorf("expected Long to be json.Number, got %T instead", value) 4897 } 4898 i64, err := jtv.Int64() 4899 if err != nil { 4900 return err 4901 } 4902 sv.AssignmentDurationInSeconds = ptr.Int64(i64) 4903 } 4904 4905 case "AutoApprovalDelayInSeconds": 4906 if value != nil { 4907 jtv, ok := value.(json.Number) 4908 if !ok { 4909 return fmt.Errorf("expected Long to be json.Number, got %T instead", value) 4910 } 4911 i64, err := jtv.Int64() 4912 if err != nil { 4913 return err 4914 } 4915 sv.AutoApprovalDelayInSeconds = ptr.Int64(i64) 4916 } 4917 4918 case "CreationTime": 4919 if value != nil { 4920 switch jtv := value.(type) { 4921 case json.Number: 4922 f64, err := jtv.Float64() 4923 if err != nil { 4924 return err 4925 } 4926 sv.CreationTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 4927 4928 default: 4929 return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value) 4930 4931 } 4932 } 4933 4934 case "Description": 4935 if value != nil { 4936 jtv, ok := value.(string) 4937 if !ok { 4938 return fmt.Errorf("expected String to be of type string, got %T instead", value) 4939 } 4940 sv.Description = ptr.String(jtv) 4941 } 4942 4943 case "Expiration": 4944 if value != nil { 4945 switch jtv := value.(type) { 4946 case json.Number: 4947 f64, err := jtv.Float64() 4948 if err != nil { 4949 return err 4950 } 4951 sv.Expiration = ptr.Time(smithytime.ParseEpochSeconds(f64)) 4952 4953 default: 4954 return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value) 4955 4956 } 4957 } 4958 4959 case "HITGroupId": 4960 if value != nil { 4961 jtv, ok := value.(string) 4962 if !ok { 4963 return fmt.Errorf("expected EntityId to be of type string, got %T instead", value) 4964 } 4965 sv.HITGroupId = ptr.String(jtv) 4966 } 4967 4968 case "HITId": 4969 if value != nil { 4970 jtv, ok := value.(string) 4971 if !ok { 4972 return fmt.Errorf("expected EntityId to be of type string, got %T instead", value) 4973 } 4974 sv.HITId = ptr.String(jtv) 4975 } 4976 4977 case "HITLayoutId": 4978 if value != nil { 4979 jtv, ok := value.(string) 4980 if !ok { 4981 return fmt.Errorf("expected EntityId to be of type string, got %T instead", value) 4982 } 4983 sv.HITLayoutId = ptr.String(jtv) 4984 } 4985 4986 case "HITReviewStatus": 4987 if value != nil { 4988 jtv, ok := value.(string) 4989 if !ok { 4990 return fmt.Errorf("expected HITReviewStatus to be of type string, got %T instead", value) 4991 } 4992 sv.HITReviewStatus = types.HITReviewStatus(jtv) 4993 } 4994 4995 case "HITStatus": 4996 if value != nil { 4997 jtv, ok := value.(string) 4998 if !ok { 4999 return fmt.Errorf("expected HITStatus to be of type string, got %T instead", value) 5000 } 5001 sv.HITStatus = types.HITStatus(jtv) 5002 } 5003 5004 case "HITTypeId": 5005 if value != nil { 5006 jtv, ok := value.(string) 5007 if !ok { 5008 return fmt.Errorf("expected EntityId to be of type string, got %T instead", value) 5009 } 5010 sv.HITTypeId = ptr.String(jtv) 5011 } 5012 5013 case "Keywords": 5014 if value != nil { 5015 jtv, ok := value.(string) 5016 if !ok { 5017 return fmt.Errorf("expected String to be of type string, got %T instead", value) 5018 } 5019 sv.Keywords = ptr.String(jtv) 5020 } 5021 5022 case "MaxAssignments": 5023 if value != nil { 5024 jtv, ok := value.(json.Number) 5025 if !ok { 5026 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 5027 } 5028 i64, err := jtv.Int64() 5029 if err != nil { 5030 return err 5031 } 5032 sv.MaxAssignments = ptr.Int32(int32(i64)) 5033 } 5034 5035 case "NumberOfAssignmentsAvailable": 5036 if value != nil { 5037 jtv, ok := value.(json.Number) 5038 if !ok { 5039 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 5040 } 5041 i64, err := jtv.Int64() 5042 if err != nil { 5043 return err 5044 } 5045 sv.NumberOfAssignmentsAvailable = ptr.Int32(int32(i64)) 5046 } 5047 5048 case "NumberOfAssignmentsCompleted": 5049 if value != nil { 5050 jtv, ok := value.(json.Number) 5051 if !ok { 5052 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 5053 } 5054 i64, err := jtv.Int64() 5055 if err != nil { 5056 return err 5057 } 5058 sv.NumberOfAssignmentsCompleted = ptr.Int32(int32(i64)) 5059 } 5060 5061 case "NumberOfAssignmentsPending": 5062 if value != nil { 5063 jtv, ok := value.(json.Number) 5064 if !ok { 5065 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 5066 } 5067 i64, err := jtv.Int64() 5068 if err != nil { 5069 return err 5070 } 5071 sv.NumberOfAssignmentsPending = ptr.Int32(int32(i64)) 5072 } 5073 5074 case "QualificationRequirements": 5075 if err := awsAwsjson11_deserializeDocumentQualificationRequirementList(&sv.QualificationRequirements, value); err != nil { 5076 return err 5077 } 5078 5079 case "Question": 5080 if value != nil { 5081 jtv, ok := value.(string) 5082 if !ok { 5083 return fmt.Errorf("expected String to be of type string, got %T instead", value) 5084 } 5085 sv.Question = ptr.String(jtv) 5086 } 5087 5088 case "RequesterAnnotation": 5089 if value != nil { 5090 jtv, ok := value.(string) 5091 if !ok { 5092 return fmt.Errorf("expected String to be of type string, got %T instead", value) 5093 } 5094 sv.RequesterAnnotation = ptr.String(jtv) 5095 } 5096 5097 case "Reward": 5098 if value != nil { 5099 jtv, ok := value.(string) 5100 if !ok { 5101 return fmt.Errorf("expected CurrencyAmount to be of type string, got %T instead", value) 5102 } 5103 sv.Reward = ptr.String(jtv) 5104 } 5105 5106 case "Title": 5107 if value != nil { 5108 jtv, ok := value.(string) 5109 if !ok { 5110 return fmt.Errorf("expected String to be of type string, got %T instead", value) 5111 } 5112 sv.Title = ptr.String(jtv) 5113 } 5114 5115 default: 5116 _, _ = key, value 5117 5118 } 5119 } 5120 *v = sv 5121 return nil 5122} 5123 5124func awsAwsjson11_deserializeDocumentHITList(v *[]types.HIT, value interface{}) error { 5125 if v == nil { 5126 return fmt.Errorf("unexpected nil of type %T", v) 5127 } 5128 if value == nil { 5129 return nil 5130 } 5131 5132 shape, ok := value.([]interface{}) 5133 if !ok { 5134 return fmt.Errorf("unexpected JSON type %v", value) 5135 } 5136 5137 var cv []types.HIT 5138 if *v == nil { 5139 cv = []types.HIT{} 5140 } else { 5141 cv = *v 5142 } 5143 5144 for _, value := range shape { 5145 var col types.HIT 5146 destAddr := &col 5147 if err := awsAwsjson11_deserializeDocumentHIT(&destAddr, value); err != nil { 5148 return err 5149 } 5150 col = *destAddr 5151 cv = append(cv, col) 5152 5153 } 5154 *v = cv 5155 return nil 5156} 5157 5158func awsAwsjson11_deserializeDocumentIntegerList(v *[]int32, value interface{}) error { 5159 if v == nil { 5160 return fmt.Errorf("unexpected nil of type %T", v) 5161 } 5162 if value == nil { 5163 return nil 5164 } 5165 5166 shape, ok := value.([]interface{}) 5167 if !ok { 5168 return fmt.Errorf("unexpected JSON type %v", value) 5169 } 5170 5171 var cv []int32 5172 if *v == nil { 5173 cv = []int32{} 5174 } else { 5175 cv = *v 5176 } 5177 5178 for _, value := range shape { 5179 var col int32 5180 if value != nil { 5181 jtv, ok := value.(json.Number) 5182 if !ok { 5183 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 5184 } 5185 i64, err := jtv.Int64() 5186 if err != nil { 5187 return err 5188 } 5189 col = int32(i64) 5190 } 5191 cv = append(cv, col) 5192 5193 } 5194 *v = cv 5195 return nil 5196} 5197 5198func awsAwsjson11_deserializeDocumentLocale(v **types.Locale, value interface{}) error { 5199 if v == nil { 5200 return fmt.Errorf("unexpected nil of type %T", v) 5201 } 5202 if value == nil { 5203 return nil 5204 } 5205 5206 shape, ok := value.(map[string]interface{}) 5207 if !ok { 5208 return fmt.Errorf("unexpected JSON type %v", value) 5209 } 5210 5211 var sv *types.Locale 5212 if *v == nil { 5213 sv = &types.Locale{} 5214 } else { 5215 sv = *v 5216 } 5217 5218 for key, value := range shape { 5219 switch key { 5220 case "Country": 5221 if value != nil { 5222 jtv, ok := value.(string) 5223 if !ok { 5224 return fmt.Errorf("expected CountryParameters to be of type string, got %T instead", value) 5225 } 5226 sv.Country = ptr.String(jtv) 5227 } 5228 5229 case "Subdivision": 5230 if value != nil { 5231 jtv, ok := value.(string) 5232 if !ok { 5233 return fmt.Errorf("expected CountryParameters to be of type string, got %T instead", value) 5234 } 5235 sv.Subdivision = ptr.String(jtv) 5236 } 5237 5238 default: 5239 _, _ = key, value 5240 5241 } 5242 } 5243 *v = sv 5244 return nil 5245} 5246 5247func awsAwsjson11_deserializeDocumentLocaleList(v *[]types.Locale, value interface{}) error { 5248 if v == nil { 5249 return fmt.Errorf("unexpected nil of type %T", v) 5250 } 5251 if value == nil { 5252 return nil 5253 } 5254 5255 shape, ok := value.([]interface{}) 5256 if !ok { 5257 return fmt.Errorf("unexpected JSON type %v", value) 5258 } 5259 5260 var cv []types.Locale 5261 if *v == nil { 5262 cv = []types.Locale{} 5263 } else { 5264 cv = *v 5265 } 5266 5267 for _, value := range shape { 5268 var col types.Locale 5269 destAddr := &col 5270 if err := awsAwsjson11_deserializeDocumentLocale(&destAddr, value); err != nil { 5271 return err 5272 } 5273 col = *destAddr 5274 cv = append(cv, col) 5275 5276 } 5277 *v = cv 5278 return nil 5279} 5280 5281func awsAwsjson11_deserializeDocumentNotifyWorkersFailureStatus(v **types.NotifyWorkersFailureStatus, value interface{}) error { 5282 if v == nil { 5283 return fmt.Errorf("unexpected nil of type %T", v) 5284 } 5285 if value == nil { 5286 return nil 5287 } 5288 5289 shape, ok := value.(map[string]interface{}) 5290 if !ok { 5291 return fmt.Errorf("unexpected JSON type %v", value) 5292 } 5293 5294 var sv *types.NotifyWorkersFailureStatus 5295 if *v == nil { 5296 sv = &types.NotifyWorkersFailureStatus{} 5297 } else { 5298 sv = *v 5299 } 5300 5301 for key, value := range shape { 5302 switch key { 5303 case "NotifyWorkersFailureCode": 5304 if value != nil { 5305 jtv, ok := value.(string) 5306 if !ok { 5307 return fmt.Errorf("expected NotifyWorkersFailureCode to be of type string, got %T instead", value) 5308 } 5309 sv.NotifyWorkersFailureCode = types.NotifyWorkersFailureCode(jtv) 5310 } 5311 5312 case "NotifyWorkersFailureMessage": 5313 if value != nil { 5314 jtv, ok := value.(string) 5315 if !ok { 5316 return fmt.Errorf("expected String to be of type string, got %T instead", value) 5317 } 5318 sv.NotifyWorkersFailureMessage = ptr.String(jtv) 5319 } 5320 5321 case "WorkerId": 5322 if value != nil { 5323 jtv, ok := value.(string) 5324 if !ok { 5325 return fmt.Errorf("expected CustomerId to be of type string, got %T instead", value) 5326 } 5327 sv.WorkerId = ptr.String(jtv) 5328 } 5329 5330 default: 5331 _, _ = key, value 5332 5333 } 5334 } 5335 *v = sv 5336 return nil 5337} 5338 5339func awsAwsjson11_deserializeDocumentNotifyWorkersFailureStatusList(v *[]types.NotifyWorkersFailureStatus, value interface{}) error { 5340 if v == nil { 5341 return fmt.Errorf("unexpected nil of type %T", v) 5342 } 5343 if value == nil { 5344 return nil 5345 } 5346 5347 shape, ok := value.([]interface{}) 5348 if !ok { 5349 return fmt.Errorf("unexpected JSON type %v", value) 5350 } 5351 5352 var cv []types.NotifyWorkersFailureStatus 5353 if *v == nil { 5354 cv = []types.NotifyWorkersFailureStatus{} 5355 } else { 5356 cv = *v 5357 } 5358 5359 for _, value := range shape { 5360 var col types.NotifyWorkersFailureStatus 5361 destAddr := &col 5362 if err := awsAwsjson11_deserializeDocumentNotifyWorkersFailureStatus(&destAddr, value); err != nil { 5363 return err 5364 } 5365 col = *destAddr 5366 cv = append(cv, col) 5367 5368 } 5369 *v = cv 5370 return nil 5371} 5372 5373func awsAwsjson11_deserializeDocumentParameterMapEntry(v **types.ParameterMapEntry, value interface{}) error { 5374 if v == nil { 5375 return fmt.Errorf("unexpected nil of type %T", v) 5376 } 5377 if value == nil { 5378 return nil 5379 } 5380 5381 shape, ok := value.(map[string]interface{}) 5382 if !ok { 5383 return fmt.Errorf("unexpected JSON type %v", value) 5384 } 5385 5386 var sv *types.ParameterMapEntry 5387 if *v == nil { 5388 sv = &types.ParameterMapEntry{} 5389 } else { 5390 sv = *v 5391 } 5392 5393 for key, value := range shape { 5394 switch key { 5395 case "Key": 5396 if value != nil { 5397 jtv, ok := value.(string) 5398 if !ok { 5399 return fmt.Errorf("expected String to be of type string, got %T instead", value) 5400 } 5401 sv.Key = ptr.String(jtv) 5402 } 5403 5404 case "Values": 5405 if err := awsAwsjson11_deserializeDocumentStringList(&sv.Values, value); err != nil { 5406 return err 5407 } 5408 5409 default: 5410 _, _ = key, value 5411 5412 } 5413 } 5414 *v = sv 5415 return nil 5416} 5417 5418func awsAwsjson11_deserializeDocumentParameterMapEntryList(v *[]types.ParameterMapEntry, value interface{}) error { 5419 if v == nil { 5420 return fmt.Errorf("unexpected nil of type %T", v) 5421 } 5422 if value == nil { 5423 return nil 5424 } 5425 5426 shape, ok := value.([]interface{}) 5427 if !ok { 5428 return fmt.Errorf("unexpected JSON type %v", value) 5429 } 5430 5431 var cv []types.ParameterMapEntry 5432 if *v == nil { 5433 cv = []types.ParameterMapEntry{} 5434 } else { 5435 cv = *v 5436 } 5437 5438 for _, value := range shape { 5439 var col types.ParameterMapEntry 5440 destAddr := &col 5441 if err := awsAwsjson11_deserializeDocumentParameterMapEntry(&destAddr, value); err != nil { 5442 return err 5443 } 5444 col = *destAddr 5445 cv = append(cv, col) 5446 5447 } 5448 *v = cv 5449 return nil 5450} 5451 5452func awsAwsjson11_deserializeDocumentPolicyParameter(v **types.PolicyParameter, value interface{}) error { 5453 if v == nil { 5454 return fmt.Errorf("unexpected nil of type %T", v) 5455 } 5456 if value == nil { 5457 return nil 5458 } 5459 5460 shape, ok := value.(map[string]interface{}) 5461 if !ok { 5462 return fmt.Errorf("unexpected JSON type %v", value) 5463 } 5464 5465 var sv *types.PolicyParameter 5466 if *v == nil { 5467 sv = &types.PolicyParameter{} 5468 } else { 5469 sv = *v 5470 } 5471 5472 for key, value := range shape { 5473 switch key { 5474 case "Key": 5475 if value != nil { 5476 jtv, ok := value.(string) 5477 if !ok { 5478 return fmt.Errorf("expected String to be of type string, got %T instead", value) 5479 } 5480 sv.Key = ptr.String(jtv) 5481 } 5482 5483 case "MapEntries": 5484 if err := awsAwsjson11_deserializeDocumentParameterMapEntryList(&sv.MapEntries, value); err != nil { 5485 return err 5486 } 5487 5488 case "Values": 5489 if err := awsAwsjson11_deserializeDocumentStringList(&sv.Values, value); err != nil { 5490 return err 5491 } 5492 5493 default: 5494 _, _ = key, value 5495 5496 } 5497 } 5498 *v = sv 5499 return nil 5500} 5501 5502func awsAwsjson11_deserializeDocumentPolicyParameterList(v *[]types.PolicyParameter, value interface{}) error { 5503 if v == nil { 5504 return fmt.Errorf("unexpected nil of type %T", v) 5505 } 5506 if value == nil { 5507 return nil 5508 } 5509 5510 shape, ok := value.([]interface{}) 5511 if !ok { 5512 return fmt.Errorf("unexpected JSON type %v", value) 5513 } 5514 5515 var cv []types.PolicyParameter 5516 if *v == nil { 5517 cv = []types.PolicyParameter{} 5518 } else { 5519 cv = *v 5520 } 5521 5522 for _, value := range shape { 5523 var col types.PolicyParameter 5524 destAddr := &col 5525 if err := awsAwsjson11_deserializeDocumentPolicyParameter(&destAddr, value); err != nil { 5526 return err 5527 } 5528 col = *destAddr 5529 cv = append(cv, col) 5530 5531 } 5532 *v = cv 5533 return nil 5534} 5535 5536func awsAwsjson11_deserializeDocumentQualification(v **types.Qualification, value interface{}) error { 5537 if v == nil { 5538 return fmt.Errorf("unexpected nil of type %T", v) 5539 } 5540 if value == nil { 5541 return nil 5542 } 5543 5544 shape, ok := value.(map[string]interface{}) 5545 if !ok { 5546 return fmt.Errorf("unexpected JSON type %v", value) 5547 } 5548 5549 var sv *types.Qualification 5550 if *v == nil { 5551 sv = &types.Qualification{} 5552 } else { 5553 sv = *v 5554 } 5555 5556 for key, value := range shape { 5557 switch key { 5558 case "GrantTime": 5559 if value != nil { 5560 switch jtv := value.(type) { 5561 case json.Number: 5562 f64, err := jtv.Float64() 5563 if err != nil { 5564 return err 5565 } 5566 sv.GrantTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 5567 5568 default: 5569 return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value) 5570 5571 } 5572 } 5573 5574 case "IntegerValue": 5575 if value != nil { 5576 jtv, ok := value.(json.Number) 5577 if !ok { 5578 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 5579 } 5580 i64, err := jtv.Int64() 5581 if err != nil { 5582 return err 5583 } 5584 sv.IntegerValue = ptr.Int32(int32(i64)) 5585 } 5586 5587 case "LocaleValue": 5588 if err := awsAwsjson11_deserializeDocumentLocale(&sv.LocaleValue, value); err != nil { 5589 return err 5590 } 5591 5592 case "QualificationTypeId": 5593 if value != nil { 5594 jtv, ok := value.(string) 5595 if !ok { 5596 return fmt.Errorf("expected EntityId to be of type string, got %T instead", value) 5597 } 5598 sv.QualificationTypeId = ptr.String(jtv) 5599 } 5600 5601 case "Status": 5602 if value != nil { 5603 jtv, ok := value.(string) 5604 if !ok { 5605 return fmt.Errorf("expected QualificationStatus to be of type string, got %T instead", value) 5606 } 5607 sv.Status = types.QualificationStatus(jtv) 5608 } 5609 5610 case "WorkerId": 5611 if value != nil { 5612 jtv, ok := value.(string) 5613 if !ok { 5614 return fmt.Errorf("expected CustomerId to be of type string, got %T instead", value) 5615 } 5616 sv.WorkerId = ptr.String(jtv) 5617 } 5618 5619 default: 5620 _, _ = key, value 5621 5622 } 5623 } 5624 *v = sv 5625 return nil 5626} 5627 5628func awsAwsjson11_deserializeDocumentQualificationList(v *[]types.Qualification, value interface{}) error { 5629 if v == nil { 5630 return fmt.Errorf("unexpected nil of type %T", v) 5631 } 5632 if value == nil { 5633 return nil 5634 } 5635 5636 shape, ok := value.([]interface{}) 5637 if !ok { 5638 return fmt.Errorf("unexpected JSON type %v", value) 5639 } 5640 5641 var cv []types.Qualification 5642 if *v == nil { 5643 cv = []types.Qualification{} 5644 } else { 5645 cv = *v 5646 } 5647 5648 for _, value := range shape { 5649 var col types.Qualification 5650 destAddr := &col 5651 if err := awsAwsjson11_deserializeDocumentQualification(&destAddr, value); err != nil { 5652 return err 5653 } 5654 col = *destAddr 5655 cv = append(cv, col) 5656 5657 } 5658 *v = cv 5659 return nil 5660} 5661 5662func awsAwsjson11_deserializeDocumentQualificationRequest(v **types.QualificationRequest, value interface{}) error { 5663 if v == nil { 5664 return fmt.Errorf("unexpected nil of type %T", v) 5665 } 5666 if value == nil { 5667 return nil 5668 } 5669 5670 shape, ok := value.(map[string]interface{}) 5671 if !ok { 5672 return fmt.Errorf("unexpected JSON type %v", value) 5673 } 5674 5675 var sv *types.QualificationRequest 5676 if *v == nil { 5677 sv = &types.QualificationRequest{} 5678 } else { 5679 sv = *v 5680 } 5681 5682 for key, value := range shape { 5683 switch key { 5684 case "Answer": 5685 if value != nil { 5686 jtv, ok := value.(string) 5687 if !ok { 5688 return fmt.Errorf("expected String to be of type string, got %T instead", value) 5689 } 5690 sv.Answer = ptr.String(jtv) 5691 } 5692 5693 case "QualificationRequestId": 5694 if value != nil { 5695 jtv, ok := value.(string) 5696 if !ok { 5697 return fmt.Errorf("expected String to be of type string, got %T instead", value) 5698 } 5699 sv.QualificationRequestId = ptr.String(jtv) 5700 } 5701 5702 case "QualificationTypeId": 5703 if value != nil { 5704 jtv, ok := value.(string) 5705 if !ok { 5706 return fmt.Errorf("expected EntityId to be of type string, got %T instead", value) 5707 } 5708 sv.QualificationTypeId = ptr.String(jtv) 5709 } 5710 5711 case "SubmitTime": 5712 if value != nil { 5713 switch jtv := value.(type) { 5714 case json.Number: 5715 f64, err := jtv.Float64() 5716 if err != nil { 5717 return err 5718 } 5719 sv.SubmitTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 5720 5721 default: 5722 return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value) 5723 5724 } 5725 } 5726 5727 case "Test": 5728 if value != nil { 5729 jtv, ok := value.(string) 5730 if !ok { 5731 return fmt.Errorf("expected String to be of type string, got %T instead", value) 5732 } 5733 sv.Test = ptr.String(jtv) 5734 } 5735 5736 case "WorkerId": 5737 if value != nil { 5738 jtv, ok := value.(string) 5739 if !ok { 5740 return fmt.Errorf("expected CustomerId to be of type string, got %T instead", value) 5741 } 5742 sv.WorkerId = ptr.String(jtv) 5743 } 5744 5745 default: 5746 _, _ = key, value 5747 5748 } 5749 } 5750 *v = sv 5751 return nil 5752} 5753 5754func awsAwsjson11_deserializeDocumentQualificationRequestList(v *[]types.QualificationRequest, value interface{}) error { 5755 if v == nil { 5756 return fmt.Errorf("unexpected nil of type %T", v) 5757 } 5758 if value == nil { 5759 return nil 5760 } 5761 5762 shape, ok := value.([]interface{}) 5763 if !ok { 5764 return fmt.Errorf("unexpected JSON type %v", value) 5765 } 5766 5767 var cv []types.QualificationRequest 5768 if *v == nil { 5769 cv = []types.QualificationRequest{} 5770 } else { 5771 cv = *v 5772 } 5773 5774 for _, value := range shape { 5775 var col types.QualificationRequest 5776 destAddr := &col 5777 if err := awsAwsjson11_deserializeDocumentQualificationRequest(&destAddr, value); err != nil { 5778 return err 5779 } 5780 col = *destAddr 5781 cv = append(cv, col) 5782 5783 } 5784 *v = cv 5785 return nil 5786} 5787 5788func awsAwsjson11_deserializeDocumentQualificationRequirement(v **types.QualificationRequirement, value interface{}) error { 5789 if v == nil { 5790 return fmt.Errorf("unexpected nil of type %T", v) 5791 } 5792 if value == nil { 5793 return nil 5794 } 5795 5796 shape, ok := value.(map[string]interface{}) 5797 if !ok { 5798 return fmt.Errorf("unexpected JSON type %v", value) 5799 } 5800 5801 var sv *types.QualificationRequirement 5802 if *v == nil { 5803 sv = &types.QualificationRequirement{} 5804 } else { 5805 sv = *v 5806 } 5807 5808 for key, value := range shape { 5809 switch key { 5810 case "ActionsGuarded": 5811 if value != nil { 5812 jtv, ok := value.(string) 5813 if !ok { 5814 return fmt.Errorf("expected HITAccessActions to be of type string, got %T instead", value) 5815 } 5816 sv.ActionsGuarded = types.HITAccessActions(jtv) 5817 } 5818 5819 case "Comparator": 5820 if value != nil { 5821 jtv, ok := value.(string) 5822 if !ok { 5823 return fmt.Errorf("expected Comparator to be of type string, got %T instead", value) 5824 } 5825 sv.Comparator = types.Comparator(jtv) 5826 } 5827 5828 case "IntegerValues": 5829 if err := awsAwsjson11_deserializeDocumentIntegerList(&sv.IntegerValues, value); err != nil { 5830 return err 5831 } 5832 5833 case "LocaleValues": 5834 if err := awsAwsjson11_deserializeDocumentLocaleList(&sv.LocaleValues, value); err != nil { 5835 return err 5836 } 5837 5838 case "QualificationTypeId": 5839 if value != nil { 5840 jtv, ok := value.(string) 5841 if !ok { 5842 return fmt.Errorf("expected String to be of type string, got %T instead", value) 5843 } 5844 sv.QualificationTypeId = ptr.String(jtv) 5845 } 5846 5847 case "RequiredToPreview": 5848 if value != nil { 5849 jtv, ok := value.(bool) 5850 if !ok { 5851 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 5852 } 5853 sv.RequiredToPreview = ptr.Bool(jtv) 5854 } 5855 5856 default: 5857 _, _ = key, value 5858 5859 } 5860 } 5861 *v = sv 5862 return nil 5863} 5864 5865func awsAwsjson11_deserializeDocumentQualificationRequirementList(v *[]types.QualificationRequirement, value interface{}) error { 5866 if v == nil { 5867 return fmt.Errorf("unexpected nil of type %T", v) 5868 } 5869 if value == nil { 5870 return nil 5871 } 5872 5873 shape, ok := value.([]interface{}) 5874 if !ok { 5875 return fmt.Errorf("unexpected JSON type %v", value) 5876 } 5877 5878 var cv []types.QualificationRequirement 5879 if *v == nil { 5880 cv = []types.QualificationRequirement{} 5881 } else { 5882 cv = *v 5883 } 5884 5885 for _, value := range shape { 5886 var col types.QualificationRequirement 5887 destAddr := &col 5888 if err := awsAwsjson11_deserializeDocumentQualificationRequirement(&destAddr, value); err != nil { 5889 return err 5890 } 5891 col = *destAddr 5892 cv = append(cv, col) 5893 5894 } 5895 *v = cv 5896 return nil 5897} 5898 5899func awsAwsjson11_deserializeDocumentQualificationType(v **types.QualificationType, value interface{}) error { 5900 if v == nil { 5901 return fmt.Errorf("unexpected nil of type %T", v) 5902 } 5903 if value == nil { 5904 return nil 5905 } 5906 5907 shape, ok := value.(map[string]interface{}) 5908 if !ok { 5909 return fmt.Errorf("unexpected JSON type %v", value) 5910 } 5911 5912 var sv *types.QualificationType 5913 if *v == nil { 5914 sv = &types.QualificationType{} 5915 } else { 5916 sv = *v 5917 } 5918 5919 for key, value := range shape { 5920 switch key { 5921 case "AnswerKey": 5922 if value != nil { 5923 jtv, ok := value.(string) 5924 if !ok { 5925 return fmt.Errorf("expected String to be of type string, got %T instead", value) 5926 } 5927 sv.AnswerKey = ptr.String(jtv) 5928 } 5929 5930 case "AutoGranted": 5931 if value != nil { 5932 jtv, ok := value.(bool) 5933 if !ok { 5934 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 5935 } 5936 sv.AutoGranted = ptr.Bool(jtv) 5937 } 5938 5939 case "AutoGrantedValue": 5940 if value != nil { 5941 jtv, ok := value.(json.Number) 5942 if !ok { 5943 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 5944 } 5945 i64, err := jtv.Int64() 5946 if err != nil { 5947 return err 5948 } 5949 sv.AutoGrantedValue = ptr.Int32(int32(i64)) 5950 } 5951 5952 case "CreationTime": 5953 if value != nil { 5954 switch jtv := value.(type) { 5955 case json.Number: 5956 f64, err := jtv.Float64() 5957 if err != nil { 5958 return err 5959 } 5960 sv.CreationTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 5961 5962 default: 5963 return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value) 5964 5965 } 5966 } 5967 5968 case "Description": 5969 if value != nil { 5970 jtv, ok := value.(string) 5971 if !ok { 5972 return fmt.Errorf("expected String to be of type string, got %T instead", value) 5973 } 5974 sv.Description = ptr.String(jtv) 5975 } 5976 5977 case "IsRequestable": 5978 if value != nil { 5979 jtv, ok := value.(bool) 5980 if !ok { 5981 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 5982 } 5983 sv.IsRequestable = ptr.Bool(jtv) 5984 } 5985 5986 case "Keywords": 5987 if value != nil { 5988 jtv, ok := value.(string) 5989 if !ok { 5990 return fmt.Errorf("expected String to be of type string, got %T instead", value) 5991 } 5992 sv.Keywords = ptr.String(jtv) 5993 } 5994 5995 case "Name": 5996 if value != nil { 5997 jtv, ok := value.(string) 5998 if !ok { 5999 return fmt.Errorf("expected String to be of type string, got %T instead", value) 6000 } 6001 sv.Name = ptr.String(jtv) 6002 } 6003 6004 case "QualificationTypeId": 6005 if value != nil { 6006 jtv, ok := value.(string) 6007 if !ok { 6008 return fmt.Errorf("expected EntityId to be of type string, got %T instead", value) 6009 } 6010 sv.QualificationTypeId = ptr.String(jtv) 6011 } 6012 6013 case "QualificationTypeStatus": 6014 if value != nil { 6015 jtv, ok := value.(string) 6016 if !ok { 6017 return fmt.Errorf("expected QualificationTypeStatus to be of type string, got %T instead", value) 6018 } 6019 sv.QualificationTypeStatus = types.QualificationTypeStatus(jtv) 6020 } 6021 6022 case "RetryDelayInSeconds": 6023 if value != nil { 6024 jtv, ok := value.(json.Number) 6025 if !ok { 6026 return fmt.Errorf("expected Long to be json.Number, got %T instead", value) 6027 } 6028 i64, err := jtv.Int64() 6029 if err != nil { 6030 return err 6031 } 6032 sv.RetryDelayInSeconds = ptr.Int64(i64) 6033 } 6034 6035 case "Test": 6036 if value != nil { 6037 jtv, ok := value.(string) 6038 if !ok { 6039 return fmt.Errorf("expected String to be of type string, got %T instead", value) 6040 } 6041 sv.Test = ptr.String(jtv) 6042 } 6043 6044 case "TestDurationInSeconds": 6045 if value != nil { 6046 jtv, ok := value.(json.Number) 6047 if !ok { 6048 return fmt.Errorf("expected Long to be json.Number, got %T instead", value) 6049 } 6050 i64, err := jtv.Int64() 6051 if err != nil { 6052 return err 6053 } 6054 sv.TestDurationInSeconds = ptr.Int64(i64) 6055 } 6056 6057 default: 6058 _, _ = key, value 6059 6060 } 6061 } 6062 *v = sv 6063 return nil 6064} 6065 6066func awsAwsjson11_deserializeDocumentQualificationTypeList(v *[]types.QualificationType, value interface{}) error { 6067 if v == nil { 6068 return fmt.Errorf("unexpected nil of type %T", v) 6069 } 6070 if value == nil { 6071 return nil 6072 } 6073 6074 shape, ok := value.([]interface{}) 6075 if !ok { 6076 return fmt.Errorf("unexpected JSON type %v", value) 6077 } 6078 6079 var cv []types.QualificationType 6080 if *v == nil { 6081 cv = []types.QualificationType{} 6082 } else { 6083 cv = *v 6084 } 6085 6086 for _, value := range shape { 6087 var col types.QualificationType 6088 destAddr := &col 6089 if err := awsAwsjson11_deserializeDocumentQualificationType(&destAddr, value); err != nil { 6090 return err 6091 } 6092 col = *destAddr 6093 cv = append(cv, col) 6094 6095 } 6096 *v = cv 6097 return nil 6098} 6099 6100func awsAwsjson11_deserializeDocumentRequestError(v **types.RequestError, value interface{}) error { 6101 if v == nil { 6102 return fmt.Errorf("unexpected nil of type %T", v) 6103 } 6104 if value == nil { 6105 return nil 6106 } 6107 6108 shape, ok := value.(map[string]interface{}) 6109 if !ok { 6110 return fmt.Errorf("unexpected JSON type %v", value) 6111 } 6112 6113 var sv *types.RequestError 6114 if *v == nil { 6115 sv = &types.RequestError{} 6116 } else { 6117 sv = *v 6118 } 6119 6120 for key, value := range shape { 6121 switch key { 6122 case "Message": 6123 if value != nil { 6124 jtv, ok := value.(string) 6125 if !ok { 6126 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 6127 } 6128 sv.Message = ptr.String(jtv) 6129 } 6130 6131 case "TurkErrorCode": 6132 if value != nil { 6133 jtv, ok := value.(string) 6134 if !ok { 6135 return fmt.Errorf("expected TurkErrorCode to be of type string, got %T instead", value) 6136 } 6137 sv.TurkErrorCode = ptr.String(jtv) 6138 } 6139 6140 default: 6141 _, _ = key, value 6142 6143 } 6144 } 6145 *v = sv 6146 return nil 6147} 6148 6149func awsAwsjson11_deserializeDocumentReviewActionDetail(v **types.ReviewActionDetail, value interface{}) error { 6150 if v == nil { 6151 return fmt.Errorf("unexpected nil of type %T", v) 6152 } 6153 if value == nil { 6154 return nil 6155 } 6156 6157 shape, ok := value.(map[string]interface{}) 6158 if !ok { 6159 return fmt.Errorf("unexpected JSON type %v", value) 6160 } 6161 6162 var sv *types.ReviewActionDetail 6163 if *v == nil { 6164 sv = &types.ReviewActionDetail{} 6165 } else { 6166 sv = *v 6167 } 6168 6169 for key, value := range shape { 6170 switch key { 6171 case "ActionId": 6172 if value != nil { 6173 jtv, ok := value.(string) 6174 if !ok { 6175 return fmt.Errorf("expected EntityId to be of type string, got %T instead", value) 6176 } 6177 sv.ActionId = ptr.String(jtv) 6178 } 6179 6180 case "ActionName": 6181 if value != nil { 6182 jtv, ok := value.(string) 6183 if !ok { 6184 return fmt.Errorf("expected String to be of type string, got %T instead", value) 6185 } 6186 sv.ActionName = ptr.String(jtv) 6187 } 6188 6189 case "CompleteTime": 6190 if value != nil { 6191 switch jtv := value.(type) { 6192 case json.Number: 6193 f64, err := jtv.Float64() 6194 if err != nil { 6195 return err 6196 } 6197 sv.CompleteTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 6198 6199 default: 6200 return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value) 6201 6202 } 6203 } 6204 6205 case "ErrorCode": 6206 if value != nil { 6207 jtv, ok := value.(string) 6208 if !ok { 6209 return fmt.Errorf("expected String to be of type string, got %T instead", value) 6210 } 6211 sv.ErrorCode = ptr.String(jtv) 6212 } 6213 6214 case "Result": 6215 if value != nil { 6216 jtv, ok := value.(string) 6217 if !ok { 6218 return fmt.Errorf("expected String to be of type string, got %T instead", value) 6219 } 6220 sv.Result = ptr.String(jtv) 6221 } 6222 6223 case "Status": 6224 if value != nil { 6225 jtv, ok := value.(string) 6226 if !ok { 6227 return fmt.Errorf("expected ReviewActionStatus to be of type string, got %T instead", value) 6228 } 6229 sv.Status = types.ReviewActionStatus(jtv) 6230 } 6231 6232 case "TargetId": 6233 if value != nil { 6234 jtv, ok := value.(string) 6235 if !ok { 6236 return fmt.Errorf("expected EntityId to be of type string, got %T instead", value) 6237 } 6238 sv.TargetId = ptr.String(jtv) 6239 } 6240 6241 case "TargetType": 6242 if value != nil { 6243 jtv, ok := value.(string) 6244 if !ok { 6245 return fmt.Errorf("expected String to be of type string, got %T instead", value) 6246 } 6247 sv.TargetType = ptr.String(jtv) 6248 } 6249 6250 default: 6251 _, _ = key, value 6252 6253 } 6254 } 6255 *v = sv 6256 return nil 6257} 6258 6259func awsAwsjson11_deserializeDocumentReviewActionDetailList(v *[]types.ReviewActionDetail, value interface{}) error { 6260 if v == nil { 6261 return fmt.Errorf("unexpected nil of type %T", v) 6262 } 6263 if value == nil { 6264 return nil 6265 } 6266 6267 shape, ok := value.([]interface{}) 6268 if !ok { 6269 return fmt.Errorf("unexpected JSON type %v", value) 6270 } 6271 6272 var cv []types.ReviewActionDetail 6273 if *v == nil { 6274 cv = []types.ReviewActionDetail{} 6275 } else { 6276 cv = *v 6277 } 6278 6279 for _, value := range shape { 6280 var col types.ReviewActionDetail 6281 destAddr := &col 6282 if err := awsAwsjson11_deserializeDocumentReviewActionDetail(&destAddr, value); err != nil { 6283 return err 6284 } 6285 col = *destAddr 6286 cv = append(cv, col) 6287 6288 } 6289 *v = cv 6290 return nil 6291} 6292 6293func awsAwsjson11_deserializeDocumentReviewPolicy(v **types.ReviewPolicy, value interface{}) error { 6294 if v == nil { 6295 return fmt.Errorf("unexpected nil of type %T", v) 6296 } 6297 if value == nil { 6298 return nil 6299 } 6300 6301 shape, ok := value.(map[string]interface{}) 6302 if !ok { 6303 return fmt.Errorf("unexpected JSON type %v", value) 6304 } 6305 6306 var sv *types.ReviewPolicy 6307 if *v == nil { 6308 sv = &types.ReviewPolicy{} 6309 } else { 6310 sv = *v 6311 } 6312 6313 for key, value := range shape { 6314 switch key { 6315 case "Parameters": 6316 if err := awsAwsjson11_deserializeDocumentPolicyParameterList(&sv.Parameters, value); err != nil { 6317 return err 6318 } 6319 6320 case "PolicyName": 6321 if value != nil { 6322 jtv, ok := value.(string) 6323 if !ok { 6324 return fmt.Errorf("expected String to be of type string, got %T instead", value) 6325 } 6326 sv.PolicyName = ptr.String(jtv) 6327 } 6328 6329 default: 6330 _, _ = key, value 6331 6332 } 6333 } 6334 *v = sv 6335 return nil 6336} 6337 6338func awsAwsjson11_deserializeDocumentReviewReport(v **types.ReviewReport, value interface{}) error { 6339 if v == nil { 6340 return fmt.Errorf("unexpected nil of type %T", v) 6341 } 6342 if value == nil { 6343 return nil 6344 } 6345 6346 shape, ok := value.(map[string]interface{}) 6347 if !ok { 6348 return fmt.Errorf("unexpected JSON type %v", value) 6349 } 6350 6351 var sv *types.ReviewReport 6352 if *v == nil { 6353 sv = &types.ReviewReport{} 6354 } else { 6355 sv = *v 6356 } 6357 6358 for key, value := range shape { 6359 switch key { 6360 case "ReviewActions": 6361 if err := awsAwsjson11_deserializeDocumentReviewActionDetailList(&sv.ReviewActions, value); err != nil { 6362 return err 6363 } 6364 6365 case "ReviewResults": 6366 if err := awsAwsjson11_deserializeDocumentReviewResultDetailList(&sv.ReviewResults, value); err != nil { 6367 return err 6368 } 6369 6370 default: 6371 _, _ = key, value 6372 6373 } 6374 } 6375 *v = sv 6376 return nil 6377} 6378 6379func awsAwsjson11_deserializeDocumentReviewResultDetail(v **types.ReviewResultDetail, value interface{}) error { 6380 if v == nil { 6381 return fmt.Errorf("unexpected nil of type %T", v) 6382 } 6383 if value == nil { 6384 return nil 6385 } 6386 6387 shape, ok := value.(map[string]interface{}) 6388 if !ok { 6389 return fmt.Errorf("unexpected JSON type %v", value) 6390 } 6391 6392 var sv *types.ReviewResultDetail 6393 if *v == nil { 6394 sv = &types.ReviewResultDetail{} 6395 } else { 6396 sv = *v 6397 } 6398 6399 for key, value := range shape { 6400 switch key { 6401 case "ActionId": 6402 if value != nil { 6403 jtv, ok := value.(string) 6404 if !ok { 6405 return fmt.Errorf("expected EntityId to be of type string, got %T instead", value) 6406 } 6407 sv.ActionId = ptr.String(jtv) 6408 } 6409 6410 case "Key": 6411 if value != nil { 6412 jtv, ok := value.(string) 6413 if !ok { 6414 return fmt.Errorf("expected String to be of type string, got %T instead", value) 6415 } 6416 sv.Key = ptr.String(jtv) 6417 } 6418 6419 case "QuestionId": 6420 if value != nil { 6421 jtv, ok := value.(string) 6422 if !ok { 6423 return fmt.Errorf("expected EntityId to be of type string, got %T instead", value) 6424 } 6425 sv.QuestionId = ptr.String(jtv) 6426 } 6427 6428 case "SubjectId": 6429 if value != nil { 6430 jtv, ok := value.(string) 6431 if !ok { 6432 return fmt.Errorf("expected EntityId to be of type string, got %T instead", value) 6433 } 6434 sv.SubjectId = ptr.String(jtv) 6435 } 6436 6437 case "SubjectType": 6438 if value != nil { 6439 jtv, ok := value.(string) 6440 if !ok { 6441 return fmt.Errorf("expected String to be of type string, got %T instead", value) 6442 } 6443 sv.SubjectType = ptr.String(jtv) 6444 } 6445 6446 case "Value": 6447 if value != nil { 6448 jtv, ok := value.(string) 6449 if !ok { 6450 return fmt.Errorf("expected String to be of type string, got %T instead", value) 6451 } 6452 sv.Value = ptr.String(jtv) 6453 } 6454 6455 default: 6456 _, _ = key, value 6457 6458 } 6459 } 6460 *v = sv 6461 return nil 6462} 6463 6464func awsAwsjson11_deserializeDocumentReviewResultDetailList(v *[]types.ReviewResultDetail, value interface{}) error { 6465 if v == nil { 6466 return fmt.Errorf("unexpected nil of type %T", v) 6467 } 6468 if value == nil { 6469 return nil 6470 } 6471 6472 shape, ok := value.([]interface{}) 6473 if !ok { 6474 return fmt.Errorf("unexpected JSON type %v", value) 6475 } 6476 6477 var cv []types.ReviewResultDetail 6478 if *v == nil { 6479 cv = []types.ReviewResultDetail{} 6480 } else { 6481 cv = *v 6482 } 6483 6484 for _, value := range shape { 6485 var col types.ReviewResultDetail 6486 destAddr := &col 6487 if err := awsAwsjson11_deserializeDocumentReviewResultDetail(&destAddr, value); err != nil { 6488 return err 6489 } 6490 col = *destAddr 6491 cv = append(cv, col) 6492 6493 } 6494 *v = cv 6495 return nil 6496} 6497 6498func awsAwsjson11_deserializeDocumentServiceFault(v **types.ServiceFault, value interface{}) error { 6499 if v == nil { 6500 return fmt.Errorf("unexpected nil of type %T", v) 6501 } 6502 if value == nil { 6503 return nil 6504 } 6505 6506 shape, ok := value.(map[string]interface{}) 6507 if !ok { 6508 return fmt.Errorf("unexpected JSON type %v", value) 6509 } 6510 6511 var sv *types.ServiceFault 6512 if *v == nil { 6513 sv = &types.ServiceFault{} 6514 } else { 6515 sv = *v 6516 } 6517 6518 for key, value := range shape { 6519 switch key { 6520 case "Message": 6521 if value != nil { 6522 jtv, ok := value.(string) 6523 if !ok { 6524 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 6525 } 6526 sv.Message = ptr.String(jtv) 6527 } 6528 6529 case "TurkErrorCode": 6530 if value != nil { 6531 jtv, ok := value.(string) 6532 if !ok { 6533 return fmt.Errorf("expected TurkErrorCode to be of type string, got %T instead", value) 6534 } 6535 sv.TurkErrorCode = ptr.String(jtv) 6536 } 6537 6538 default: 6539 _, _ = key, value 6540 6541 } 6542 } 6543 *v = sv 6544 return nil 6545} 6546 6547func awsAwsjson11_deserializeDocumentStringList(v *[]string, value interface{}) error { 6548 if v == nil { 6549 return fmt.Errorf("unexpected nil of type %T", v) 6550 } 6551 if value == nil { 6552 return nil 6553 } 6554 6555 shape, ok := value.([]interface{}) 6556 if !ok { 6557 return fmt.Errorf("unexpected JSON type %v", value) 6558 } 6559 6560 var cv []string 6561 if *v == nil { 6562 cv = []string{} 6563 } else { 6564 cv = *v 6565 } 6566 6567 for _, value := range shape { 6568 var col string 6569 if value != nil { 6570 jtv, ok := value.(string) 6571 if !ok { 6572 return fmt.Errorf("expected String to be of type string, got %T instead", value) 6573 } 6574 col = jtv 6575 } 6576 cv = append(cv, col) 6577 6578 } 6579 *v = cv 6580 return nil 6581} 6582 6583func awsAwsjson11_deserializeDocumentWorkerBlock(v **types.WorkerBlock, value interface{}) error { 6584 if v == nil { 6585 return fmt.Errorf("unexpected nil of type %T", v) 6586 } 6587 if value == nil { 6588 return nil 6589 } 6590 6591 shape, ok := value.(map[string]interface{}) 6592 if !ok { 6593 return fmt.Errorf("unexpected JSON type %v", value) 6594 } 6595 6596 var sv *types.WorkerBlock 6597 if *v == nil { 6598 sv = &types.WorkerBlock{} 6599 } else { 6600 sv = *v 6601 } 6602 6603 for key, value := range shape { 6604 switch key { 6605 case "Reason": 6606 if value != nil { 6607 jtv, ok := value.(string) 6608 if !ok { 6609 return fmt.Errorf("expected String to be of type string, got %T instead", value) 6610 } 6611 sv.Reason = ptr.String(jtv) 6612 } 6613 6614 case "WorkerId": 6615 if value != nil { 6616 jtv, ok := value.(string) 6617 if !ok { 6618 return fmt.Errorf("expected CustomerId to be of type string, got %T instead", value) 6619 } 6620 sv.WorkerId = ptr.String(jtv) 6621 } 6622 6623 default: 6624 _, _ = key, value 6625 6626 } 6627 } 6628 *v = sv 6629 return nil 6630} 6631 6632func awsAwsjson11_deserializeDocumentWorkerBlockList(v *[]types.WorkerBlock, value interface{}) error { 6633 if v == nil { 6634 return fmt.Errorf("unexpected nil of type %T", v) 6635 } 6636 if value == nil { 6637 return nil 6638 } 6639 6640 shape, ok := value.([]interface{}) 6641 if !ok { 6642 return fmt.Errorf("unexpected JSON type %v", value) 6643 } 6644 6645 var cv []types.WorkerBlock 6646 if *v == nil { 6647 cv = []types.WorkerBlock{} 6648 } else { 6649 cv = *v 6650 } 6651 6652 for _, value := range shape { 6653 var col types.WorkerBlock 6654 destAddr := &col 6655 if err := awsAwsjson11_deserializeDocumentWorkerBlock(&destAddr, value); err != nil { 6656 return err 6657 } 6658 col = *destAddr 6659 cv = append(cv, col) 6660 6661 } 6662 *v = cv 6663 return nil 6664} 6665 6666func awsAwsjson11_deserializeOpDocumentAcceptQualificationRequestOutput(v **AcceptQualificationRequestOutput, value interface{}) error { 6667 if v == nil { 6668 return fmt.Errorf("unexpected nil of type %T", v) 6669 } 6670 if value == nil { 6671 return nil 6672 } 6673 6674 shape, ok := value.(map[string]interface{}) 6675 if !ok { 6676 return fmt.Errorf("unexpected JSON type %v", value) 6677 } 6678 6679 var sv *AcceptQualificationRequestOutput 6680 if *v == nil { 6681 sv = &AcceptQualificationRequestOutput{} 6682 } else { 6683 sv = *v 6684 } 6685 6686 for key, value := range shape { 6687 switch key { 6688 default: 6689 _, _ = key, value 6690 6691 } 6692 } 6693 *v = sv 6694 return nil 6695} 6696 6697func awsAwsjson11_deserializeOpDocumentApproveAssignmentOutput(v **ApproveAssignmentOutput, value interface{}) error { 6698 if v == nil { 6699 return fmt.Errorf("unexpected nil of type %T", v) 6700 } 6701 if value == nil { 6702 return nil 6703 } 6704 6705 shape, ok := value.(map[string]interface{}) 6706 if !ok { 6707 return fmt.Errorf("unexpected JSON type %v", value) 6708 } 6709 6710 var sv *ApproveAssignmentOutput 6711 if *v == nil { 6712 sv = &ApproveAssignmentOutput{} 6713 } else { 6714 sv = *v 6715 } 6716 6717 for key, value := range shape { 6718 switch key { 6719 default: 6720 _, _ = key, value 6721 6722 } 6723 } 6724 *v = sv 6725 return nil 6726} 6727 6728func awsAwsjson11_deserializeOpDocumentAssociateQualificationWithWorkerOutput(v **AssociateQualificationWithWorkerOutput, value interface{}) error { 6729 if v == nil { 6730 return fmt.Errorf("unexpected nil of type %T", v) 6731 } 6732 if value == nil { 6733 return nil 6734 } 6735 6736 shape, ok := value.(map[string]interface{}) 6737 if !ok { 6738 return fmt.Errorf("unexpected JSON type %v", value) 6739 } 6740 6741 var sv *AssociateQualificationWithWorkerOutput 6742 if *v == nil { 6743 sv = &AssociateQualificationWithWorkerOutput{} 6744 } else { 6745 sv = *v 6746 } 6747 6748 for key, value := range shape { 6749 switch key { 6750 default: 6751 _, _ = key, value 6752 6753 } 6754 } 6755 *v = sv 6756 return nil 6757} 6758 6759func awsAwsjson11_deserializeOpDocumentCreateAdditionalAssignmentsForHITOutput(v **CreateAdditionalAssignmentsForHITOutput, value interface{}) error { 6760 if v == nil { 6761 return fmt.Errorf("unexpected nil of type %T", v) 6762 } 6763 if value == nil { 6764 return nil 6765 } 6766 6767 shape, ok := value.(map[string]interface{}) 6768 if !ok { 6769 return fmt.Errorf("unexpected JSON type %v", value) 6770 } 6771 6772 var sv *CreateAdditionalAssignmentsForHITOutput 6773 if *v == nil { 6774 sv = &CreateAdditionalAssignmentsForHITOutput{} 6775 } else { 6776 sv = *v 6777 } 6778 6779 for key, value := range shape { 6780 switch key { 6781 default: 6782 _, _ = key, value 6783 6784 } 6785 } 6786 *v = sv 6787 return nil 6788} 6789 6790func awsAwsjson11_deserializeOpDocumentCreateHITOutput(v **CreateHITOutput, value interface{}) error { 6791 if v == nil { 6792 return fmt.Errorf("unexpected nil of type %T", v) 6793 } 6794 if value == nil { 6795 return nil 6796 } 6797 6798 shape, ok := value.(map[string]interface{}) 6799 if !ok { 6800 return fmt.Errorf("unexpected JSON type %v", value) 6801 } 6802 6803 var sv *CreateHITOutput 6804 if *v == nil { 6805 sv = &CreateHITOutput{} 6806 } else { 6807 sv = *v 6808 } 6809 6810 for key, value := range shape { 6811 switch key { 6812 case "HIT": 6813 if err := awsAwsjson11_deserializeDocumentHIT(&sv.HIT, value); err != nil { 6814 return err 6815 } 6816 6817 default: 6818 _, _ = key, value 6819 6820 } 6821 } 6822 *v = sv 6823 return nil 6824} 6825 6826func awsAwsjson11_deserializeOpDocumentCreateHITTypeOutput(v **CreateHITTypeOutput, value interface{}) error { 6827 if v == nil { 6828 return fmt.Errorf("unexpected nil of type %T", v) 6829 } 6830 if value == nil { 6831 return nil 6832 } 6833 6834 shape, ok := value.(map[string]interface{}) 6835 if !ok { 6836 return fmt.Errorf("unexpected JSON type %v", value) 6837 } 6838 6839 var sv *CreateHITTypeOutput 6840 if *v == nil { 6841 sv = &CreateHITTypeOutput{} 6842 } else { 6843 sv = *v 6844 } 6845 6846 for key, value := range shape { 6847 switch key { 6848 case "HITTypeId": 6849 if value != nil { 6850 jtv, ok := value.(string) 6851 if !ok { 6852 return fmt.Errorf("expected EntityId to be of type string, got %T instead", value) 6853 } 6854 sv.HITTypeId = ptr.String(jtv) 6855 } 6856 6857 default: 6858 _, _ = key, value 6859 6860 } 6861 } 6862 *v = sv 6863 return nil 6864} 6865 6866func awsAwsjson11_deserializeOpDocumentCreateHITWithHITTypeOutput(v **CreateHITWithHITTypeOutput, value interface{}) error { 6867 if v == nil { 6868 return fmt.Errorf("unexpected nil of type %T", v) 6869 } 6870 if value == nil { 6871 return nil 6872 } 6873 6874 shape, ok := value.(map[string]interface{}) 6875 if !ok { 6876 return fmt.Errorf("unexpected JSON type %v", value) 6877 } 6878 6879 var sv *CreateHITWithHITTypeOutput 6880 if *v == nil { 6881 sv = &CreateHITWithHITTypeOutput{} 6882 } else { 6883 sv = *v 6884 } 6885 6886 for key, value := range shape { 6887 switch key { 6888 case "HIT": 6889 if err := awsAwsjson11_deserializeDocumentHIT(&sv.HIT, value); err != nil { 6890 return err 6891 } 6892 6893 default: 6894 _, _ = key, value 6895 6896 } 6897 } 6898 *v = sv 6899 return nil 6900} 6901 6902func awsAwsjson11_deserializeOpDocumentCreateQualificationTypeOutput(v **CreateQualificationTypeOutput, value interface{}) error { 6903 if v == nil { 6904 return fmt.Errorf("unexpected nil of type %T", v) 6905 } 6906 if value == nil { 6907 return nil 6908 } 6909 6910 shape, ok := value.(map[string]interface{}) 6911 if !ok { 6912 return fmt.Errorf("unexpected JSON type %v", value) 6913 } 6914 6915 var sv *CreateQualificationTypeOutput 6916 if *v == nil { 6917 sv = &CreateQualificationTypeOutput{} 6918 } else { 6919 sv = *v 6920 } 6921 6922 for key, value := range shape { 6923 switch key { 6924 case "QualificationType": 6925 if err := awsAwsjson11_deserializeDocumentQualificationType(&sv.QualificationType, value); err != nil { 6926 return err 6927 } 6928 6929 default: 6930 _, _ = key, value 6931 6932 } 6933 } 6934 *v = sv 6935 return nil 6936} 6937 6938func awsAwsjson11_deserializeOpDocumentCreateWorkerBlockOutput(v **CreateWorkerBlockOutput, value interface{}) error { 6939 if v == nil { 6940 return fmt.Errorf("unexpected nil of type %T", v) 6941 } 6942 if value == nil { 6943 return nil 6944 } 6945 6946 shape, ok := value.(map[string]interface{}) 6947 if !ok { 6948 return fmt.Errorf("unexpected JSON type %v", value) 6949 } 6950 6951 var sv *CreateWorkerBlockOutput 6952 if *v == nil { 6953 sv = &CreateWorkerBlockOutput{} 6954 } else { 6955 sv = *v 6956 } 6957 6958 for key, value := range shape { 6959 switch key { 6960 default: 6961 _, _ = key, value 6962 6963 } 6964 } 6965 *v = sv 6966 return nil 6967} 6968 6969func awsAwsjson11_deserializeOpDocumentDeleteHITOutput(v **DeleteHITOutput, value interface{}) error { 6970 if v == nil { 6971 return fmt.Errorf("unexpected nil of type %T", v) 6972 } 6973 if value == nil { 6974 return nil 6975 } 6976 6977 shape, ok := value.(map[string]interface{}) 6978 if !ok { 6979 return fmt.Errorf("unexpected JSON type %v", value) 6980 } 6981 6982 var sv *DeleteHITOutput 6983 if *v == nil { 6984 sv = &DeleteHITOutput{} 6985 } else { 6986 sv = *v 6987 } 6988 6989 for key, value := range shape { 6990 switch key { 6991 default: 6992 _, _ = key, value 6993 6994 } 6995 } 6996 *v = sv 6997 return nil 6998} 6999 7000func awsAwsjson11_deserializeOpDocumentDeleteQualificationTypeOutput(v **DeleteQualificationTypeOutput, value interface{}) error { 7001 if v == nil { 7002 return fmt.Errorf("unexpected nil of type %T", v) 7003 } 7004 if value == nil { 7005 return nil 7006 } 7007 7008 shape, ok := value.(map[string]interface{}) 7009 if !ok { 7010 return fmt.Errorf("unexpected JSON type %v", value) 7011 } 7012 7013 var sv *DeleteQualificationTypeOutput 7014 if *v == nil { 7015 sv = &DeleteQualificationTypeOutput{} 7016 } else { 7017 sv = *v 7018 } 7019 7020 for key, value := range shape { 7021 switch key { 7022 default: 7023 _, _ = key, value 7024 7025 } 7026 } 7027 *v = sv 7028 return nil 7029} 7030 7031func awsAwsjson11_deserializeOpDocumentDeleteWorkerBlockOutput(v **DeleteWorkerBlockOutput, value interface{}) error { 7032 if v == nil { 7033 return fmt.Errorf("unexpected nil of type %T", v) 7034 } 7035 if value == nil { 7036 return nil 7037 } 7038 7039 shape, ok := value.(map[string]interface{}) 7040 if !ok { 7041 return fmt.Errorf("unexpected JSON type %v", value) 7042 } 7043 7044 var sv *DeleteWorkerBlockOutput 7045 if *v == nil { 7046 sv = &DeleteWorkerBlockOutput{} 7047 } else { 7048 sv = *v 7049 } 7050 7051 for key, value := range shape { 7052 switch key { 7053 default: 7054 _, _ = key, value 7055 7056 } 7057 } 7058 *v = sv 7059 return nil 7060} 7061 7062func awsAwsjson11_deserializeOpDocumentDisassociateQualificationFromWorkerOutput(v **DisassociateQualificationFromWorkerOutput, value interface{}) error { 7063 if v == nil { 7064 return fmt.Errorf("unexpected nil of type %T", v) 7065 } 7066 if value == nil { 7067 return nil 7068 } 7069 7070 shape, ok := value.(map[string]interface{}) 7071 if !ok { 7072 return fmt.Errorf("unexpected JSON type %v", value) 7073 } 7074 7075 var sv *DisassociateQualificationFromWorkerOutput 7076 if *v == nil { 7077 sv = &DisassociateQualificationFromWorkerOutput{} 7078 } else { 7079 sv = *v 7080 } 7081 7082 for key, value := range shape { 7083 switch key { 7084 default: 7085 _, _ = key, value 7086 7087 } 7088 } 7089 *v = sv 7090 return nil 7091} 7092 7093func awsAwsjson11_deserializeOpDocumentGetAccountBalanceOutput(v **GetAccountBalanceOutput, value interface{}) error { 7094 if v == nil { 7095 return fmt.Errorf("unexpected nil of type %T", v) 7096 } 7097 if value == nil { 7098 return nil 7099 } 7100 7101 shape, ok := value.(map[string]interface{}) 7102 if !ok { 7103 return fmt.Errorf("unexpected JSON type %v", value) 7104 } 7105 7106 var sv *GetAccountBalanceOutput 7107 if *v == nil { 7108 sv = &GetAccountBalanceOutput{} 7109 } else { 7110 sv = *v 7111 } 7112 7113 for key, value := range shape { 7114 switch key { 7115 case "AvailableBalance": 7116 if value != nil { 7117 jtv, ok := value.(string) 7118 if !ok { 7119 return fmt.Errorf("expected CurrencyAmount to be of type string, got %T instead", value) 7120 } 7121 sv.AvailableBalance = ptr.String(jtv) 7122 } 7123 7124 case "OnHoldBalance": 7125 if value != nil { 7126 jtv, ok := value.(string) 7127 if !ok { 7128 return fmt.Errorf("expected CurrencyAmount to be of type string, got %T instead", value) 7129 } 7130 sv.OnHoldBalance = ptr.String(jtv) 7131 } 7132 7133 default: 7134 _, _ = key, value 7135 7136 } 7137 } 7138 *v = sv 7139 return nil 7140} 7141 7142func awsAwsjson11_deserializeOpDocumentGetAssignmentOutput(v **GetAssignmentOutput, value interface{}) error { 7143 if v == nil { 7144 return fmt.Errorf("unexpected nil of type %T", v) 7145 } 7146 if value == nil { 7147 return nil 7148 } 7149 7150 shape, ok := value.(map[string]interface{}) 7151 if !ok { 7152 return fmt.Errorf("unexpected JSON type %v", value) 7153 } 7154 7155 var sv *GetAssignmentOutput 7156 if *v == nil { 7157 sv = &GetAssignmentOutput{} 7158 } else { 7159 sv = *v 7160 } 7161 7162 for key, value := range shape { 7163 switch key { 7164 case "Assignment": 7165 if err := awsAwsjson11_deserializeDocumentAssignment(&sv.Assignment, value); err != nil { 7166 return err 7167 } 7168 7169 case "HIT": 7170 if err := awsAwsjson11_deserializeDocumentHIT(&sv.HIT, value); err != nil { 7171 return err 7172 } 7173 7174 default: 7175 _, _ = key, value 7176 7177 } 7178 } 7179 *v = sv 7180 return nil 7181} 7182 7183func awsAwsjson11_deserializeOpDocumentGetFileUploadURLOutput(v **GetFileUploadURLOutput, value interface{}) error { 7184 if v == nil { 7185 return fmt.Errorf("unexpected nil of type %T", v) 7186 } 7187 if value == nil { 7188 return nil 7189 } 7190 7191 shape, ok := value.(map[string]interface{}) 7192 if !ok { 7193 return fmt.Errorf("unexpected JSON type %v", value) 7194 } 7195 7196 var sv *GetFileUploadURLOutput 7197 if *v == nil { 7198 sv = &GetFileUploadURLOutput{} 7199 } else { 7200 sv = *v 7201 } 7202 7203 for key, value := range shape { 7204 switch key { 7205 case "FileUploadURL": 7206 if value != nil { 7207 jtv, ok := value.(string) 7208 if !ok { 7209 return fmt.Errorf("expected String to be of type string, got %T instead", value) 7210 } 7211 sv.FileUploadURL = ptr.String(jtv) 7212 } 7213 7214 default: 7215 _, _ = key, value 7216 7217 } 7218 } 7219 *v = sv 7220 return nil 7221} 7222 7223func awsAwsjson11_deserializeOpDocumentGetHITOutput(v **GetHITOutput, value interface{}) error { 7224 if v == nil { 7225 return fmt.Errorf("unexpected nil of type %T", v) 7226 } 7227 if value == nil { 7228 return nil 7229 } 7230 7231 shape, ok := value.(map[string]interface{}) 7232 if !ok { 7233 return fmt.Errorf("unexpected JSON type %v", value) 7234 } 7235 7236 var sv *GetHITOutput 7237 if *v == nil { 7238 sv = &GetHITOutput{} 7239 } else { 7240 sv = *v 7241 } 7242 7243 for key, value := range shape { 7244 switch key { 7245 case "HIT": 7246 if err := awsAwsjson11_deserializeDocumentHIT(&sv.HIT, value); err != nil { 7247 return err 7248 } 7249 7250 default: 7251 _, _ = key, value 7252 7253 } 7254 } 7255 *v = sv 7256 return nil 7257} 7258 7259func awsAwsjson11_deserializeOpDocumentGetQualificationScoreOutput(v **GetQualificationScoreOutput, value interface{}) error { 7260 if v == nil { 7261 return fmt.Errorf("unexpected nil of type %T", v) 7262 } 7263 if value == nil { 7264 return nil 7265 } 7266 7267 shape, ok := value.(map[string]interface{}) 7268 if !ok { 7269 return fmt.Errorf("unexpected JSON type %v", value) 7270 } 7271 7272 var sv *GetQualificationScoreOutput 7273 if *v == nil { 7274 sv = &GetQualificationScoreOutput{} 7275 } else { 7276 sv = *v 7277 } 7278 7279 for key, value := range shape { 7280 switch key { 7281 case "Qualification": 7282 if err := awsAwsjson11_deserializeDocumentQualification(&sv.Qualification, value); err != nil { 7283 return err 7284 } 7285 7286 default: 7287 _, _ = key, value 7288 7289 } 7290 } 7291 *v = sv 7292 return nil 7293} 7294 7295func awsAwsjson11_deserializeOpDocumentGetQualificationTypeOutput(v **GetQualificationTypeOutput, value interface{}) error { 7296 if v == nil { 7297 return fmt.Errorf("unexpected nil of type %T", v) 7298 } 7299 if value == nil { 7300 return nil 7301 } 7302 7303 shape, ok := value.(map[string]interface{}) 7304 if !ok { 7305 return fmt.Errorf("unexpected JSON type %v", value) 7306 } 7307 7308 var sv *GetQualificationTypeOutput 7309 if *v == nil { 7310 sv = &GetQualificationTypeOutput{} 7311 } else { 7312 sv = *v 7313 } 7314 7315 for key, value := range shape { 7316 switch key { 7317 case "QualificationType": 7318 if err := awsAwsjson11_deserializeDocumentQualificationType(&sv.QualificationType, value); err != nil { 7319 return err 7320 } 7321 7322 default: 7323 _, _ = key, value 7324 7325 } 7326 } 7327 *v = sv 7328 return nil 7329} 7330 7331func awsAwsjson11_deserializeOpDocumentListAssignmentsForHITOutput(v **ListAssignmentsForHITOutput, value interface{}) error { 7332 if v == nil { 7333 return fmt.Errorf("unexpected nil of type %T", v) 7334 } 7335 if value == nil { 7336 return nil 7337 } 7338 7339 shape, ok := value.(map[string]interface{}) 7340 if !ok { 7341 return fmt.Errorf("unexpected JSON type %v", value) 7342 } 7343 7344 var sv *ListAssignmentsForHITOutput 7345 if *v == nil { 7346 sv = &ListAssignmentsForHITOutput{} 7347 } else { 7348 sv = *v 7349 } 7350 7351 for key, value := range shape { 7352 switch key { 7353 case "Assignments": 7354 if err := awsAwsjson11_deserializeDocumentAssignmentList(&sv.Assignments, value); err != nil { 7355 return err 7356 } 7357 7358 case "NextToken": 7359 if value != nil { 7360 jtv, ok := value.(string) 7361 if !ok { 7362 return fmt.Errorf("expected PaginationToken to be of type string, got %T instead", value) 7363 } 7364 sv.NextToken = ptr.String(jtv) 7365 } 7366 7367 case "NumResults": 7368 if value != nil { 7369 jtv, ok := value.(json.Number) 7370 if !ok { 7371 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 7372 } 7373 i64, err := jtv.Int64() 7374 if err != nil { 7375 return err 7376 } 7377 sv.NumResults = ptr.Int32(int32(i64)) 7378 } 7379 7380 default: 7381 _, _ = key, value 7382 7383 } 7384 } 7385 *v = sv 7386 return nil 7387} 7388 7389func awsAwsjson11_deserializeOpDocumentListBonusPaymentsOutput(v **ListBonusPaymentsOutput, value interface{}) error { 7390 if v == nil { 7391 return fmt.Errorf("unexpected nil of type %T", v) 7392 } 7393 if value == nil { 7394 return nil 7395 } 7396 7397 shape, ok := value.(map[string]interface{}) 7398 if !ok { 7399 return fmt.Errorf("unexpected JSON type %v", value) 7400 } 7401 7402 var sv *ListBonusPaymentsOutput 7403 if *v == nil { 7404 sv = &ListBonusPaymentsOutput{} 7405 } else { 7406 sv = *v 7407 } 7408 7409 for key, value := range shape { 7410 switch key { 7411 case "BonusPayments": 7412 if err := awsAwsjson11_deserializeDocumentBonusPaymentList(&sv.BonusPayments, value); err != nil { 7413 return err 7414 } 7415 7416 case "NextToken": 7417 if value != nil { 7418 jtv, ok := value.(string) 7419 if !ok { 7420 return fmt.Errorf("expected PaginationToken to be of type string, got %T instead", value) 7421 } 7422 sv.NextToken = ptr.String(jtv) 7423 } 7424 7425 case "NumResults": 7426 if value != nil { 7427 jtv, ok := value.(json.Number) 7428 if !ok { 7429 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 7430 } 7431 i64, err := jtv.Int64() 7432 if err != nil { 7433 return err 7434 } 7435 sv.NumResults = ptr.Int32(int32(i64)) 7436 } 7437 7438 default: 7439 _, _ = key, value 7440 7441 } 7442 } 7443 *v = sv 7444 return nil 7445} 7446 7447func awsAwsjson11_deserializeOpDocumentListHITsForQualificationTypeOutput(v **ListHITsForQualificationTypeOutput, value interface{}) error { 7448 if v == nil { 7449 return fmt.Errorf("unexpected nil of type %T", v) 7450 } 7451 if value == nil { 7452 return nil 7453 } 7454 7455 shape, ok := value.(map[string]interface{}) 7456 if !ok { 7457 return fmt.Errorf("unexpected JSON type %v", value) 7458 } 7459 7460 var sv *ListHITsForQualificationTypeOutput 7461 if *v == nil { 7462 sv = &ListHITsForQualificationTypeOutput{} 7463 } else { 7464 sv = *v 7465 } 7466 7467 for key, value := range shape { 7468 switch key { 7469 case "HITs": 7470 if err := awsAwsjson11_deserializeDocumentHITList(&sv.HITs, value); err != nil { 7471 return err 7472 } 7473 7474 case "NextToken": 7475 if value != nil { 7476 jtv, ok := value.(string) 7477 if !ok { 7478 return fmt.Errorf("expected PaginationToken to be of type string, got %T instead", value) 7479 } 7480 sv.NextToken = ptr.String(jtv) 7481 } 7482 7483 case "NumResults": 7484 if value != nil { 7485 jtv, ok := value.(json.Number) 7486 if !ok { 7487 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 7488 } 7489 i64, err := jtv.Int64() 7490 if err != nil { 7491 return err 7492 } 7493 sv.NumResults = ptr.Int32(int32(i64)) 7494 } 7495 7496 default: 7497 _, _ = key, value 7498 7499 } 7500 } 7501 *v = sv 7502 return nil 7503} 7504 7505func awsAwsjson11_deserializeOpDocumentListHITsOutput(v **ListHITsOutput, value interface{}) error { 7506 if v == nil { 7507 return fmt.Errorf("unexpected nil of type %T", v) 7508 } 7509 if value == nil { 7510 return nil 7511 } 7512 7513 shape, ok := value.(map[string]interface{}) 7514 if !ok { 7515 return fmt.Errorf("unexpected JSON type %v", value) 7516 } 7517 7518 var sv *ListHITsOutput 7519 if *v == nil { 7520 sv = &ListHITsOutput{} 7521 } else { 7522 sv = *v 7523 } 7524 7525 for key, value := range shape { 7526 switch key { 7527 case "HITs": 7528 if err := awsAwsjson11_deserializeDocumentHITList(&sv.HITs, value); err != nil { 7529 return err 7530 } 7531 7532 case "NextToken": 7533 if value != nil { 7534 jtv, ok := value.(string) 7535 if !ok { 7536 return fmt.Errorf("expected PaginationToken to be of type string, got %T instead", value) 7537 } 7538 sv.NextToken = ptr.String(jtv) 7539 } 7540 7541 case "NumResults": 7542 if value != nil { 7543 jtv, ok := value.(json.Number) 7544 if !ok { 7545 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 7546 } 7547 i64, err := jtv.Int64() 7548 if err != nil { 7549 return err 7550 } 7551 sv.NumResults = ptr.Int32(int32(i64)) 7552 } 7553 7554 default: 7555 _, _ = key, value 7556 7557 } 7558 } 7559 *v = sv 7560 return nil 7561} 7562 7563func awsAwsjson11_deserializeOpDocumentListQualificationRequestsOutput(v **ListQualificationRequestsOutput, value interface{}) error { 7564 if v == nil { 7565 return fmt.Errorf("unexpected nil of type %T", v) 7566 } 7567 if value == nil { 7568 return nil 7569 } 7570 7571 shape, ok := value.(map[string]interface{}) 7572 if !ok { 7573 return fmt.Errorf("unexpected JSON type %v", value) 7574 } 7575 7576 var sv *ListQualificationRequestsOutput 7577 if *v == nil { 7578 sv = &ListQualificationRequestsOutput{} 7579 } else { 7580 sv = *v 7581 } 7582 7583 for key, value := range shape { 7584 switch key { 7585 case "NextToken": 7586 if value != nil { 7587 jtv, ok := value.(string) 7588 if !ok { 7589 return fmt.Errorf("expected PaginationToken to be of type string, got %T instead", value) 7590 } 7591 sv.NextToken = ptr.String(jtv) 7592 } 7593 7594 case "NumResults": 7595 if value != nil { 7596 jtv, ok := value.(json.Number) 7597 if !ok { 7598 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 7599 } 7600 i64, err := jtv.Int64() 7601 if err != nil { 7602 return err 7603 } 7604 sv.NumResults = ptr.Int32(int32(i64)) 7605 } 7606 7607 case "QualificationRequests": 7608 if err := awsAwsjson11_deserializeDocumentQualificationRequestList(&sv.QualificationRequests, value); err != nil { 7609 return err 7610 } 7611 7612 default: 7613 _, _ = key, value 7614 7615 } 7616 } 7617 *v = sv 7618 return nil 7619} 7620 7621func awsAwsjson11_deserializeOpDocumentListQualificationTypesOutput(v **ListQualificationTypesOutput, value interface{}) error { 7622 if v == nil { 7623 return fmt.Errorf("unexpected nil of type %T", v) 7624 } 7625 if value == nil { 7626 return nil 7627 } 7628 7629 shape, ok := value.(map[string]interface{}) 7630 if !ok { 7631 return fmt.Errorf("unexpected JSON type %v", value) 7632 } 7633 7634 var sv *ListQualificationTypesOutput 7635 if *v == nil { 7636 sv = &ListQualificationTypesOutput{} 7637 } else { 7638 sv = *v 7639 } 7640 7641 for key, value := range shape { 7642 switch key { 7643 case "NextToken": 7644 if value != nil { 7645 jtv, ok := value.(string) 7646 if !ok { 7647 return fmt.Errorf("expected PaginationToken to be of type string, got %T instead", value) 7648 } 7649 sv.NextToken = ptr.String(jtv) 7650 } 7651 7652 case "NumResults": 7653 if value != nil { 7654 jtv, ok := value.(json.Number) 7655 if !ok { 7656 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 7657 } 7658 i64, err := jtv.Int64() 7659 if err != nil { 7660 return err 7661 } 7662 sv.NumResults = ptr.Int32(int32(i64)) 7663 } 7664 7665 case "QualificationTypes": 7666 if err := awsAwsjson11_deserializeDocumentQualificationTypeList(&sv.QualificationTypes, value); err != nil { 7667 return err 7668 } 7669 7670 default: 7671 _, _ = key, value 7672 7673 } 7674 } 7675 *v = sv 7676 return nil 7677} 7678 7679func awsAwsjson11_deserializeOpDocumentListReviewableHITsOutput(v **ListReviewableHITsOutput, value interface{}) error { 7680 if v == nil { 7681 return fmt.Errorf("unexpected nil of type %T", v) 7682 } 7683 if value == nil { 7684 return nil 7685 } 7686 7687 shape, ok := value.(map[string]interface{}) 7688 if !ok { 7689 return fmt.Errorf("unexpected JSON type %v", value) 7690 } 7691 7692 var sv *ListReviewableHITsOutput 7693 if *v == nil { 7694 sv = &ListReviewableHITsOutput{} 7695 } else { 7696 sv = *v 7697 } 7698 7699 for key, value := range shape { 7700 switch key { 7701 case "HITs": 7702 if err := awsAwsjson11_deserializeDocumentHITList(&sv.HITs, value); err != nil { 7703 return err 7704 } 7705 7706 case "NextToken": 7707 if value != nil { 7708 jtv, ok := value.(string) 7709 if !ok { 7710 return fmt.Errorf("expected PaginationToken to be of type string, got %T instead", value) 7711 } 7712 sv.NextToken = ptr.String(jtv) 7713 } 7714 7715 case "NumResults": 7716 if value != nil { 7717 jtv, ok := value.(json.Number) 7718 if !ok { 7719 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 7720 } 7721 i64, err := jtv.Int64() 7722 if err != nil { 7723 return err 7724 } 7725 sv.NumResults = ptr.Int32(int32(i64)) 7726 } 7727 7728 default: 7729 _, _ = key, value 7730 7731 } 7732 } 7733 *v = sv 7734 return nil 7735} 7736 7737func awsAwsjson11_deserializeOpDocumentListReviewPolicyResultsForHITOutput(v **ListReviewPolicyResultsForHITOutput, value interface{}) error { 7738 if v == nil { 7739 return fmt.Errorf("unexpected nil of type %T", v) 7740 } 7741 if value == nil { 7742 return nil 7743 } 7744 7745 shape, ok := value.(map[string]interface{}) 7746 if !ok { 7747 return fmt.Errorf("unexpected JSON type %v", value) 7748 } 7749 7750 var sv *ListReviewPolicyResultsForHITOutput 7751 if *v == nil { 7752 sv = &ListReviewPolicyResultsForHITOutput{} 7753 } else { 7754 sv = *v 7755 } 7756 7757 for key, value := range shape { 7758 switch key { 7759 case "AssignmentReviewPolicy": 7760 if err := awsAwsjson11_deserializeDocumentReviewPolicy(&sv.AssignmentReviewPolicy, value); err != nil { 7761 return err 7762 } 7763 7764 case "AssignmentReviewReport": 7765 if err := awsAwsjson11_deserializeDocumentReviewReport(&sv.AssignmentReviewReport, value); err != nil { 7766 return err 7767 } 7768 7769 case "HITId": 7770 if value != nil { 7771 jtv, ok := value.(string) 7772 if !ok { 7773 return fmt.Errorf("expected EntityId to be of type string, got %T instead", value) 7774 } 7775 sv.HITId = ptr.String(jtv) 7776 } 7777 7778 case "HITReviewPolicy": 7779 if err := awsAwsjson11_deserializeDocumentReviewPolicy(&sv.HITReviewPolicy, value); err != nil { 7780 return err 7781 } 7782 7783 case "HITReviewReport": 7784 if err := awsAwsjson11_deserializeDocumentReviewReport(&sv.HITReviewReport, value); err != nil { 7785 return err 7786 } 7787 7788 case "NextToken": 7789 if value != nil { 7790 jtv, ok := value.(string) 7791 if !ok { 7792 return fmt.Errorf("expected PaginationToken to be of type string, got %T instead", value) 7793 } 7794 sv.NextToken = ptr.String(jtv) 7795 } 7796 7797 default: 7798 _, _ = key, value 7799 7800 } 7801 } 7802 *v = sv 7803 return nil 7804} 7805 7806func awsAwsjson11_deserializeOpDocumentListWorkerBlocksOutput(v **ListWorkerBlocksOutput, value interface{}) error { 7807 if v == nil { 7808 return fmt.Errorf("unexpected nil of type %T", v) 7809 } 7810 if value == nil { 7811 return nil 7812 } 7813 7814 shape, ok := value.(map[string]interface{}) 7815 if !ok { 7816 return fmt.Errorf("unexpected JSON type %v", value) 7817 } 7818 7819 var sv *ListWorkerBlocksOutput 7820 if *v == nil { 7821 sv = &ListWorkerBlocksOutput{} 7822 } else { 7823 sv = *v 7824 } 7825 7826 for key, value := range shape { 7827 switch key { 7828 case "NextToken": 7829 if value != nil { 7830 jtv, ok := value.(string) 7831 if !ok { 7832 return fmt.Errorf("expected PaginationToken to be of type string, got %T instead", value) 7833 } 7834 sv.NextToken = ptr.String(jtv) 7835 } 7836 7837 case "NumResults": 7838 if value != nil { 7839 jtv, ok := value.(json.Number) 7840 if !ok { 7841 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 7842 } 7843 i64, err := jtv.Int64() 7844 if err != nil { 7845 return err 7846 } 7847 sv.NumResults = ptr.Int32(int32(i64)) 7848 } 7849 7850 case "WorkerBlocks": 7851 if err := awsAwsjson11_deserializeDocumentWorkerBlockList(&sv.WorkerBlocks, value); err != nil { 7852 return err 7853 } 7854 7855 default: 7856 _, _ = key, value 7857 7858 } 7859 } 7860 *v = sv 7861 return nil 7862} 7863 7864func awsAwsjson11_deserializeOpDocumentListWorkersWithQualificationTypeOutput(v **ListWorkersWithQualificationTypeOutput, value interface{}) error { 7865 if v == nil { 7866 return fmt.Errorf("unexpected nil of type %T", v) 7867 } 7868 if value == nil { 7869 return nil 7870 } 7871 7872 shape, ok := value.(map[string]interface{}) 7873 if !ok { 7874 return fmt.Errorf("unexpected JSON type %v", value) 7875 } 7876 7877 var sv *ListWorkersWithQualificationTypeOutput 7878 if *v == nil { 7879 sv = &ListWorkersWithQualificationTypeOutput{} 7880 } else { 7881 sv = *v 7882 } 7883 7884 for key, value := range shape { 7885 switch key { 7886 case "NextToken": 7887 if value != nil { 7888 jtv, ok := value.(string) 7889 if !ok { 7890 return fmt.Errorf("expected PaginationToken to be of type string, got %T instead", value) 7891 } 7892 sv.NextToken = ptr.String(jtv) 7893 } 7894 7895 case "NumResults": 7896 if value != nil { 7897 jtv, ok := value.(json.Number) 7898 if !ok { 7899 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 7900 } 7901 i64, err := jtv.Int64() 7902 if err != nil { 7903 return err 7904 } 7905 sv.NumResults = ptr.Int32(int32(i64)) 7906 } 7907 7908 case "Qualifications": 7909 if err := awsAwsjson11_deserializeDocumentQualificationList(&sv.Qualifications, value); err != nil { 7910 return err 7911 } 7912 7913 default: 7914 _, _ = key, value 7915 7916 } 7917 } 7918 *v = sv 7919 return nil 7920} 7921 7922func awsAwsjson11_deserializeOpDocumentNotifyWorkersOutput(v **NotifyWorkersOutput, value interface{}) error { 7923 if v == nil { 7924 return fmt.Errorf("unexpected nil of type %T", v) 7925 } 7926 if value == nil { 7927 return nil 7928 } 7929 7930 shape, ok := value.(map[string]interface{}) 7931 if !ok { 7932 return fmt.Errorf("unexpected JSON type %v", value) 7933 } 7934 7935 var sv *NotifyWorkersOutput 7936 if *v == nil { 7937 sv = &NotifyWorkersOutput{} 7938 } else { 7939 sv = *v 7940 } 7941 7942 for key, value := range shape { 7943 switch key { 7944 case "NotifyWorkersFailureStatuses": 7945 if err := awsAwsjson11_deserializeDocumentNotifyWorkersFailureStatusList(&sv.NotifyWorkersFailureStatuses, value); err != nil { 7946 return err 7947 } 7948 7949 default: 7950 _, _ = key, value 7951 7952 } 7953 } 7954 *v = sv 7955 return nil 7956} 7957 7958func awsAwsjson11_deserializeOpDocumentRejectAssignmentOutput(v **RejectAssignmentOutput, value interface{}) error { 7959 if v == nil { 7960 return fmt.Errorf("unexpected nil of type %T", v) 7961 } 7962 if value == nil { 7963 return nil 7964 } 7965 7966 shape, ok := value.(map[string]interface{}) 7967 if !ok { 7968 return fmt.Errorf("unexpected JSON type %v", value) 7969 } 7970 7971 var sv *RejectAssignmentOutput 7972 if *v == nil { 7973 sv = &RejectAssignmentOutput{} 7974 } else { 7975 sv = *v 7976 } 7977 7978 for key, value := range shape { 7979 switch key { 7980 default: 7981 _, _ = key, value 7982 7983 } 7984 } 7985 *v = sv 7986 return nil 7987} 7988 7989func awsAwsjson11_deserializeOpDocumentRejectQualificationRequestOutput(v **RejectQualificationRequestOutput, value interface{}) error { 7990 if v == nil { 7991 return fmt.Errorf("unexpected nil of type %T", v) 7992 } 7993 if value == nil { 7994 return nil 7995 } 7996 7997 shape, ok := value.(map[string]interface{}) 7998 if !ok { 7999 return fmt.Errorf("unexpected JSON type %v", value) 8000 } 8001 8002 var sv *RejectQualificationRequestOutput 8003 if *v == nil { 8004 sv = &RejectQualificationRequestOutput{} 8005 } else { 8006 sv = *v 8007 } 8008 8009 for key, value := range shape { 8010 switch key { 8011 default: 8012 _, _ = key, value 8013 8014 } 8015 } 8016 *v = sv 8017 return nil 8018} 8019 8020func awsAwsjson11_deserializeOpDocumentSendBonusOutput(v **SendBonusOutput, value interface{}) error { 8021 if v == nil { 8022 return fmt.Errorf("unexpected nil of type %T", v) 8023 } 8024 if value == nil { 8025 return nil 8026 } 8027 8028 shape, ok := value.(map[string]interface{}) 8029 if !ok { 8030 return fmt.Errorf("unexpected JSON type %v", value) 8031 } 8032 8033 var sv *SendBonusOutput 8034 if *v == nil { 8035 sv = &SendBonusOutput{} 8036 } else { 8037 sv = *v 8038 } 8039 8040 for key, value := range shape { 8041 switch key { 8042 default: 8043 _, _ = key, value 8044 8045 } 8046 } 8047 *v = sv 8048 return nil 8049} 8050 8051func awsAwsjson11_deserializeOpDocumentSendTestEventNotificationOutput(v **SendTestEventNotificationOutput, value interface{}) error { 8052 if v == nil { 8053 return fmt.Errorf("unexpected nil of type %T", v) 8054 } 8055 if value == nil { 8056 return nil 8057 } 8058 8059 shape, ok := value.(map[string]interface{}) 8060 if !ok { 8061 return fmt.Errorf("unexpected JSON type %v", value) 8062 } 8063 8064 var sv *SendTestEventNotificationOutput 8065 if *v == nil { 8066 sv = &SendTestEventNotificationOutput{} 8067 } else { 8068 sv = *v 8069 } 8070 8071 for key, value := range shape { 8072 switch key { 8073 default: 8074 _, _ = key, value 8075 8076 } 8077 } 8078 *v = sv 8079 return nil 8080} 8081 8082func awsAwsjson11_deserializeOpDocumentUpdateExpirationForHITOutput(v **UpdateExpirationForHITOutput, value interface{}) error { 8083 if v == nil { 8084 return fmt.Errorf("unexpected nil of type %T", v) 8085 } 8086 if value == nil { 8087 return nil 8088 } 8089 8090 shape, ok := value.(map[string]interface{}) 8091 if !ok { 8092 return fmt.Errorf("unexpected JSON type %v", value) 8093 } 8094 8095 var sv *UpdateExpirationForHITOutput 8096 if *v == nil { 8097 sv = &UpdateExpirationForHITOutput{} 8098 } else { 8099 sv = *v 8100 } 8101 8102 for key, value := range shape { 8103 switch key { 8104 default: 8105 _, _ = key, value 8106 8107 } 8108 } 8109 *v = sv 8110 return nil 8111} 8112 8113func awsAwsjson11_deserializeOpDocumentUpdateHITReviewStatusOutput(v **UpdateHITReviewStatusOutput, value interface{}) error { 8114 if v == nil { 8115 return fmt.Errorf("unexpected nil of type %T", v) 8116 } 8117 if value == nil { 8118 return nil 8119 } 8120 8121 shape, ok := value.(map[string]interface{}) 8122 if !ok { 8123 return fmt.Errorf("unexpected JSON type %v", value) 8124 } 8125 8126 var sv *UpdateHITReviewStatusOutput 8127 if *v == nil { 8128 sv = &UpdateHITReviewStatusOutput{} 8129 } else { 8130 sv = *v 8131 } 8132 8133 for key, value := range shape { 8134 switch key { 8135 default: 8136 _, _ = key, value 8137 8138 } 8139 } 8140 *v = sv 8141 return nil 8142} 8143 8144func awsAwsjson11_deserializeOpDocumentUpdateHITTypeOfHITOutput(v **UpdateHITTypeOfHITOutput, value interface{}) error { 8145 if v == nil { 8146 return fmt.Errorf("unexpected nil of type %T", v) 8147 } 8148 if value == nil { 8149 return nil 8150 } 8151 8152 shape, ok := value.(map[string]interface{}) 8153 if !ok { 8154 return fmt.Errorf("unexpected JSON type %v", value) 8155 } 8156 8157 var sv *UpdateHITTypeOfHITOutput 8158 if *v == nil { 8159 sv = &UpdateHITTypeOfHITOutput{} 8160 } else { 8161 sv = *v 8162 } 8163 8164 for key, value := range shape { 8165 switch key { 8166 default: 8167 _, _ = key, value 8168 8169 } 8170 } 8171 *v = sv 8172 return nil 8173} 8174 8175func awsAwsjson11_deserializeOpDocumentUpdateNotificationSettingsOutput(v **UpdateNotificationSettingsOutput, value interface{}) error { 8176 if v == nil { 8177 return fmt.Errorf("unexpected nil of type %T", v) 8178 } 8179 if value == nil { 8180 return nil 8181 } 8182 8183 shape, ok := value.(map[string]interface{}) 8184 if !ok { 8185 return fmt.Errorf("unexpected JSON type %v", value) 8186 } 8187 8188 var sv *UpdateNotificationSettingsOutput 8189 if *v == nil { 8190 sv = &UpdateNotificationSettingsOutput{} 8191 } else { 8192 sv = *v 8193 } 8194 8195 for key, value := range shape { 8196 switch key { 8197 default: 8198 _, _ = key, value 8199 8200 } 8201 } 8202 *v = sv 8203 return nil 8204} 8205 8206func awsAwsjson11_deserializeOpDocumentUpdateQualificationTypeOutput(v **UpdateQualificationTypeOutput, value interface{}) error { 8207 if v == nil { 8208 return fmt.Errorf("unexpected nil of type %T", v) 8209 } 8210 if value == nil { 8211 return nil 8212 } 8213 8214 shape, ok := value.(map[string]interface{}) 8215 if !ok { 8216 return fmt.Errorf("unexpected JSON type %v", value) 8217 } 8218 8219 var sv *UpdateQualificationTypeOutput 8220 if *v == nil { 8221 sv = &UpdateQualificationTypeOutput{} 8222 } else { 8223 sv = *v 8224 } 8225 8226 for key, value := range shape { 8227 switch key { 8228 case "QualificationType": 8229 if err := awsAwsjson11_deserializeDocumentQualificationType(&sv.QualificationType, value); err != nil { 8230 return err 8231 } 8232 8233 default: 8234 _, _ = key, value 8235 8236 } 8237 } 8238 *v = sv 8239 return nil 8240} 8241