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 jtv, ok := value.(json.Number) 4563 if !ok { 4564 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 4565 } 4566 f64, err := jtv.Float64() 4567 if err != nil { 4568 return err 4569 } 4570 sv.AcceptTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 4571 } 4572 4573 case "Answer": 4574 if value != nil { 4575 jtv, ok := value.(string) 4576 if !ok { 4577 return fmt.Errorf("expected String to be of type string, got %T instead", value) 4578 } 4579 sv.Answer = ptr.String(jtv) 4580 } 4581 4582 case "ApprovalTime": 4583 if value != nil { 4584 jtv, ok := value.(json.Number) 4585 if !ok { 4586 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 4587 } 4588 f64, err := jtv.Float64() 4589 if err != nil { 4590 return err 4591 } 4592 sv.ApprovalTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 4593 } 4594 4595 case "AssignmentId": 4596 if value != nil { 4597 jtv, ok := value.(string) 4598 if !ok { 4599 return fmt.Errorf("expected EntityId to be of type string, got %T instead", value) 4600 } 4601 sv.AssignmentId = ptr.String(jtv) 4602 } 4603 4604 case "AssignmentStatus": 4605 if value != nil { 4606 jtv, ok := value.(string) 4607 if !ok { 4608 return fmt.Errorf("expected AssignmentStatus to be of type string, got %T instead", value) 4609 } 4610 sv.AssignmentStatus = types.AssignmentStatus(jtv) 4611 } 4612 4613 case "AutoApprovalTime": 4614 if value != nil { 4615 jtv, ok := value.(json.Number) 4616 if !ok { 4617 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 4618 } 4619 f64, err := jtv.Float64() 4620 if err != nil { 4621 return err 4622 } 4623 sv.AutoApprovalTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 4624 } 4625 4626 case "Deadline": 4627 if value != nil { 4628 jtv, ok := value.(json.Number) 4629 if !ok { 4630 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 4631 } 4632 f64, err := jtv.Float64() 4633 if err != nil { 4634 return err 4635 } 4636 sv.Deadline = ptr.Time(smithytime.ParseEpochSeconds(f64)) 4637 } 4638 4639 case "HITId": 4640 if value != nil { 4641 jtv, ok := value.(string) 4642 if !ok { 4643 return fmt.Errorf("expected EntityId to be of type string, got %T instead", value) 4644 } 4645 sv.HITId = ptr.String(jtv) 4646 } 4647 4648 case "RejectionTime": 4649 if value != nil { 4650 jtv, ok := value.(json.Number) 4651 if !ok { 4652 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 4653 } 4654 f64, err := jtv.Float64() 4655 if err != nil { 4656 return err 4657 } 4658 sv.RejectionTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 4659 } 4660 4661 case "RequesterFeedback": 4662 if value != nil { 4663 jtv, ok := value.(string) 4664 if !ok { 4665 return fmt.Errorf("expected String to be of type string, got %T instead", value) 4666 } 4667 sv.RequesterFeedback = ptr.String(jtv) 4668 } 4669 4670 case "SubmitTime": 4671 if value != nil { 4672 jtv, ok := value.(json.Number) 4673 if !ok { 4674 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 4675 } 4676 f64, err := jtv.Float64() 4677 if err != nil { 4678 return err 4679 } 4680 sv.SubmitTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 4681 } 4682 4683 case "WorkerId": 4684 if value != nil { 4685 jtv, ok := value.(string) 4686 if !ok { 4687 return fmt.Errorf("expected CustomerId to be of type string, got %T instead", value) 4688 } 4689 sv.WorkerId = ptr.String(jtv) 4690 } 4691 4692 default: 4693 _, _ = key, value 4694 4695 } 4696 } 4697 *v = sv 4698 return nil 4699} 4700 4701func awsAwsjson11_deserializeDocumentAssignmentList(v *[]types.Assignment, value interface{}) error { 4702 if v == nil { 4703 return fmt.Errorf("unexpected nil of type %T", v) 4704 } 4705 if value == nil { 4706 return nil 4707 } 4708 4709 shape, ok := value.([]interface{}) 4710 if !ok { 4711 return fmt.Errorf("unexpected JSON type %v", value) 4712 } 4713 4714 var cv []types.Assignment 4715 if *v == nil { 4716 cv = []types.Assignment{} 4717 } else { 4718 cv = *v 4719 } 4720 4721 for _, value := range shape { 4722 var col types.Assignment 4723 destAddr := &col 4724 if err := awsAwsjson11_deserializeDocumentAssignment(&destAddr, value); err != nil { 4725 return err 4726 } 4727 col = *destAddr 4728 cv = append(cv, col) 4729 4730 } 4731 *v = cv 4732 return nil 4733} 4734 4735func awsAwsjson11_deserializeDocumentBonusPayment(v **types.BonusPayment, value interface{}) error { 4736 if v == nil { 4737 return fmt.Errorf("unexpected nil of type %T", v) 4738 } 4739 if value == nil { 4740 return nil 4741 } 4742 4743 shape, ok := value.(map[string]interface{}) 4744 if !ok { 4745 return fmt.Errorf("unexpected JSON type %v", value) 4746 } 4747 4748 var sv *types.BonusPayment 4749 if *v == nil { 4750 sv = &types.BonusPayment{} 4751 } else { 4752 sv = *v 4753 } 4754 4755 for key, value := range shape { 4756 switch key { 4757 case "AssignmentId": 4758 if value != nil { 4759 jtv, ok := value.(string) 4760 if !ok { 4761 return fmt.Errorf("expected EntityId to be of type string, got %T instead", value) 4762 } 4763 sv.AssignmentId = ptr.String(jtv) 4764 } 4765 4766 case "BonusAmount": 4767 if value != nil { 4768 jtv, ok := value.(string) 4769 if !ok { 4770 return fmt.Errorf("expected CurrencyAmount to be of type string, got %T instead", value) 4771 } 4772 sv.BonusAmount = ptr.String(jtv) 4773 } 4774 4775 case "GrantTime": 4776 if value != nil { 4777 jtv, ok := value.(json.Number) 4778 if !ok { 4779 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 4780 } 4781 f64, err := jtv.Float64() 4782 if err != nil { 4783 return err 4784 } 4785 sv.GrantTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 4786 } 4787 4788 case "Reason": 4789 if value != nil { 4790 jtv, ok := value.(string) 4791 if !ok { 4792 return fmt.Errorf("expected String to be of type string, got %T instead", value) 4793 } 4794 sv.Reason = ptr.String(jtv) 4795 } 4796 4797 case "WorkerId": 4798 if value != nil { 4799 jtv, ok := value.(string) 4800 if !ok { 4801 return fmt.Errorf("expected CustomerId to be of type string, got %T instead", value) 4802 } 4803 sv.WorkerId = ptr.String(jtv) 4804 } 4805 4806 default: 4807 _, _ = key, value 4808 4809 } 4810 } 4811 *v = sv 4812 return nil 4813} 4814 4815func awsAwsjson11_deserializeDocumentBonusPaymentList(v *[]types.BonusPayment, value interface{}) error { 4816 if v == nil { 4817 return fmt.Errorf("unexpected nil of type %T", v) 4818 } 4819 if value == nil { 4820 return nil 4821 } 4822 4823 shape, ok := value.([]interface{}) 4824 if !ok { 4825 return fmt.Errorf("unexpected JSON type %v", value) 4826 } 4827 4828 var cv []types.BonusPayment 4829 if *v == nil { 4830 cv = []types.BonusPayment{} 4831 } else { 4832 cv = *v 4833 } 4834 4835 for _, value := range shape { 4836 var col types.BonusPayment 4837 destAddr := &col 4838 if err := awsAwsjson11_deserializeDocumentBonusPayment(&destAddr, value); err != nil { 4839 return err 4840 } 4841 col = *destAddr 4842 cv = append(cv, col) 4843 4844 } 4845 *v = cv 4846 return nil 4847} 4848 4849func awsAwsjson11_deserializeDocumentHIT(v **types.HIT, value interface{}) error { 4850 if v == nil { 4851 return fmt.Errorf("unexpected nil of type %T", v) 4852 } 4853 if value == nil { 4854 return nil 4855 } 4856 4857 shape, ok := value.(map[string]interface{}) 4858 if !ok { 4859 return fmt.Errorf("unexpected JSON type %v", value) 4860 } 4861 4862 var sv *types.HIT 4863 if *v == nil { 4864 sv = &types.HIT{} 4865 } else { 4866 sv = *v 4867 } 4868 4869 for key, value := range shape { 4870 switch key { 4871 case "AssignmentDurationInSeconds": 4872 if value != nil { 4873 jtv, ok := value.(json.Number) 4874 if !ok { 4875 return fmt.Errorf("expected Long to be json.Number, got %T instead", value) 4876 } 4877 i64, err := jtv.Int64() 4878 if err != nil { 4879 return err 4880 } 4881 sv.AssignmentDurationInSeconds = ptr.Int64(i64) 4882 } 4883 4884 case "AutoApprovalDelayInSeconds": 4885 if value != nil { 4886 jtv, ok := value.(json.Number) 4887 if !ok { 4888 return fmt.Errorf("expected Long to be json.Number, got %T instead", value) 4889 } 4890 i64, err := jtv.Int64() 4891 if err != nil { 4892 return err 4893 } 4894 sv.AutoApprovalDelayInSeconds = ptr.Int64(i64) 4895 } 4896 4897 case "CreationTime": 4898 if value != nil { 4899 jtv, ok := value.(json.Number) 4900 if !ok { 4901 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 4902 } 4903 f64, err := jtv.Float64() 4904 if err != nil { 4905 return err 4906 } 4907 sv.CreationTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 4908 } 4909 4910 case "Description": 4911 if value != nil { 4912 jtv, ok := value.(string) 4913 if !ok { 4914 return fmt.Errorf("expected String to be of type string, got %T instead", value) 4915 } 4916 sv.Description = ptr.String(jtv) 4917 } 4918 4919 case "Expiration": 4920 if value != nil { 4921 jtv, ok := value.(json.Number) 4922 if !ok { 4923 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 4924 } 4925 f64, err := jtv.Float64() 4926 if err != nil { 4927 return err 4928 } 4929 sv.Expiration = ptr.Time(smithytime.ParseEpochSeconds(f64)) 4930 } 4931 4932 case "HITGroupId": 4933 if value != nil { 4934 jtv, ok := value.(string) 4935 if !ok { 4936 return fmt.Errorf("expected EntityId to be of type string, got %T instead", value) 4937 } 4938 sv.HITGroupId = ptr.String(jtv) 4939 } 4940 4941 case "HITId": 4942 if value != nil { 4943 jtv, ok := value.(string) 4944 if !ok { 4945 return fmt.Errorf("expected EntityId to be of type string, got %T instead", value) 4946 } 4947 sv.HITId = ptr.String(jtv) 4948 } 4949 4950 case "HITLayoutId": 4951 if value != nil { 4952 jtv, ok := value.(string) 4953 if !ok { 4954 return fmt.Errorf("expected EntityId to be of type string, got %T instead", value) 4955 } 4956 sv.HITLayoutId = ptr.String(jtv) 4957 } 4958 4959 case "HITReviewStatus": 4960 if value != nil { 4961 jtv, ok := value.(string) 4962 if !ok { 4963 return fmt.Errorf("expected HITReviewStatus to be of type string, got %T instead", value) 4964 } 4965 sv.HITReviewStatus = types.HITReviewStatus(jtv) 4966 } 4967 4968 case "HITStatus": 4969 if value != nil { 4970 jtv, ok := value.(string) 4971 if !ok { 4972 return fmt.Errorf("expected HITStatus to be of type string, got %T instead", value) 4973 } 4974 sv.HITStatus = types.HITStatus(jtv) 4975 } 4976 4977 case "HITTypeId": 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.HITTypeId = ptr.String(jtv) 4984 } 4985 4986 case "Keywords": 4987 if value != nil { 4988 jtv, ok := value.(string) 4989 if !ok { 4990 return fmt.Errorf("expected String to be of type string, got %T instead", value) 4991 } 4992 sv.Keywords = ptr.String(jtv) 4993 } 4994 4995 case "MaxAssignments": 4996 if value != nil { 4997 jtv, ok := value.(json.Number) 4998 if !ok { 4999 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 5000 } 5001 i64, err := jtv.Int64() 5002 if err != nil { 5003 return err 5004 } 5005 sv.MaxAssignments = ptr.Int32(int32(i64)) 5006 } 5007 5008 case "NumberOfAssignmentsAvailable": 5009 if value != nil { 5010 jtv, ok := value.(json.Number) 5011 if !ok { 5012 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 5013 } 5014 i64, err := jtv.Int64() 5015 if err != nil { 5016 return err 5017 } 5018 sv.NumberOfAssignmentsAvailable = ptr.Int32(int32(i64)) 5019 } 5020 5021 case "NumberOfAssignmentsCompleted": 5022 if value != nil { 5023 jtv, ok := value.(json.Number) 5024 if !ok { 5025 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 5026 } 5027 i64, err := jtv.Int64() 5028 if err != nil { 5029 return err 5030 } 5031 sv.NumberOfAssignmentsCompleted = ptr.Int32(int32(i64)) 5032 } 5033 5034 case "NumberOfAssignmentsPending": 5035 if value != nil { 5036 jtv, ok := value.(json.Number) 5037 if !ok { 5038 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 5039 } 5040 i64, err := jtv.Int64() 5041 if err != nil { 5042 return err 5043 } 5044 sv.NumberOfAssignmentsPending = ptr.Int32(int32(i64)) 5045 } 5046 5047 case "QualificationRequirements": 5048 if err := awsAwsjson11_deserializeDocumentQualificationRequirementList(&sv.QualificationRequirements, value); err != nil { 5049 return err 5050 } 5051 5052 case "Question": 5053 if value != nil { 5054 jtv, ok := value.(string) 5055 if !ok { 5056 return fmt.Errorf("expected String to be of type string, got %T instead", value) 5057 } 5058 sv.Question = ptr.String(jtv) 5059 } 5060 5061 case "RequesterAnnotation": 5062 if value != nil { 5063 jtv, ok := value.(string) 5064 if !ok { 5065 return fmt.Errorf("expected String to be of type string, got %T instead", value) 5066 } 5067 sv.RequesterAnnotation = ptr.String(jtv) 5068 } 5069 5070 case "Reward": 5071 if value != nil { 5072 jtv, ok := value.(string) 5073 if !ok { 5074 return fmt.Errorf("expected CurrencyAmount to be of type string, got %T instead", value) 5075 } 5076 sv.Reward = ptr.String(jtv) 5077 } 5078 5079 case "Title": 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.Title = ptr.String(jtv) 5086 } 5087 5088 default: 5089 _, _ = key, value 5090 5091 } 5092 } 5093 *v = sv 5094 return nil 5095} 5096 5097func awsAwsjson11_deserializeDocumentHITList(v *[]types.HIT, value interface{}) error { 5098 if v == nil { 5099 return fmt.Errorf("unexpected nil of type %T", v) 5100 } 5101 if value == nil { 5102 return nil 5103 } 5104 5105 shape, ok := value.([]interface{}) 5106 if !ok { 5107 return fmt.Errorf("unexpected JSON type %v", value) 5108 } 5109 5110 var cv []types.HIT 5111 if *v == nil { 5112 cv = []types.HIT{} 5113 } else { 5114 cv = *v 5115 } 5116 5117 for _, value := range shape { 5118 var col types.HIT 5119 destAddr := &col 5120 if err := awsAwsjson11_deserializeDocumentHIT(&destAddr, value); err != nil { 5121 return err 5122 } 5123 col = *destAddr 5124 cv = append(cv, col) 5125 5126 } 5127 *v = cv 5128 return nil 5129} 5130 5131func awsAwsjson11_deserializeDocumentIntegerList(v *[]int32, value interface{}) error { 5132 if v == nil { 5133 return fmt.Errorf("unexpected nil of type %T", v) 5134 } 5135 if value == nil { 5136 return nil 5137 } 5138 5139 shape, ok := value.([]interface{}) 5140 if !ok { 5141 return fmt.Errorf("unexpected JSON type %v", value) 5142 } 5143 5144 var cv []int32 5145 if *v == nil { 5146 cv = []int32{} 5147 } else { 5148 cv = *v 5149 } 5150 5151 for _, value := range shape { 5152 var col int32 5153 if value != nil { 5154 jtv, ok := value.(json.Number) 5155 if !ok { 5156 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 5157 } 5158 i64, err := jtv.Int64() 5159 if err != nil { 5160 return err 5161 } 5162 col = int32(i64) 5163 } 5164 cv = append(cv, col) 5165 5166 } 5167 *v = cv 5168 return nil 5169} 5170 5171func awsAwsjson11_deserializeDocumentLocale(v **types.Locale, value interface{}) error { 5172 if v == nil { 5173 return fmt.Errorf("unexpected nil of type %T", v) 5174 } 5175 if value == nil { 5176 return nil 5177 } 5178 5179 shape, ok := value.(map[string]interface{}) 5180 if !ok { 5181 return fmt.Errorf("unexpected JSON type %v", value) 5182 } 5183 5184 var sv *types.Locale 5185 if *v == nil { 5186 sv = &types.Locale{} 5187 } else { 5188 sv = *v 5189 } 5190 5191 for key, value := range shape { 5192 switch key { 5193 case "Country": 5194 if value != nil { 5195 jtv, ok := value.(string) 5196 if !ok { 5197 return fmt.Errorf("expected CountryParameters to be of type string, got %T instead", value) 5198 } 5199 sv.Country = ptr.String(jtv) 5200 } 5201 5202 case "Subdivision": 5203 if value != nil { 5204 jtv, ok := value.(string) 5205 if !ok { 5206 return fmt.Errorf("expected CountryParameters to be of type string, got %T instead", value) 5207 } 5208 sv.Subdivision = ptr.String(jtv) 5209 } 5210 5211 default: 5212 _, _ = key, value 5213 5214 } 5215 } 5216 *v = sv 5217 return nil 5218} 5219 5220func awsAwsjson11_deserializeDocumentLocaleList(v *[]types.Locale, value interface{}) error { 5221 if v == nil { 5222 return fmt.Errorf("unexpected nil of type %T", v) 5223 } 5224 if value == nil { 5225 return nil 5226 } 5227 5228 shape, ok := value.([]interface{}) 5229 if !ok { 5230 return fmt.Errorf("unexpected JSON type %v", value) 5231 } 5232 5233 var cv []types.Locale 5234 if *v == nil { 5235 cv = []types.Locale{} 5236 } else { 5237 cv = *v 5238 } 5239 5240 for _, value := range shape { 5241 var col types.Locale 5242 destAddr := &col 5243 if err := awsAwsjson11_deserializeDocumentLocale(&destAddr, value); err != nil { 5244 return err 5245 } 5246 col = *destAddr 5247 cv = append(cv, col) 5248 5249 } 5250 *v = cv 5251 return nil 5252} 5253 5254func awsAwsjson11_deserializeDocumentNotifyWorkersFailureStatus(v **types.NotifyWorkersFailureStatus, value interface{}) error { 5255 if v == nil { 5256 return fmt.Errorf("unexpected nil of type %T", v) 5257 } 5258 if value == nil { 5259 return nil 5260 } 5261 5262 shape, ok := value.(map[string]interface{}) 5263 if !ok { 5264 return fmt.Errorf("unexpected JSON type %v", value) 5265 } 5266 5267 var sv *types.NotifyWorkersFailureStatus 5268 if *v == nil { 5269 sv = &types.NotifyWorkersFailureStatus{} 5270 } else { 5271 sv = *v 5272 } 5273 5274 for key, value := range shape { 5275 switch key { 5276 case "NotifyWorkersFailureCode": 5277 if value != nil { 5278 jtv, ok := value.(string) 5279 if !ok { 5280 return fmt.Errorf("expected NotifyWorkersFailureCode to be of type string, got %T instead", value) 5281 } 5282 sv.NotifyWorkersFailureCode = types.NotifyWorkersFailureCode(jtv) 5283 } 5284 5285 case "NotifyWorkersFailureMessage": 5286 if value != nil { 5287 jtv, ok := value.(string) 5288 if !ok { 5289 return fmt.Errorf("expected String to be of type string, got %T instead", value) 5290 } 5291 sv.NotifyWorkersFailureMessage = ptr.String(jtv) 5292 } 5293 5294 case "WorkerId": 5295 if value != nil { 5296 jtv, ok := value.(string) 5297 if !ok { 5298 return fmt.Errorf("expected CustomerId to be of type string, got %T instead", value) 5299 } 5300 sv.WorkerId = ptr.String(jtv) 5301 } 5302 5303 default: 5304 _, _ = key, value 5305 5306 } 5307 } 5308 *v = sv 5309 return nil 5310} 5311 5312func awsAwsjson11_deserializeDocumentNotifyWorkersFailureStatusList(v *[]types.NotifyWorkersFailureStatus, value interface{}) error { 5313 if v == nil { 5314 return fmt.Errorf("unexpected nil of type %T", v) 5315 } 5316 if value == nil { 5317 return nil 5318 } 5319 5320 shape, ok := value.([]interface{}) 5321 if !ok { 5322 return fmt.Errorf("unexpected JSON type %v", value) 5323 } 5324 5325 var cv []types.NotifyWorkersFailureStatus 5326 if *v == nil { 5327 cv = []types.NotifyWorkersFailureStatus{} 5328 } else { 5329 cv = *v 5330 } 5331 5332 for _, value := range shape { 5333 var col types.NotifyWorkersFailureStatus 5334 destAddr := &col 5335 if err := awsAwsjson11_deserializeDocumentNotifyWorkersFailureStatus(&destAddr, value); err != nil { 5336 return err 5337 } 5338 col = *destAddr 5339 cv = append(cv, col) 5340 5341 } 5342 *v = cv 5343 return nil 5344} 5345 5346func awsAwsjson11_deserializeDocumentParameterMapEntry(v **types.ParameterMapEntry, value interface{}) error { 5347 if v == nil { 5348 return fmt.Errorf("unexpected nil of type %T", v) 5349 } 5350 if value == nil { 5351 return nil 5352 } 5353 5354 shape, ok := value.(map[string]interface{}) 5355 if !ok { 5356 return fmt.Errorf("unexpected JSON type %v", value) 5357 } 5358 5359 var sv *types.ParameterMapEntry 5360 if *v == nil { 5361 sv = &types.ParameterMapEntry{} 5362 } else { 5363 sv = *v 5364 } 5365 5366 for key, value := range shape { 5367 switch key { 5368 case "Key": 5369 if value != nil { 5370 jtv, ok := value.(string) 5371 if !ok { 5372 return fmt.Errorf("expected String to be of type string, got %T instead", value) 5373 } 5374 sv.Key = ptr.String(jtv) 5375 } 5376 5377 case "Values": 5378 if err := awsAwsjson11_deserializeDocumentStringList(&sv.Values, value); err != nil { 5379 return err 5380 } 5381 5382 default: 5383 _, _ = key, value 5384 5385 } 5386 } 5387 *v = sv 5388 return nil 5389} 5390 5391func awsAwsjson11_deserializeDocumentParameterMapEntryList(v *[]types.ParameterMapEntry, value interface{}) error { 5392 if v == nil { 5393 return fmt.Errorf("unexpected nil of type %T", v) 5394 } 5395 if value == nil { 5396 return nil 5397 } 5398 5399 shape, ok := value.([]interface{}) 5400 if !ok { 5401 return fmt.Errorf("unexpected JSON type %v", value) 5402 } 5403 5404 var cv []types.ParameterMapEntry 5405 if *v == nil { 5406 cv = []types.ParameterMapEntry{} 5407 } else { 5408 cv = *v 5409 } 5410 5411 for _, value := range shape { 5412 var col types.ParameterMapEntry 5413 destAddr := &col 5414 if err := awsAwsjson11_deserializeDocumentParameterMapEntry(&destAddr, value); err != nil { 5415 return err 5416 } 5417 col = *destAddr 5418 cv = append(cv, col) 5419 5420 } 5421 *v = cv 5422 return nil 5423} 5424 5425func awsAwsjson11_deserializeDocumentPolicyParameter(v **types.PolicyParameter, value interface{}) error { 5426 if v == nil { 5427 return fmt.Errorf("unexpected nil of type %T", v) 5428 } 5429 if value == nil { 5430 return nil 5431 } 5432 5433 shape, ok := value.(map[string]interface{}) 5434 if !ok { 5435 return fmt.Errorf("unexpected JSON type %v", value) 5436 } 5437 5438 var sv *types.PolicyParameter 5439 if *v == nil { 5440 sv = &types.PolicyParameter{} 5441 } else { 5442 sv = *v 5443 } 5444 5445 for key, value := range shape { 5446 switch key { 5447 case "Key": 5448 if value != nil { 5449 jtv, ok := value.(string) 5450 if !ok { 5451 return fmt.Errorf("expected String to be of type string, got %T instead", value) 5452 } 5453 sv.Key = ptr.String(jtv) 5454 } 5455 5456 case "MapEntries": 5457 if err := awsAwsjson11_deserializeDocumentParameterMapEntryList(&sv.MapEntries, value); err != nil { 5458 return err 5459 } 5460 5461 case "Values": 5462 if err := awsAwsjson11_deserializeDocumentStringList(&sv.Values, value); err != nil { 5463 return err 5464 } 5465 5466 default: 5467 _, _ = key, value 5468 5469 } 5470 } 5471 *v = sv 5472 return nil 5473} 5474 5475func awsAwsjson11_deserializeDocumentPolicyParameterList(v *[]types.PolicyParameter, value interface{}) error { 5476 if v == nil { 5477 return fmt.Errorf("unexpected nil of type %T", v) 5478 } 5479 if value == nil { 5480 return nil 5481 } 5482 5483 shape, ok := value.([]interface{}) 5484 if !ok { 5485 return fmt.Errorf("unexpected JSON type %v", value) 5486 } 5487 5488 var cv []types.PolicyParameter 5489 if *v == nil { 5490 cv = []types.PolicyParameter{} 5491 } else { 5492 cv = *v 5493 } 5494 5495 for _, value := range shape { 5496 var col types.PolicyParameter 5497 destAddr := &col 5498 if err := awsAwsjson11_deserializeDocumentPolicyParameter(&destAddr, value); err != nil { 5499 return err 5500 } 5501 col = *destAddr 5502 cv = append(cv, col) 5503 5504 } 5505 *v = cv 5506 return nil 5507} 5508 5509func awsAwsjson11_deserializeDocumentQualification(v **types.Qualification, value interface{}) error { 5510 if v == nil { 5511 return fmt.Errorf("unexpected nil of type %T", v) 5512 } 5513 if value == nil { 5514 return nil 5515 } 5516 5517 shape, ok := value.(map[string]interface{}) 5518 if !ok { 5519 return fmt.Errorf("unexpected JSON type %v", value) 5520 } 5521 5522 var sv *types.Qualification 5523 if *v == nil { 5524 sv = &types.Qualification{} 5525 } else { 5526 sv = *v 5527 } 5528 5529 for key, value := range shape { 5530 switch key { 5531 case "GrantTime": 5532 if value != nil { 5533 jtv, ok := value.(json.Number) 5534 if !ok { 5535 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 5536 } 5537 f64, err := jtv.Float64() 5538 if err != nil { 5539 return err 5540 } 5541 sv.GrantTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 5542 } 5543 5544 case "IntegerValue": 5545 if value != nil { 5546 jtv, ok := value.(json.Number) 5547 if !ok { 5548 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 5549 } 5550 i64, err := jtv.Int64() 5551 if err != nil { 5552 return err 5553 } 5554 sv.IntegerValue = ptr.Int32(int32(i64)) 5555 } 5556 5557 case "LocaleValue": 5558 if err := awsAwsjson11_deserializeDocumentLocale(&sv.LocaleValue, value); err != nil { 5559 return err 5560 } 5561 5562 case "QualificationTypeId": 5563 if value != nil { 5564 jtv, ok := value.(string) 5565 if !ok { 5566 return fmt.Errorf("expected EntityId to be of type string, got %T instead", value) 5567 } 5568 sv.QualificationTypeId = ptr.String(jtv) 5569 } 5570 5571 case "Status": 5572 if value != nil { 5573 jtv, ok := value.(string) 5574 if !ok { 5575 return fmt.Errorf("expected QualificationStatus to be of type string, got %T instead", value) 5576 } 5577 sv.Status = types.QualificationStatus(jtv) 5578 } 5579 5580 case "WorkerId": 5581 if value != nil { 5582 jtv, ok := value.(string) 5583 if !ok { 5584 return fmt.Errorf("expected CustomerId to be of type string, got %T instead", value) 5585 } 5586 sv.WorkerId = ptr.String(jtv) 5587 } 5588 5589 default: 5590 _, _ = key, value 5591 5592 } 5593 } 5594 *v = sv 5595 return nil 5596} 5597 5598func awsAwsjson11_deserializeDocumentQualificationList(v *[]types.Qualification, value interface{}) error { 5599 if v == nil { 5600 return fmt.Errorf("unexpected nil of type %T", v) 5601 } 5602 if value == nil { 5603 return nil 5604 } 5605 5606 shape, ok := value.([]interface{}) 5607 if !ok { 5608 return fmt.Errorf("unexpected JSON type %v", value) 5609 } 5610 5611 var cv []types.Qualification 5612 if *v == nil { 5613 cv = []types.Qualification{} 5614 } else { 5615 cv = *v 5616 } 5617 5618 for _, value := range shape { 5619 var col types.Qualification 5620 destAddr := &col 5621 if err := awsAwsjson11_deserializeDocumentQualification(&destAddr, value); err != nil { 5622 return err 5623 } 5624 col = *destAddr 5625 cv = append(cv, col) 5626 5627 } 5628 *v = cv 5629 return nil 5630} 5631 5632func awsAwsjson11_deserializeDocumentQualificationRequest(v **types.QualificationRequest, value interface{}) error { 5633 if v == nil { 5634 return fmt.Errorf("unexpected nil of type %T", v) 5635 } 5636 if value == nil { 5637 return nil 5638 } 5639 5640 shape, ok := value.(map[string]interface{}) 5641 if !ok { 5642 return fmt.Errorf("unexpected JSON type %v", value) 5643 } 5644 5645 var sv *types.QualificationRequest 5646 if *v == nil { 5647 sv = &types.QualificationRequest{} 5648 } else { 5649 sv = *v 5650 } 5651 5652 for key, value := range shape { 5653 switch key { 5654 case "Answer": 5655 if value != nil { 5656 jtv, ok := value.(string) 5657 if !ok { 5658 return fmt.Errorf("expected String to be of type string, got %T instead", value) 5659 } 5660 sv.Answer = ptr.String(jtv) 5661 } 5662 5663 case "QualificationRequestId": 5664 if value != nil { 5665 jtv, ok := value.(string) 5666 if !ok { 5667 return fmt.Errorf("expected String to be of type string, got %T instead", value) 5668 } 5669 sv.QualificationRequestId = ptr.String(jtv) 5670 } 5671 5672 case "QualificationTypeId": 5673 if value != nil { 5674 jtv, ok := value.(string) 5675 if !ok { 5676 return fmt.Errorf("expected EntityId to be of type string, got %T instead", value) 5677 } 5678 sv.QualificationTypeId = ptr.String(jtv) 5679 } 5680 5681 case "SubmitTime": 5682 if value != nil { 5683 jtv, ok := value.(json.Number) 5684 if !ok { 5685 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 5686 } 5687 f64, err := jtv.Float64() 5688 if err != nil { 5689 return err 5690 } 5691 sv.SubmitTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 5692 } 5693 5694 case "Test": 5695 if value != nil { 5696 jtv, ok := value.(string) 5697 if !ok { 5698 return fmt.Errorf("expected String to be of type string, got %T instead", value) 5699 } 5700 sv.Test = ptr.String(jtv) 5701 } 5702 5703 case "WorkerId": 5704 if value != nil { 5705 jtv, ok := value.(string) 5706 if !ok { 5707 return fmt.Errorf("expected CustomerId to be of type string, got %T instead", value) 5708 } 5709 sv.WorkerId = ptr.String(jtv) 5710 } 5711 5712 default: 5713 _, _ = key, value 5714 5715 } 5716 } 5717 *v = sv 5718 return nil 5719} 5720 5721func awsAwsjson11_deserializeDocumentQualificationRequestList(v *[]types.QualificationRequest, value interface{}) error { 5722 if v == nil { 5723 return fmt.Errorf("unexpected nil of type %T", v) 5724 } 5725 if value == nil { 5726 return nil 5727 } 5728 5729 shape, ok := value.([]interface{}) 5730 if !ok { 5731 return fmt.Errorf("unexpected JSON type %v", value) 5732 } 5733 5734 var cv []types.QualificationRequest 5735 if *v == nil { 5736 cv = []types.QualificationRequest{} 5737 } else { 5738 cv = *v 5739 } 5740 5741 for _, value := range shape { 5742 var col types.QualificationRequest 5743 destAddr := &col 5744 if err := awsAwsjson11_deserializeDocumentQualificationRequest(&destAddr, value); err != nil { 5745 return err 5746 } 5747 col = *destAddr 5748 cv = append(cv, col) 5749 5750 } 5751 *v = cv 5752 return nil 5753} 5754 5755func awsAwsjson11_deserializeDocumentQualificationRequirement(v **types.QualificationRequirement, value interface{}) error { 5756 if v == nil { 5757 return fmt.Errorf("unexpected nil of type %T", v) 5758 } 5759 if value == nil { 5760 return nil 5761 } 5762 5763 shape, ok := value.(map[string]interface{}) 5764 if !ok { 5765 return fmt.Errorf("unexpected JSON type %v", value) 5766 } 5767 5768 var sv *types.QualificationRequirement 5769 if *v == nil { 5770 sv = &types.QualificationRequirement{} 5771 } else { 5772 sv = *v 5773 } 5774 5775 for key, value := range shape { 5776 switch key { 5777 case "ActionsGuarded": 5778 if value != nil { 5779 jtv, ok := value.(string) 5780 if !ok { 5781 return fmt.Errorf("expected HITAccessActions to be of type string, got %T instead", value) 5782 } 5783 sv.ActionsGuarded = types.HITAccessActions(jtv) 5784 } 5785 5786 case "Comparator": 5787 if value != nil { 5788 jtv, ok := value.(string) 5789 if !ok { 5790 return fmt.Errorf("expected Comparator to be of type string, got %T instead", value) 5791 } 5792 sv.Comparator = types.Comparator(jtv) 5793 } 5794 5795 case "IntegerValues": 5796 if err := awsAwsjson11_deserializeDocumentIntegerList(&sv.IntegerValues, value); err != nil { 5797 return err 5798 } 5799 5800 case "LocaleValues": 5801 if err := awsAwsjson11_deserializeDocumentLocaleList(&sv.LocaleValues, value); err != nil { 5802 return err 5803 } 5804 5805 case "QualificationTypeId": 5806 if value != nil { 5807 jtv, ok := value.(string) 5808 if !ok { 5809 return fmt.Errorf("expected String to be of type string, got %T instead", value) 5810 } 5811 sv.QualificationTypeId = ptr.String(jtv) 5812 } 5813 5814 case "RequiredToPreview": 5815 if value != nil { 5816 jtv, ok := value.(bool) 5817 if !ok { 5818 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 5819 } 5820 sv.RequiredToPreview = ptr.Bool(jtv) 5821 } 5822 5823 default: 5824 _, _ = key, value 5825 5826 } 5827 } 5828 *v = sv 5829 return nil 5830} 5831 5832func awsAwsjson11_deserializeDocumentQualificationRequirementList(v *[]types.QualificationRequirement, value interface{}) error { 5833 if v == nil { 5834 return fmt.Errorf("unexpected nil of type %T", v) 5835 } 5836 if value == nil { 5837 return nil 5838 } 5839 5840 shape, ok := value.([]interface{}) 5841 if !ok { 5842 return fmt.Errorf("unexpected JSON type %v", value) 5843 } 5844 5845 var cv []types.QualificationRequirement 5846 if *v == nil { 5847 cv = []types.QualificationRequirement{} 5848 } else { 5849 cv = *v 5850 } 5851 5852 for _, value := range shape { 5853 var col types.QualificationRequirement 5854 destAddr := &col 5855 if err := awsAwsjson11_deserializeDocumentQualificationRequirement(&destAddr, value); err != nil { 5856 return err 5857 } 5858 col = *destAddr 5859 cv = append(cv, col) 5860 5861 } 5862 *v = cv 5863 return nil 5864} 5865 5866func awsAwsjson11_deserializeDocumentQualificationType(v **types.QualificationType, value interface{}) error { 5867 if v == nil { 5868 return fmt.Errorf("unexpected nil of type %T", v) 5869 } 5870 if value == nil { 5871 return nil 5872 } 5873 5874 shape, ok := value.(map[string]interface{}) 5875 if !ok { 5876 return fmt.Errorf("unexpected JSON type %v", value) 5877 } 5878 5879 var sv *types.QualificationType 5880 if *v == nil { 5881 sv = &types.QualificationType{} 5882 } else { 5883 sv = *v 5884 } 5885 5886 for key, value := range shape { 5887 switch key { 5888 case "AnswerKey": 5889 if value != nil { 5890 jtv, ok := value.(string) 5891 if !ok { 5892 return fmt.Errorf("expected String to be of type string, got %T instead", value) 5893 } 5894 sv.AnswerKey = ptr.String(jtv) 5895 } 5896 5897 case "AutoGranted": 5898 if value != nil { 5899 jtv, ok := value.(bool) 5900 if !ok { 5901 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 5902 } 5903 sv.AutoGranted = ptr.Bool(jtv) 5904 } 5905 5906 case "AutoGrantedValue": 5907 if value != nil { 5908 jtv, ok := value.(json.Number) 5909 if !ok { 5910 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 5911 } 5912 i64, err := jtv.Int64() 5913 if err != nil { 5914 return err 5915 } 5916 sv.AutoGrantedValue = ptr.Int32(int32(i64)) 5917 } 5918 5919 case "CreationTime": 5920 if value != nil { 5921 jtv, ok := value.(json.Number) 5922 if !ok { 5923 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 5924 } 5925 f64, err := jtv.Float64() 5926 if err != nil { 5927 return err 5928 } 5929 sv.CreationTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 5930 } 5931 5932 case "Description": 5933 if value != nil { 5934 jtv, ok := value.(string) 5935 if !ok { 5936 return fmt.Errorf("expected String to be of type string, got %T instead", value) 5937 } 5938 sv.Description = ptr.String(jtv) 5939 } 5940 5941 case "IsRequestable": 5942 if value != nil { 5943 jtv, ok := value.(bool) 5944 if !ok { 5945 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 5946 } 5947 sv.IsRequestable = ptr.Bool(jtv) 5948 } 5949 5950 case "Keywords": 5951 if value != nil { 5952 jtv, ok := value.(string) 5953 if !ok { 5954 return fmt.Errorf("expected String to be of type string, got %T instead", value) 5955 } 5956 sv.Keywords = ptr.String(jtv) 5957 } 5958 5959 case "Name": 5960 if value != nil { 5961 jtv, ok := value.(string) 5962 if !ok { 5963 return fmt.Errorf("expected String to be of type string, got %T instead", value) 5964 } 5965 sv.Name = ptr.String(jtv) 5966 } 5967 5968 case "QualificationTypeId": 5969 if value != nil { 5970 jtv, ok := value.(string) 5971 if !ok { 5972 return fmt.Errorf("expected EntityId to be of type string, got %T instead", value) 5973 } 5974 sv.QualificationTypeId = ptr.String(jtv) 5975 } 5976 5977 case "QualificationTypeStatus": 5978 if value != nil { 5979 jtv, ok := value.(string) 5980 if !ok { 5981 return fmt.Errorf("expected QualificationTypeStatus to be of type string, got %T instead", value) 5982 } 5983 sv.QualificationTypeStatus = types.QualificationTypeStatus(jtv) 5984 } 5985 5986 case "RetryDelayInSeconds": 5987 if value != nil { 5988 jtv, ok := value.(json.Number) 5989 if !ok { 5990 return fmt.Errorf("expected Long to be json.Number, got %T instead", value) 5991 } 5992 i64, err := jtv.Int64() 5993 if err != nil { 5994 return err 5995 } 5996 sv.RetryDelayInSeconds = ptr.Int64(i64) 5997 } 5998 5999 case "Test": 6000 if value != nil { 6001 jtv, ok := value.(string) 6002 if !ok { 6003 return fmt.Errorf("expected String to be of type string, got %T instead", value) 6004 } 6005 sv.Test = ptr.String(jtv) 6006 } 6007 6008 case "TestDurationInSeconds": 6009 if value != nil { 6010 jtv, ok := value.(json.Number) 6011 if !ok { 6012 return fmt.Errorf("expected Long to be json.Number, got %T instead", value) 6013 } 6014 i64, err := jtv.Int64() 6015 if err != nil { 6016 return err 6017 } 6018 sv.TestDurationInSeconds = ptr.Int64(i64) 6019 } 6020 6021 default: 6022 _, _ = key, value 6023 6024 } 6025 } 6026 *v = sv 6027 return nil 6028} 6029 6030func awsAwsjson11_deserializeDocumentQualificationTypeList(v *[]types.QualificationType, value interface{}) error { 6031 if v == nil { 6032 return fmt.Errorf("unexpected nil of type %T", v) 6033 } 6034 if value == nil { 6035 return nil 6036 } 6037 6038 shape, ok := value.([]interface{}) 6039 if !ok { 6040 return fmt.Errorf("unexpected JSON type %v", value) 6041 } 6042 6043 var cv []types.QualificationType 6044 if *v == nil { 6045 cv = []types.QualificationType{} 6046 } else { 6047 cv = *v 6048 } 6049 6050 for _, value := range shape { 6051 var col types.QualificationType 6052 destAddr := &col 6053 if err := awsAwsjson11_deserializeDocumentQualificationType(&destAddr, value); err != nil { 6054 return err 6055 } 6056 col = *destAddr 6057 cv = append(cv, col) 6058 6059 } 6060 *v = cv 6061 return nil 6062} 6063 6064func awsAwsjson11_deserializeDocumentRequestError(v **types.RequestError, value interface{}) error { 6065 if v == nil { 6066 return fmt.Errorf("unexpected nil of type %T", v) 6067 } 6068 if value == nil { 6069 return nil 6070 } 6071 6072 shape, ok := value.(map[string]interface{}) 6073 if !ok { 6074 return fmt.Errorf("unexpected JSON type %v", value) 6075 } 6076 6077 var sv *types.RequestError 6078 if *v == nil { 6079 sv = &types.RequestError{} 6080 } else { 6081 sv = *v 6082 } 6083 6084 for key, value := range shape { 6085 switch key { 6086 case "Message": 6087 if value != nil { 6088 jtv, ok := value.(string) 6089 if !ok { 6090 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 6091 } 6092 sv.Message = ptr.String(jtv) 6093 } 6094 6095 case "TurkErrorCode": 6096 if value != nil { 6097 jtv, ok := value.(string) 6098 if !ok { 6099 return fmt.Errorf("expected TurkErrorCode to be of type string, got %T instead", value) 6100 } 6101 sv.TurkErrorCode = ptr.String(jtv) 6102 } 6103 6104 default: 6105 _, _ = key, value 6106 6107 } 6108 } 6109 *v = sv 6110 return nil 6111} 6112 6113func awsAwsjson11_deserializeDocumentReviewActionDetail(v **types.ReviewActionDetail, value interface{}) error { 6114 if v == nil { 6115 return fmt.Errorf("unexpected nil of type %T", v) 6116 } 6117 if value == nil { 6118 return nil 6119 } 6120 6121 shape, ok := value.(map[string]interface{}) 6122 if !ok { 6123 return fmt.Errorf("unexpected JSON type %v", value) 6124 } 6125 6126 var sv *types.ReviewActionDetail 6127 if *v == nil { 6128 sv = &types.ReviewActionDetail{} 6129 } else { 6130 sv = *v 6131 } 6132 6133 for key, value := range shape { 6134 switch key { 6135 case "ActionId": 6136 if value != nil { 6137 jtv, ok := value.(string) 6138 if !ok { 6139 return fmt.Errorf("expected EntityId to be of type string, got %T instead", value) 6140 } 6141 sv.ActionId = ptr.String(jtv) 6142 } 6143 6144 case "ActionName": 6145 if value != nil { 6146 jtv, ok := value.(string) 6147 if !ok { 6148 return fmt.Errorf("expected String to be of type string, got %T instead", value) 6149 } 6150 sv.ActionName = ptr.String(jtv) 6151 } 6152 6153 case "CompleteTime": 6154 if value != nil { 6155 jtv, ok := value.(json.Number) 6156 if !ok { 6157 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 6158 } 6159 f64, err := jtv.Float64() 6160 if err != nil { 6161 return err 6162 } 6163 sv.CompleteTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 6164 } 6165 6166 case "ErrorCode": 6167 if value != nil { 6168 jtv, ok := value.(string) 6169 if !ok { 6170 return fmt.Errorf("expected String to be of type string, got %T instead", value) 6171 } 6172 sv.ErrorCode = ptr.String(jtv) 6173 } 6174 6175 case "Result": 6176 if value != nil { 6177 jtv, ok := value.(string) 6178 if !ok { 6179 return fmt.Errorf("expected String to be of type string, got %T instead", value) 6180 } 6181 sv.Result = ptr.String(jtv) 6182 } 6183 6184 case "Status": 6185 if value != nil { 6186 jtv, ok := value.(string) 6187 if !ok { 6188 return fmt.Errorf("expected ReviewActionStatus to be of type string, got %T instead", value) 6189 } 6190 sv.Status = types.ReviewActionStatus(jtv) 6191 } 6192 6193 case "TargetId": 6194 if value != nil { 6195 jtv, ok := value.(string) 6196 if !ok { 6197 return fmt.Errorf("expected EntityId to be of type string, got %T instead", value) 6198 } 6199 sv.TargetId = ptr.String(jtv) 6200 } 6201 6202 case "TargetType": 6203 if value != nil { 6204 jtv, ok := value.(string) 6205 if !ok { 6206 return fmt.Errorf("expected String to be of type string, got %T instead", value) 6207 } 6208 sv.TargetType = ptr.String(jtv) 6209 } 6210 6211 default: 6212 _, _ = key, value 6213 6214 } 6215 } 6216 *v = sv 6217 return nil 6218} 6219 6220func awsAwsjson11_deserializeDocumentReviewActionDetailList(v *[]types.ReviewActionDetail, value interface{}) error { 6221 if v == nil { 6222 return fmt.Errorf("unexpected nil of type %T", v) 6223 } 6224 if value == nil { 6225 return nil 6226 } 6227 6228 shape, ok := value.([]interface{}) 6229 if !ok { 6230 return fmt.Errorf("unexpected JSON type %v", value) 6231 } 6232 6233 var cv []types.ReviewActionDetail 6234 if *v == nil { 6235 cv = []types.ReviewActionDetail{} 6236 } else { 6237 cv = *v 6238 } 6239 6240 for _, value := range shape { 6241 var col types.ReviewActionDetail 6242 destAddr := &col 6243 if err := awsAwsjson11_deserializeDocumentReviewActionDetail(&destAddr, value); err != nil { 6244 return err 6245 } 6246 col = *destAddr 6247 cv = append(cv, col) 6248 6249 } 6250 *v = cv 6251 return nil 6252} 6253 6254func awsAwsjson11_deserializeDocumentReviewPolicy(v **types.ReviewPolicy, value interface{}) error { 6255 if v == nil { 6256 return fmt.Errorf("unexpected nil of type %T", v) 6257 } 6258 if value == nil { 6259 return nil 6260 } 6261 6262 shape, ok := value.(map[string]interface{}) 6263 if !ok { 6264 return fmt.Errorf("unexpected JSON type %v", value) 6265 } 6266 6267 var sv *types.ReviewPolicy 6268 if *v == nil { 6269 sv = &types.ReviewPolicy{} 6270 } else { 6271 sv = *v 6272 } 6273 6274 for key, value := range shape { 6275 switch key { 6276 case "Parameters": 6277 if err := awsAwsjson11_deserializeDocumentPolicyParameterList(&sv.Parameters, value); err != nil { 6278 return err 6279 } 6280 6281 case "PolicyName": 6282 if value != nil { 6283 jtv, ok := value.(string) 6284 if !ok { 6285 return fmt.Errorf("expected String to be of type string, got %T instead", value) 6286 } 6287 sv.PolicyName = ptr.String(jtv) 6288 } 6289 6290 default: 6291 _, _ = key, value 6292 6293 } 6294 } 6295 *v = sv 6296 return nil 6297} 6298 6299func awsAwsjson11_deserializeDocumentReviewReport(v **types.ReviewReport, value interface{}) error { 6300 if v == nil { 6301 return fmt.Errorf("unexpected nil of type %T", v) 6302 } 6303 if value == nil { 6304 return nil 6305 } 6306 6307 shape, ok := value.(map[string]interface{}) 6308 if !ok { 6309 return fmt.Errorf("unexpected JSON type %v", value) 6310 } 6311 6312 var sv *types.ReviewReport 6313 if *v == nil { 6314 sv = &types.ReviewReport{} 6315 } else { 6316 sv = *v 6317 } 6318 6319 for key, value := range shape { 6320 switch key { 6321 case "ReviewActions": 6322 if err := awsAwsjson11_deserializeDocumentReviewActionDetailList(&sv.ReviewActions, value); err != nil { 6323 return err 6324 } 6325 6326 case "ReviewResults": 6327 if err := awsAwsjson11_deserializeDocumentReviewResultDetailList(&sv.ReviewResults, value); err != nil { 6328 return err 6329 } 6330 6331 default: 6332 _, _ = key, value 6333 6334 } 6335 } 6336 *v = sv 6337 return nil 6338} 6339 6340func awsAwsjson11_deserializeDocumentReviewResultDetail(v **types.ReviewResultDetail, value interface{}) error { 6341 if v == nil { 6342 return fmt.Errorf("unexpected nil of type %T", v) 6343 } 6344 if value == nil { 6345 return nil 6346 } 6347 6348 shape, ok := value.(map[string]interface{}) 6349 if !ok { 6350 return fmt.Errorf("unexpected JSON type %v", value) 6351 } 6352 6353 var sv *types.ReviewResultDetail 6354 if *v == nil { 6355 sv = &types.ReviewResultDetail{} 6356 } else { 6357 sv = *v 6358 } 6359 6360 for key, value := range shape { 6361 switch key { 6362 case "ActionId": 6363 if value != nil { 6364 jtv, ok := value.(string) 6365 if !ok { 6366 return fmt.Errorf("expected EntityId to be of type string, got %T instead", value) 6367 } 6368 sv.ActionId = ptr.String(jtv) 6369 } 6370 6371 case "Key": 6372 if value != nil { 6373 jtv, ok := value.(string) 6374 if !ok { 6375 return fmt.Errorf("expected String to be of type string, got %T instead", value) 6376 } 6377 sv.Key = ptr.String(jtv) 6378 } 6379 6380 case "QuestionId": 6381 if value != nil { 6382 jtv, ok := value.(string) 6383 if !ok { 6384 return fmt.Errorf("expected EntityId to be of type string, got %T instead", value) 6385 } 6386 sv.QuestionId = ptr.String(jtv) 6387 } 6388 6389 case "SubjectId": 6390 if value != nil { 6391 jtv, ok := value.(string) 6392 if !ok { 6393 return fmt.Errorf("expected EntityId to be of type string, got %T instead", value) 6394 } 6395 sv.SubjectId = ptr.String(jtv) 6396 } 6397 6398 case "SubjectType": 6399 if value != nil { 6400 jtv, ok := value.(string) 6401 if !ok { 6402 return fmt.Errorf("expected String to be of type string, got %T instead", value) 6403 } 6404 sv.SubjectType = ptr.String(jtv) 6405 } 6406 6407 case "Value": 6408 if value != nil { 6409 jtv, ok := value.(string) 6410 if !ok { 6411 return fmt.Errorf("expected String to be of type string, got %T instead", value) 6412 } 6413 sv.Value = ptr.String(jtv) 6414 } 6415 6416 default: 6417 _, _ = key, value 6418 6419 } 6420 } 6421 *v = sv 6422 return nil 6423} 6424 6425func awsAwsjson11_deserializeDocumentReviewResultDetailList(v *[]types.ReviewResultDetail, value interface{}) error { 6426 if v == nil { 6427 return fmt.Errorf("unexpected nil of type %T", v) 6428 } 6429 if value == nil { 6430 return nil 6431 } 6432 6433 shape, ok := value.([]interface{}) 6434 if !ok { 6435 return fmt.Errorf("unexpected JSON type %v", value) 6436 } 6437 6438 var cv []types.ReviewResultDetail 6439 if *v == nil { 6440 cv = []types.ReviewResultDetail{} 6441 } else { 6442 cv = *v 6443 } 6444 6445 for _, value := range shape { 6446 var col types.ReviewResultDetail 6447 destAddr := &col 6448 if err := awsAwsjson11_deserializeDocumentReviewResultDetail(&destAddr, value); err != nil { 6449 return err 6450 } 6451 col = *destAddr 6452 cv = append(cv, col) 6453 6454 } 6455 *v = cv 6456 return nil 6457} 6458 6459func awsAwsjson11_deserializeDocumentServiceFault(v **types.ServiceFault, value interface{}) error { 6460 if v == nil { 6461 return fmt.Errorf("unexpected nil of type %T", v) 6462 } 6463 if value == nil { 6464 return nil 6465 } 6466 6467 shape, ok := value.(map[string]interface{}) 6468 if !ok { 6469 return fmt.Errorf("unexpected JSON type %v", value) 6470 } 6471 6472 var sv *types.ServiceFault 6473 if *v == nil { 6474 sv = &types.ServiceFault{} 6475 } else { 6476 sv = *v 6477 } 6478 6479 for key, value := range shape { 6480 switch key { 6481 case "Message": 6482 if value != nil { 6483 jtv, ok := value.(string) 6484 if !ok { 6485 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 6486 } 6487 sv.Message = ptr.String(jtv) 6488 } 6489 6490 case "TurkErrorCode": 6491 if value != nil { 6492 jtv, ok := value.(string) 6493 if !ok { 6494 return fmt.Errorf("expected TurkErrorCode to be of type string, got %T instead", value) 6495 } 6496 sv.TurkErrorCode = ptr.String(jtv) 6497 } 6498 6499 default: 6500 _, _ = key, value 6501 6502 } 6503 } 6504 *v = sv 6505 return nil 6506} 6507 6508func awsAwsjson11_deserializeDocumentStringList(v *[]string, value interface{}) error { 6509 if v == nil { 6510 return fmt.Errorf("unexpected nil of type %T", v) 6511 } 6512 if value == nil { 6513 return nil 6514 } 6515 6516 shape, ok := value.([]interface{}) 6517 if !ok { 6518 return fmt.Errorf("unexpected JSON type %v", value) 6519 } 6520 6521 var cv []string 6522 if *v == nil { 6523 cv = []string{} 6524 } else { 6525 cv = *v 6526 } 6527 6528 for _, value := range shape { 6529 var col string 6530 if value != nil { 6531 jtv, ok := value.(string) 6532 if !ok { 6533 return fmt.Errorf("expected String to be of type string, got %T instead", value) 6534 } 6535 col = jtv 6536 } 6537 cv = append(cv, col) 6538 6539 } 6540 *v = cv 6541 return nil 6542} 6543 6544func awsAwsjson11_deserializeDocumentWorkerBlock(v **types.WorkerBlock, value interface{}) error { 6545 if v == nil { 6546 return fmt.Errorf("unexpected nil of type %T", v) 6547 } 6548 if value == nil { 6549 return nil 6550 } 6551 6552 shape, ok := value.(map[string]interface{}) 6553 if !ok { 6554 return fmt.Errorf("unexpected JSON type %v", value) 6555 } 6556 6557 var sv *types.WorkerBlock 6558 if *v == nil { 6559 sv = &types.WorkerBlock{} 6560 } else { 6561 sv = *v 6562 } 6563 6564 for key, value := range shape { 6565 switch key { 6566 case "Reason": 6567 if value != nil { 6568 jtv, ok := value.(string) 6569 if !ok { 6570 return fmt.Errorf("expected String to be of type string, got %T instead", value) 6571 } 6572 sv.Reason = ptr.String(jtv) 6573 } 6574 6575 case "WorkerId": 6576 if value != nil { 6577 jtv, ok := value.(string) 6578 if !ok { 6579 return fmt.Errorf("expected CustomerId to be of type string, got %T instead", value) 6580 } 6581 sv.WorkerId = ptr.String(jtv) 6582 } 6583 6584 default: 6585 _, _ = key, value 6586 6587 } 6588 } 6589 *v = sv 6590 return nil 6591} 6592 6593func awsAwsjson11_deserializeDocumentWorkerBlockList(v *[]types.WorkerBlock, value interface{}) error { 6594 if v == nil { 6595 return fmt.Errorf("unexpected nil of type %T", v) 6596 } 6597 if value == nil { 6598 return nil 6599 } 6600 6601 shape, ok := value.([]interface{}) 6602 if !ok { 6603 return fmt.Errorf("unexpected JSON type %v", value) 6604 } 6605 6606 var cv []types.WorkerBlock 6607 if *v == nil { 6608 cv = []types.WorkerBlock{} 6609 } else { 6610 cv = *v 6611 } 6612 6613 for _, value := range shape { 6614 var col types.WorkerBlock 6615 destAddr := &col 6616 if err := awsAwsjson11_deserializeDocumentWorkerBlock(&destAddr, value); err != nil { 6617 return err 6618 } 6619 col = *destAddr 6620 cv = append(cv, col) 6621 6622 } 6623 *v = cv 6624 return nil 6625} 6626 6627func awsAwsjson11_deserializeOpDocumentAcceptQualificationRequestOutput(v **AcceptQualificationRequestOutput, value interface{}) error { 6628 if v == nil { 6629 return fmt.Errorf("unexpected nil of type %T", v) 6630 } 6631 if value == nil { 6632 return nil 6633 } 6634 6635 shape, ok := value.(map[string]interface{}) 6636 if !ok { 6637 return fmt.Errorf("unexpected JSON type %v", value) 6638 } 6639 6640 var sv *AcceptQualificationRequestOutput 6641 if *v == nil { 6642 sv = &AcceptQualificationRequestOutput{} 6643 } else { 6644 sv = *v 6645 } 6646 6647 for key, value := range shape { 6648 switch key { 6649 default: 6650 _, _ = key, value 6651 6652 } 6653 } 6654 *v = sv 6655 return nil 6656} 6657 6658func awsAwsjson11_deserializeOpDocumentApproveAssignmentOutput(v **ApproveAssignmentOutput, value interface{}) error { 6659 if v == nil { 6660 return fmt.Errorf("unexpected nil of type %T", v) 6661 } 6662 if value == nil { 6663 return nil 6664 } 6665 6666 shape, ok := value.(map[string]interface{}) 6667 if !ok { 6668 return fmt.Errorf("unexpected JSON type %v", value) 6669 } 6670 6671 var sv *ApproveAssignmentOutput 6672 if *v == nil { 6673 sv = &ApproveAssignmentOutput{} 6674 } else { 6675 sv = *v 6676 } 6677 6678 for key, value := range shape { 6679 switch key { 6680 default: 6681 _, _ = key, value 6682 6683 } 6684 } 6685 *v = sv 6686 return nil 6687} 6688 6689func awsAwsjson11_deserializeOpDocumentAssociateQualificationWithWorkerOutput(v **AssociateQualificationWithWorkerOutput, value interface{}) error { 6690 if v == nil { 6691 return fmt.Errorf("unexpected nil of type %T", v) 6692 } 6693 if value == nil { 6694 return nil 6695 } 6696 6697 shape, ok := value.(map[string]interface{}) 6698 if !ok { 6699 return fmt.Errorf("unexpected JSON type %v", value) 6700 } 6701 6702 var sv *AssociateQualificationWithWorkerOutput 6703 if *v == nil { 6704 sv = &AssociateQualificationWithWorkerOutput{} 6705 } else { 6706 sv = *v 6707 } 6708 6709 for key, value := range shape { 6710 switch key { 6711 default: 6712 _, _ = key, value 6713 6714 } 6715 } 6716 *v = sv 6717 return nil 6718} 6719 6720func awsAwsjson11_deserializeOpDocumentCreateAdditionalAssignmentsForHITOutput(v **CreateAdditionalAssignmentsForHITOutput, value interface{}) error { 6721 if v == nil { 6722 return fmt.Errorf("unexpected nil of type %T", v) 6723 } 6724 if value == nil { 6725 return nil 6726 } 6727 6728 shape, ok := value.(map[string]interface{}) 6729 if !ok { 6730 return fmt.Errorf("unexpected JSON type %v", value) 6731 } 6732 6733 var sv *CreateAdditionalAssignmentsForHITOutput 6734 if *v == nil { 6735 sv = &CreateAdditionalAssignmentsForHITOutput{} 6736 } else { 6737 sv = *v 6738 } 6739 6740 for key, value := range shape { 6741 switch key { 6742 default: 6743 _, _ = key, value 6744 6745 } 6746 } 6747 *v = sv 6748 return nil 6749} 6750 6751func awsAwsjson11_deserializeOpDocumentCreateHITOutput(v **CreateHITOutput, value interface{}) error { 6752 if v == nil { 6753 return fmt.Errorf("unexpected nil of type %T", v) 6754 } 6755 if value == nil { 6756 return nil 6757 } 6758 6759 shape, ok := value.(map[string]interface{}) 6760 if !ok { 6761 return fmt.Errorf("unexpected JSON type %v", value) 6762 } 6763 6764 var sv *CreateHITOutput 6765 if *v == nil { 6766 sv = &CreateHITOutput{} 6767 } else { 6768 sv = *v 6769 } 6770 6771 for key, value := range shape { 6772 switch key { 6773 case "HIT": 6774 if err := awsAwsjson11_deserializeDocumentHIT(&sv.HIT, value); err != nil { 6775 return err 6776 } 6777 6778 default: 6779 _, _ = key, value 6780 6781 } 6782 } 6783 *v = sv 6784 return nil 6785} 6786 6787func awsAwsjson11_deserializeOpDocumentCreateHITTypeOutput(v **CreateHITTypeOutput, value interface{}) error { 6788 if v == nil { 6789 return fmt.Errorf("unexpected nil of type %T", v) 6790 } 6791 if value == nil { 6792 return nil 6793 } 6794 6795 shape, ok := value.(map[string]interface{}) 6796 if !ok { 6797 return fmt.Errorf("unexpected JSON type %v", value) 6798 } 6799 6800 var sv *CreateHITTypeOutput 6801 if *v == nil { 6802 sv = &CreateHITTypeOutput{} 6803 } else { 6804 sv = *v 6805 } 6806 6807 for key, value := range shape { 6808 switch key { 6809 case "HITTypeId": 6810 if value != nil { 6811 jtv, ok := value.(string) 6812 if !ok { 6813 return fmt.Errorf("expected EntityId to be of type string, got %T instead", value) 6814 } 6815 sv.HITTypeId = ptr.String(jtv) 6816 } 6817 6818 default: 6819 _, _ = key, value 6820 6821 } 6822 } 6823 *v = sv 6824 return nil 6825} 6826 6827func awsAwsjson11_deserializeOpDocumentCreateHITWithHITTypeOutput(v **CreateHITWithHITTypeOutput, value interface{}) error { 6828 if v == nil { 6829 return fmt.Errorf("unexpected nil of type %T", v) 6830 } 6831 if value == nil { 6832 return nil 6833 } 6834 6835 shape, ok := value.(map[string]interface{}) 6836 if !ok { 6837 return fmt.Errorf("unexpected JSON type %v", value) 6838 } 6839 6840 var sv *CreateHITWithHITTypeOutput 6841 if *v == nil { 6842 sv = &CreateHITWithHITTypeOutput{} 6843 } else { 6844 sv = *v 6845 } 6846 6847 for key, value := range shape { 6848 switch key { 6849 case "HIT": 6850 if err := awsAwsjson11_deserializeDocumentHIT(&sv.HIT, value); err != nil { 6851 return err 6852 } 6853 6854 default: 6855 _, _ = key, value 6856 6857 } 6858 } 6859 *v = sv 6860 return nil 6861} 6862 6863func awsAwsjson11_deserializeOpDocumentCreateQualificationTypeOutput(v **CreateQualificationTypeOutput, value interface{}) error { 6864 if v == nil { 6865 return fmt.Errorf("unexpected nil of type %T", v) 6866 } 6867 if value == nil { 6868 return nil 6869 } 6870 6871 shape, ok := value.(map[string]interface{}) 6872 if !ok { 6873 return fmt.Errorf("unexpected JSON type %v", value) 6874 } 6875 6876 var sv *CreateQualificationTypeOutput 6877 if *v == nil { 6878 sv = &CreateQualificationTypeOutput{} 6879 } else { 6880 sv = *v 6881 } 6882 6883 for key, value := range shape { 6884 switch key { 6885 case "QualificationType": 6886 if err := awsAwsjson11_deserializeDocumentQualificationType(&sv.QualificationType, value); err != nil { 6887 return err 6888 } 6889 6890 default: 6891 _, _ = key, value 6892 6893 } 6894 } 6895 *v = sv 6896 return nil 6897} 6898 6899func awsAwsjson11_deserializeOpDocumentCreateWorkerBlockOutput(v **CreateWorkerBlockOutput, value interface{}) error { 6900 if v == nil { 6901 return fmt.Errorf("unexpected nil of type %T", v) 6902 } 6903 if value == nil { 6904 return nil 6905 } 6906 6907 shape, ok := value.(map[string]interface{}) 6908 if !ok { 6909 return fmt.Errorf("unexpected JSON type %v", value) 6910 } 6911 6912 var sv *CreateWorkerBlockOutput 6913 if *v == nil { 6914 sv = &CreateWorkerBlockOutput{} 6915 } else { 6916 sv = *v 6917 } 6918 6919 for key, value := range shape { 6920 switch key { 6921 default: 6922 _, _ = key, value 6923 6924 } 6925 } 6926 *v = sv 6927 return nil 6928} 6929 6930func awsAwsjson11_deserializeOpDocumentDeleteHITOutput(v **DeleteHITOutput, value interface{}) error { 6931 if v == nil { 6932 return fmt.Errorf("unexpected nil of type %T", v) 6933 } 6934 if value == nil { 6935 return nil 6936 } 6937 6938 shape, ok := value.(map[string]interface{}) 6939 if !ok { 6940 return fmt.Errorf("unexpected JSON type %v", value) 6941 } 6942 6943 var sv *DeleteHITOutput 6944 if *v == nil { 6945 sv = &DeleteHITOutput{} 6946 } else { 6947 sv = *v 6948 } 6949 6950 for key, value := range shape { 6951 switch key { 6952 default: 6953 _, _ = key, value 6954 6955 } 6956 } 6957 *v = sv 6958 return nil 6959} 6960 6961func awsAwsjson11_deserializeOpDocumentDeleteQualificationTypeOutput(v **DeleteQualificationTypeOutput, value interface{}) error { 6962 if v == nil { 6963 return fmt.Errorf("unexpected nil of type %T", v) 6964 } 6965 if value == nil { 6966 return nil 6967 } 6968 6969 shape, ok := value.(map[string]interface{}) 6970 if !ok { 6971 return fmt.Errorf("unexpected JSON type %v", value) 6972 } 6973 6974 var sv *DeleteQualificationTypeOutput 6975 if *v == nil { 6976 sv = &DeleteQualificationTypeOutput{} 6977 } else { 6978 sv = *v 6979 } 6980 6981 for key, value := range shape { 6982 switch key { 6983 default: 6984 _, _ = key, value 6985 6986 } 6987 } 6988 *v = sv 6989 return nil 6990} 6991 6992func awsAwsjson11_deserializeOpDocumentDeleteWorkerBlockOutput(v **DeleteWorkerBlockOutput, value interface{}) error { 6993 if v == nil { 6994 return fmt.Errorf("unexpected nil of type %T", v) 6995 } 6996 if value == nil { 6997 return nil 6998 } 6999 7000 shape, ok := value.(map[string]interface{}) 7001 if !ok { 7002 return fmt.Errorf("unexpected JSON type %v", value) 7003 } 7004 7005 var sv *DeleteWorkerBlockOutput 7006 if *v == nil { 7007 sv = &DeleteWorkerBlockOutput{} 7008 } else { 7009 sv = *v 7010 } 7011 7012 for key, value := range shape { 7013 switch key { 7014 default: 7015 _, _ = key, value 7016 7017 } 7018 } 7019 *v = sv 7020 return nil 7021} 7022 7023func awsAwsjson11_deserializeOpDocumentDisassociateQualificationFromWorkerOutput(v **DisassociateQualificationFromWorkerOutput, value interface{}) error { 7024 if v == nil { 7025 return fmt.Errorf("unexpected nil of type %T", v) 7026 } 7027 if value == nil { 7028 return nil 7029 } 7030 7031 shape, ok := value.(map[string]interface{}) 7032 if !ok { 7033 return fmt.Errorf("unexpected JSON type %v", value) 7034 } 7035 7036 var sv *DisassociateQualificationFromWorkerOutput 7037 if *v == nil { 7038 sv = &DisassociateQualificationFromWorkerOutput{} 7039 } else { 7040 sv = *v 7041 } 7042 7043 for key, value := range shape { 7044 switch key { 7045 default: 7046 _, _ = key, value 7047 7048 } 7049 } 7050 *v = sv 7051 return nil 7052} 7053 7054func awsAwsjson11_deserializeOpDocumentGetAccountBalanceOutput(v **GetAccountBalanceOutput, value interface{}) error { 7055 if v == nil { 7056 return fmt.Errorf("unexpected nil of type %T", v) 7057 } 7058 if value == nil { 7059 return nil 7060 } 7061 7062 shape, ok := value.(map[string]interface{}) 7063 if !ok { 7064 return fmt.Errorf("unexpected JSON type %v", value) 7065 } 7066 7067 var sv *GetAccountBalanceOutput 7068 if *v == nil { 7069 sv = &GetAccountBalanceOutput{} 7070 } else { 7071 sv = *v 7072 } 7073 7074 for key, value := range shape { 7075 switch key { 7076 case "AvailableBalance": 7077 if value != nil { 7078 jtv, ok := value.(string) 7079 if !ok { 7080 return fmt.Errorf("expected CurrencyAmount to be of type string, got %T instead", value) 7081 } 7082 sv.AvailableBalance = ptr.String(jtv) 7083 } 7084 7085 case "OnHoldBalance": 7086 if value != nil { 7087 jtv, ok := value.(string) 7088 if !ok { 7089 return fmt.Errorf("expected CurrencyAmount to be of type string, got %T instead", value) 7090 } 7091 sv.OnHoldBalance = ptr.String(jtv) 7092 } 7093 7094 default: 7095 _, _ = key, value 7096 7097 } 7098 } 7099 *v = sv 7100 return nil 7101} 7102 7103func awsAwsjson11_deserializeOpDocumentGetAssignmentOutput(v **GetAssignmentOutput, value interface{}) error { 7104 if v == nil { 7105 return fmt.Errorf("unexpected nil of type %T", v) 7106 } 7107 if value == nil { 7108 return nil 7109 } 7110 7111 shape, ok := value.(map[string]interface{}) 7112 if !ok { 7113 return fmt.Errorf("unexpected JSON type %v", value) 7114 } 7115 7116 var sv *GetAssignmentOutput 7117 if *v == nil { 7118 sv = &GetAssignmentOutput{} 7119 } else { 7120 sv = *v 7121 } 7122 7123 for key, value := range shape { 7124 switch key { 7125 case "Assignment": 7126 if err := awsAwsjson11_deserializeDocumentAssignment(&sv.Assignment, value); err != nil { 7127 return err 7128 } 7129 7130 case "HIT": 7131 if err := awsAwsjson11_deserializeDocumentHIT(&sv.HIT, value); err != nil { 7132 return err 7133 } 7134 7135 default: 7136 _, _ = key, value 7137 7138 } 7139 } 7140 *v = sv 7141 return nil 7142} 7143 7144func awsAwsjson11_deserializeOpDocumentGetFileUploadURLOutput(v **GetFileUploadURLOutput, value interface{}) error { 7145 if v == nil { 7146 return fmt.Errorf("unexpected nil of type %T", v) 7147 } 7148 if value == nil { 7149 return nil 7150 } 7151 7152 shape, ok := value.(map[string]interface{}) 7153 if !ok { 7154 return fmt.Errorf("unexpected JSON type %v", value) 7155 } 7156 7157 var sv *GetFileUploadURLOutput 7158 if *v == nil { 7159 sv = &GetFileUploadURLOutput{} 7160 } else { 7161 sv = *v 7162 } 7163 7164 for key, value := range shape { 7165 switch key { 7166 case "FileUploadURL": 7167 if value != nil { 7168 jtv, ok := value.(string) 7169 if !ok { 7170 return fmt.Errorf("expected String to be of type string, got %T instead", value) 7171 } 7172 sv.FileUploadURL = ptr.String(jtv) 7173 } 7174 7175 default: 7176 _, _ = key, value 7177 7178 } 7179 } 7180 *v = sv 7181 return nil 7182} 7183 7184func awsAwsjson11_deserializeOpDocumentGetHITOutput(v **GetHITOutput, value interface{}) error { 7185 if v == nil { 7186 return fmt.Errorf("unexpected nil of type %T", v) 7187 } 7188 if value == nil { 7189 return nil 7190 } 7191 7192 shape, ok := value.(map[string]interface{}) 7193 if !ok { 7194 return fmt.Errorf("unexpected JSON type %v", value) 7195 } 7196 7197 var sv *GetHITOutput 7198 if *v == nil { 7199 sv = &GetHITOutput{} 7200 } else { 7201 sv = *v 7202 } 7203 7204 for key, value := range shape { 7205 switch key { 7206 case "HIT": 7207 if err := awsAwsjson11_deserializeDocumentHIT(&sv.HIT, value); err != nil { 7208 return err 7209 } 7210 7211 default: 7212 _, _ = key, value 7213 7214 } 7215 } 7216 *v = sv 7217 return nil 7218} 7219 7220func awsAwsjson11_deserializeOpDocumentGetQualificationScoreOutput(v **GetQualificationScoreOutput, value interface{}) error { 7221 if v == nil { 7222 return fmt.Errorf("unexpected nil of type %T", v) 7223 } 7224 if value == nil { 7225 return nil 7226 } 7227 7228 shape, ok := value.(map[string]interface{}) 7229 if !ok { 7230 return fmt.Errorf("unexpected JSON type %v", value) 7231 } 7232 7233 var sv *GetQualificationScoreOutput 7234 if *v == nil { 7235 sv = &GetQualificationScoreOutput{} 7236 } else { 7237 sv = *v 7238 } 7239 7240 for key, value := range shape { 7241 switch key { 7242 case "Qualification": 7243 if err := awsAwsjson11_deserializeDocumentQualification(&sv.Qualification, value); err != nil { 7244 return err 7245 } 7246 7247 default: 7248 _, _ = key, value 7249 7250 } 7251 } 7252 *v = sv 7253 return nil 7254} 7255 7256func awsAwsjson11_deserializeOpDocumentGetQualificationTypeOutput(v **GetQualificationTypeOutput, value interface{}) error { 7257 if v == nil { 7258 return fmt.Errorf("unexpected nil of type %T", v) 7259 } 7260 if value == nil { 7261 return nil 7262 } 7263 7264 shape, ok := value.(map[string]interface{}) 7265 if !ok { 7266 return fmt.Errorf("unexpected JSON type %v", value) 7267 } 7268 7269 var sv *GetQualificationTypeOutput 7270 if *v == nil { 7271 sv = &GetQualificationTypeOutput{} 7272 } else { 7273 sv = *v 7274 } 7275 7276 for key, value := range shape { 7277 switch key { 7278 case "QualificationType": 7279 if err := awsAwsjson11_deserializeDocumentQualificationType(&sv.QualificationType, value); err != nil { 7280 return err 7281 } 7282 7283 default: 7284 _, _ = key, value 7285 7286 } 7287 } 7288 *v = sv 7289 return nil 7290} 7291 7292func awsAwsjson11_deserializeOpDocumentListAssignmentsForHITOutput(v **ListAssignmentsForHITOutput, value interface{}) error { 7293 if v == nil { 7294 return fmt.Errorf("unexpected nil of type %T", v) 7295 } 7296 if value == nil { 7297 return nil 7298 } 7299 7300 shape, ok := value.(map[string]interface{}) 7301 if !ok { 7302 return fmt.Errorf("unexpected JSON type %v", value) 7303 } 7304 7305 var sv *ListAssignmentsForHITOutput 7306 if *v == nil { 7307 sv = &ListAssignmentsForHITOutput{} 7308 } else { 7309 sv = *v 7310 } 7311 7312 for key, value := range shape { 7313 switch key { 7314 case "Assignments": 7315 if err := awsAwsjson11_deserializeDocumentAssignmentList(&sv.Assignments, value); err != nil { 7316 return err 7317 } 7318 7319 case "NextToken": 7320 if value != nil { 7321 jtv, ok := value.(string) 7322 if !ok { 7323 return fmt.Errorf("expected PaginationToken to be of type string, got %T instead", value) 7324 } 7325 sv.NextToken = ptr.String(jtv) 7326 } 7327 7328 case "NumResults": 7329 if value != nil { 7330 jtv, ok := value.(json.Number) 7331 if !ok { 7332 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 7333 } 7334 i64, err := jtv.Int64() 7335 if err != nil { 7336 return err 7337 } 7338 sv.NumResults = ptr.Int32(int32(i64)) 7339 } 7340 7341 default: 7342 _, _ = key, value 7343 7344 } 7345 } 7346 *v = sv 7347 return nil 7348} 7349 7350func awsAwsjson11_deserializeOpDocumentListBonusPaymentsOutput(v **ListBonusPaymentsOutput, value interface{}) error { 7351 if v == nil { 7352 return fmt.Errorf("unexpected nil of type %T", v) 7353 } 7354 if value == nil { 7355 return nil 7356 } 7357 7358 shape, ok := value.(map[string]interface{}) 7359 if !ok { 7360 return fmt.Errorf("unexpected JSON type %v", value) 7361 } 7362 7363 var sv *ListBonusPaymentsOutput 7364 if *v == nil { 7365 sv = &ListBonusPaymentsOutput{} 7366 } else { 7367 sv = *v 7368 } 7369 7370 for key, value := range shape { 7371 switch key { 7372 case "BonusPayments": 7373 if err := awsAwsjson11_deserializeDocumentBonusPaymentList(&sv.BonusPayments, value); err != nil { 7374 return err 7375 } 7376 7377 case "NextToken": 7378 if value != nil { 7379 jtv, ok := value.(string) 7380 if !ok { 7381 return fmt.Errorf("expected PaginationToken to be of type string, got %T instead", value) 7382 } 7383 sv.NextToken = ptr.String(jtv) 7384 } 7385 7386 case "NumResults": 7387 if value != nil { 7388 jtv, ok := value.(json.Number) 7389 if !ok { 7390 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 7391 } 7392 i64, err := jtv.Int64() 7393 if err != nil { 7394 return err 7395 } 7396 sv.NumResults = ptr.Int32(int32(i64)) 7397 } 7398 7399 default: 7400 _, _ = key, value 7401 7402 } 7403 } 7404 *v = sv 7405 return nil 7406} 7407 7408func awsAwsjson11_deserializeOpDocumentListHITsForQualificationTypeOutput(v **ListHITsForQualificationTypeOutput, value interface{}) error { 7409 if v == nil { 7410 return fmt.Errorf("unexpected nil of type %T", v) 7411 } 7412 if value == nil { 7413 return nil 7414 } 7415 7416 shape, ok := value.(map[string]interface{}) 7417 if !ok { 7418 return fmt.Errorf("unexpected JSON type %v", value) 7419 } 7420 7421 var sv *ListHITsForQualificationTypeOutput 7422 if *v == nil { 7423 sv = &ListHITsForQualificationTypeOutput{} 7424 } else { 7425 sv = *v 7426 } 7427 7428 for key, value := range shape { 7429 switch key { 7430 case "HITs": 7431 if err := awsAwsjson11_deserializeDocumentHITList(&sv.HITs, value); err != nil { 7432 return err 7433 } 7434 7435 case "NextToken": 7436 if value != nil { 7437 jtv, ok := value.(string) 7438 if !ok { 7439 return fmt.Errorf("expected PaginationToken to be of type string, got %T instead", value) 7440 } 7441 sv.NextToken = ptr.String(jtv) 7442 } 7443 7444 case "NumResults": 7445 if value != nil { 7446 jtv, ok := value.(json.Number) 7447 if !ok { 7448 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 7449 } 7450 i64, err := jtv.Int64() 7451 if err != nil { 7452 return err 7453 } 7454 sv.NumResults = ptr.Int32(int32(i64)) 7455 } 7456 7457 default: 7458 _, _ = key, value 7459 7460 } 7461 } 7462 *v = sv 7463 return nil 7464} 7465 7466func awsAwsjson11_deserializeOpDocumentListHITsOutput(v **ListHITsOutput, value interface{}) error { 7467 if v == nil { 7468 return fmt.Errorf("unexpected nil of type %T", v) 7469 } 7470 if value == nil { 7471 return nil 7472 } 7473 7474 shape, ok := value.(map[string]interface{}) 7475 if !ok { 7476 return fmt.Errorf("unexpected JSON type %v", value) 7477 } 7478 7479 var sv *ListHITsOutput 7480 if *v == nil { 7481 sv = &ListHITsOutput{} 7482 } else { 7483 sv = *v 7484 } 7485 7486 for key, value := range shape { 7487 switch key { 7488 case "HITs": 7489 if err := awsAwsjson11_deserializeDocumentHITList(&sv.HITs, value); err != nil { 7490 return err 7491 } 7492 7493 case "NextToken": 7494 if value != nil { 7495 jtv, ok := value.(string) 7496 if !ok { 7497 return fmt.Errorf("expected PaginationToken to be of type string, got %T instead", value) 7498 } 7499 sv.NextToken = ptr.String(jtv) 7500 } 7501 7502 case "NumResults": 7503 if value != nil { 7504 jtv, ok := value.(json.Number) 7505 if !ok { 7506 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 7507 } 7508 i64, err := jtv.Int64() 7509 if err != nil { 7510 return err 7511 } 7512 sv.NumResults = ptr.Int32(int32(i64)) 7513 } 7514 7515 default: 7516 _, _ = key, value 7517 7518 } 7519 } 7520 *v = sv 7521 return nil 7522} 7523 7524func awsAwsjson11_deserializeOpDocumentListQualificationRequestsOutput(v **ListQualificationRequestsOutput, value interface{}) error { 7525 if v == nil { 7526 return fmt.Errorf("unexpected nil of type %T", v) 7527 } 7528 if value == nil { 7529 return nil 7530 } 7531 7532 shape, ok := value.(map[string]interface{}) 7533 if !ok { 7534 return fmt.Errorf("unexpected JSON type %v", value) 7535 } 7536 7537 var sv *ListQualificationRequestsOutput 7538 if *v == nil { 7539 sv = &ListQualificationRequestsOutput{} 7540 } else { 7541 sv = *v 7542 } 7543 7544 for key, value := range shape { 7545 switch key { 7546 case "NextToken": 7547 if value != nil { 7548 jtv, ok := value.(string) 7549 if !ok { 7550 return fmt.Errorf("expected PaginationToken to be of type string, got %T instead", value) 7551 } 7552 sv.NextToken = ptr.String(jtv) 7553 } 7554 7555 case "NumResults": 7556 if value != nil { 7557 jtv, ok := value.(json.Number) 7558 if !ok { 7559 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 7560 } 7561 i64, err := jtv.Int64() 7562 if err != nil { 7563 return err 7564 } 7565 sv.NumResults = ptr.Int32(int32(i64)) 7566 } 7567 7568 case "QualificationRequests": 7569 if err := awsAwsjson11_deserializeDocumentQualificationRequestList(&sv.QualificationRequests, value); err != nil { 7570 return err 7571 } 7572 7573 default: 7574 _, _ = key, value 7575 7576 } 7577 } 7578 *v = sv 7579 return nil 7580} 7581 7582func awsAwsjson11_deserializeOpDocumentListQualificationTypesOutput(v **ListQualificationTypesOutput, value interface{}) error { 7583 if v == nil { 7584 return fmt.Errorf("unexpected nil of type %T", v) 7585 } 7586 if value == nil { 7587 return nil 7588 } 7589 7590 shape, ok := value.(map[string]interface{}) 7591 if !ok { 7592 return fmt.Errorf("unexpected JSON type %v", value) 7593 } 7594 7595 var sv *ListQualificationTypesOutput 7596 if *v == nil { 7597 sv = &ListQualificationTypesOutput{} 7598 } else { 7599 sv = *v 7600 } 7601 7602 for key, value := range shape { 7603 switch key { 7604 case "NextToken": 7605 if value != nil { 7606 jtv, ok := value.(string) 7607 if !ok { 7608 return fmt.Errorf("expected PaginationToken to be of type string, got %T instead", value) 7609 } 7610 sv.NextToken = ptr.String(jtv) 7611 } 7612 7613 case "NumResults": 7614 if value != nil { 7615 jtv, ok := value.(json.Number) 7616 if !ok { 7617 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 7618 } 7619 i64, err := jtv.Int64() 7620 if err != nil { 7621 return err 7622 } 7623 sv.NumResults = ptr.Int32(int32(i64)) 7624 } 7625 7626 case "QualificationTypes": 7627 if err := awsAwsjson11_deserializeDocumentQualificationTypeList(&sv.QualificationTypes, value); err != nil { 7628 return err 7629 } 7630 7631 default: 7632 _, _ = key, value 7633 7634 } 7635 } 7636 *v = sv 7637 return nil 7638} 7639 7640func awsAwsjson11_deserializeOpDocumentListReviewableHITsOutput(v **ListReviewableHITsOutput, value interface{}) error { 7641 if v == nil { 7642 return fmt.Errorf("unexpected nil of type %T", v) 7643 } 7644 if value == nil { 7645 return nil 7646 } 7647 7648 shape, ok := value.(map[string]interface{}) 7649 if !ok { 7650 return fmt.Errorf("unexpected JSON type %v", value) 7651 } 7652 7653 var sv *ListReviewableHITsOutput 7654 if *v == nil { 7655 sv = &ListReviewableHITsOutput{} 7656 } else { 7657 sv = *v 7658 } 7659 7660 for key, value := range shape { 7661 switch key { 7662 case "HITs": 7663 if err := awsAwsjson11_deserializeDocumentHITList(&sv.HITs, value); err != nil { 7664 return err 7665 } 7666 7667 case "NextToken": 7668 if value != nil { 7669 jtv, ok := value.(string) 7670 if !ok { 7671 return fmt.Errorf("expected PaginationToken to be of type string, got %T instead", value) 7672 } 7673 sv.NextToken = ptr.String(jtv) 7674 } 7675 7676 case "NumResults": 7677 if value != nil { 7678 jtv, ok := value.(json.Number) 7679 if !ok { 7680 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 7681 } 7682 i64, err := jtv.Int64() 7683 if err != nil { 7684 return err 7685 } 7686 sv.NumResults = ptr.Int32(int32(i64)) 7687 } 7688 7689 default: 7690 _, _ = key, value 7691 7692 } 7693 } 7694 *v = sv 7695 return nil 7696} 7697 7698func awsAwsjson11_deserializeOpDocumentListReviewPolicyResultsForHITOutput(v **ListReviewPolicyResultsForHITOutput, value interface{}) error { 7699 if v == nil { 7700 return fmt.Errorf("unexpected nil of type %T", v) 7701 } 7702 if value == nil { 7703 return nil 7704 } 7705 7706 shape, ok := value.(map[string]interface{}) 7707 if !ok { 7708 return fmt.Errorf("unexpected JSON type %v", value) 7709 } 7710 7711 var sv *ListReviewPolicyResultsForHITOutput 7712 if *v == nil { 7713 sv = &ListReviewPolicyResultsForHITOutput{} 7714 } else { 7715 sv = *v 7716 } 7717 7718 for key, value := range shape { 7719 switch key { 7720 case "AssignmentReviewPolicy": 7721 if err := awsAwsjson11_deserializeDocumentReviewPolicy(&sv.AssignmentReviewPolicy, value); err != nil { 7722 return err 7723 } 7724 7725 case "AssignmentReviewReport": 7726 if err := awsAwsjson11_deserializeDocumentReviewReport(&sv.AssignmentReviewReport, value); err != nil { 7727 return err 7728 } 7729 7730 case "HITId": 7731 if value != nil { 7732 jtv, ok := value.(string) 7733 if !ok { 7734 return fmt.Errorf("expected EntityId to be of type string, got %T instead", value) 7735 } 7736 sv.HITId = ptr.String(jtv) 7737 } 7738 7739 case "HITReviewPolicy": 7740 if err := awsAwsjson11_deserializeDocumentReviewPolicy(&sv.HITReviewPolicy, value); err != nil { 7741 return err 7742 } 7743 7744 case "HITReviewReport": 7745 if err := awsAwsjson11_deserializeDocumentReviewReport(&sv.HITReviewReport, value); err != nil { 7746 return err 7747 } 7748 7749 case "NextToken": 7750 if value != nil { 7751 jtv, ok := value.(string) 7752 if !ok { 7753 return fmt.Errorf("expected PaginationToken to be of type string, got %T instead", value) 7754 } 7755 sv.NextToken = ptr.String(jtv) 7756 } 7757 7758 default: 7759 _, _ = key, value 7760 7761 } 7762 } 7763 *v = sv 7764 return nil 7765} 7766 7767func awsAwsjson11_deserializeOpDocumentListWorkerBlocksOutput(v **ListWorkerBlocksOutput, value interface{}) error { 7768 if v == nil { 7769 return fmt.Errorf("unexpected nil of type %T", v) 7770 } 7771 if value == nil { 7772 return nil 7773 } 7774 7775 shape, ok := value.(map[string]interface{}) 7776 if !ok { 7777 return fmt.Errorf("unexpected JSON type %v", value) 7778 } 7779 7780 var sv *ListWorkerBlocksOutput 7781 if *v == nil { 7782 sv = &ListWorkerBlocksOutput{} 7783 } else { 7784 sv = *v 7785 } 7786 7787 for key, value := range shape { 7788 switch key { 7789 case "NextToken": 7790 if value != nil { 7791 jtv, ok := value.(string) 7792 if !ok { 7793 return fmt.Errorf("expected PaginationToken to be of type string, got %T instead", value) 7794 } 7795 sv.NextToken = ptr.String(jtv) 7796 } 7797 7798 case "NumResults": 7799 if value != nil { 7800 jtv, ok := value.(json.Number) 7801 if !ok { 7802 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 7803 } 7804 i64, err := jtv.Int64() 7805 if err != nil { 7806 return err 7807 } 7808 sv.NumResults = ptr.Int32(int32(i64)) 7809 } 7810 7811 case "WorkerBlocks": 7812 if err := awsAwsjson11_deserializeDocumentWorkerBlockList(&sv.WorkerBlocks, value); err != nil { 7813 return err 7814 } 7815 7816 default: 7817 _, _ = key, value 7818 7819 } 7820 } 7821 *v = sv 7822 return nil 7823} 7824 7825func awsAwsjson11_deserializeOpDocumentListWorkersWithQualificationTypeOutput(v **ListWorkersWithQualificationTypeOutput, value interface{}) error { 7826 if v == nil { 7827 return fmt.Errorf("unexpected nil of type %T", v) 7828 } 7829 if value == nil { 7830 return nil 7831 } 7832 7833 shape, ok := value.(map[string]interface{}) 7834 if !ok { 7835 return fmt.Errorf("unexpected JSON type %v", value) 7836 } 7837 7838 var sv *ListWorkersWithQualificationTypeOutput 7839 if *v == nil { 7840 sv = &ListWorkersWithQualificationTypeOutput{} 7841 } else { 7842 sv = *v 7843 } 7844 7845 for key, value := range shape { 7846 switch key { 7847 case "NextToken": 7848 if value != nil { 7849 jtv, ok := value.(string) 7850 if !ok { 7851 return fmt.Errorf("expected PaginationToken to be of type string, got %T instead", value) 7852 } 7853 sv.NextToken = ptr.String(jtv) 7854 } 7855 7856 case "NumResults": 7857 if value != nil { 7858 jtv, ok := value.(json.Number) 7859 if !ok { 7860 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 7861 } 7862 i64, err := jtv.Int64() 7863 if err != nil { 7864 return err 7865 } 7866 sv.NumResults = ptr.Int32(int32(i64)) 7867 } 7868 7869 case "Qualifications": 7870 if err := awsAwsjson11_deserializeDocumentQualificationList(&sv.Qualifications, value); err != nil { 7871 return err 7872 } 7873 7874 default: 7875 _, _ = key, value 7876 7877 } 7878 } 7879 *v = sv 7880 return nil 7881} 7882 7883func awsAwsjson11_deserializeOpDocumentNotifyWorkersOutput(v **NotifyWorkersOutput, value interface{}) error { 7884 if v == nil { 7885 return fmt.Errorf("unexpected nil of type %T", v) 7886 } 7887 if value == nil { 7888 return nil 7889 } 7890 7891 shape, ok := value.(map[string]interface{}) 7892 if !ok { 7893 return fmt.Errorf("unexpected JSON type %v", value) 7894 } 7895 7896 var sv *NotifyWorkersOutput 7897 if *v == nil { 7898 sv = &NotifyWorkersOutput{} 7899 } else { 7900 sv = *v 7901 } 7902 7903 for key, value := range shape { 7904 switch key { 7905 case "NotifyWorkersFailureStatuses": 7906 if err := awsAwsjson11_deserializeDocumentNotifyWorkersFailureStatusList(&sv.NotifyWorkersFailureStatuses, value); err != nil { 7907 return err 7908 } 7909 7910 default: 7911 _, _ = key, value 7912 7913 } 7914 } 7915 *v = sv 7916 return nil 7917} 7918 7919func awsAwsjson11_deserializeOpDocumentRejectAssignmentOutput(v **RejectAssignmentOutput, value interface{}) error { 7920 if v == nil { 7921 return fmt.Errorf("unexpected nil of type %T", v) 7922 } 7923 if value == nil { 7924 return nil 7925 } 7926 7927 shape, ok := value.(map[string]interface{}) 7928 if !ok { 7929 return fmt.Errorf("unexpected JSON type %v", value) 7930 } 7931 7932 var sv *RejectAssignmentOutput 7933 if *v == nil { 7934 sv = &RejectAssignmentOutput{} 7935 } else { 7936 sv = *v 7937 } 7938 7939 for key, value := range shape { 7940 switch key { 7941 default: 7942 _, _ = key, value 7943 7944 } 7945 } 7946 *v = sv 7947 return nil 7948} 7949 7950func awsAwsjson11_deserializeOpDocumentRejectQualificationRequestOutput(v **RejectQualificationRequestOutput, value interface{}) error { 7951 if v == nil { 7952 return fmt.Errorf("unexpected nil of type %T", v) 7953 } 7954 if value == nil { 7955 return nil 7956 } 7957 7958 shape, ok := value.(map[string]interface{}) 7959 if !ok { 7960 return fmt.Errorf("unexpected JSON type %v", value) 7961 } 7962 7963 var sv *RejectQualificationRequestOutput 7964 if *v == nil { 7965 sv = &RejectQualificationRequestOutput{} 7966 } else { 7967 sv = *v 7968 } 7969 7970 for key, value := range shape { 7971 switch key { 7972 default: 7973 _, _ = key, value 7974 7975 } 7976 } 7977 *v = sv 7978 return nil 7979} 7980 7981func awsAwsjson11_deserializeOpDocumentSendBonusOutput(v **SendBonusOutput, value interface{}) error { 7982 if v == nil { 7983 return fmt.Errorf("unexpected nil of type %T", v) 7984 } 7985 if value == nil { 7986 return nil 7987 } 7988 7989 shape, ok := value.(map[string]interface{}) 7990 if !ok { 7991 return fmt.Errorf("unexpected JSON type %v", value) 7992 } 7993 7994 var sv *SendBonusOutput 7995 if *v == nil { 7996 sv = &SendBonusOutput{} 7997 } else { 7998 sv = *v 7999 } 8000 8001 for key, value := range shape { 8002 switch key { 8003 default: 8004 _, _ = key, value 8005 8006 } 8007 } 8008 *v = sv 8009 return nil 8010} 8011 8012func awsAwsjson11_deserializeOpDocumentSendTestEventNotificationOutput(v **SendTestEventNotificationOutput, value interface{}) error { 8013 if v == nil { 8014 return fmt.Errorf("unexpected nil of type %T", v) 8015 } 8016 if value == nil { 8017 return nil 8018 } 8019 8020 shape, ok := value.(map[string]interface{}) 8021 if !ok { 8022 return fmt.Errorf("unexpected JSON type %v", value) 8023 } 8024 8025 var sv *SendTestEventNotificationOutput 8026 if *v == nil { 8027 sv = &SendTestEventNotificationOutput{} 8028 } else { 8029 sv = *v 8030 } 8031 8032 for key, value := range shape { 8033 switch key { 8034 default: 8035 _, _ = key, value 8036 8037 } 8038 } 8039 *v = sv 8040 return nil 8041} 8042 8043func awsAwsjson11_deserializeOpDocumentUpdateExpirationForHITOutput(v **UpdateExpirationForHITOutput, value interface{}) error { 8044 if v == nil { 8045 return fmt.Errorf("unexpected nil of type %T", v) 8046 } 8047 if value == nil { 8048 return nil 8049 } 8050 8051 shape, ok := value.(map[string]interface{}) 8052 if !ok { 8053 return fmt.Errorf("unexpected JSON type %v", value) 8054 } 8055 8056 var sv *UpdateExpirationForHITOutput 8057 if *v == nil { 8058 sv = &UpdateExpirationForHITOutput{} 8059 } else { 8060 sv = *v 8061 } 8062 8063 for key, value := range shape { 8064 switch key { 8065 default: 8066 _, _ = key, value 8067 8068 } 8069 } 8070 *v = sv 8071 return nil 8072} 8073 8074func awsAwsjson11_deserializeOpDocumentUpdateHITReviewStatusOutput(v **UpdateHITReviewStatusOutput, value interface{}) error { 8075 if v == nil { 8076 return fmt.Errorf("unexpected nil of type %T", v) 8077 } 8078 if value == nil { 8079 return nil 8080 } 8081 8082 shape, ok := value.(map[string]interface{}) 8083 if !ok { 8084 return fmt.Errorf("unexpected JSON type %v", value) 8085 } 8086 8087 var sv *UpdateHITReviewStatusOutput 8088 if *v == nil { 8089 sv = &UpdateHITReviewStatusOutput{} 8090 } else { 8091 sv = *v 8092 } 8093 8094 for key, value := range shape { 8095 switch key { 8096 default: 8097 _, _ = key, value 8098 8099 } 8100 } 8101 *v = sv 8102 return nil 8103} 8104 8105func awsAwsjson11_deserializeOpDocumentUpdateHITTypeOfHITOutput(v **UpdateHITTypeOfHITOutput, value interface{}) error { 8106 if v == nil { 8107 return fmt.Errorf("unexpected nil of type %T", v) 8108 } 8109 if value == nil { 8110 return nil 8111 } 8112 8113 shape, ok := value.(map[string]interface{}) 8114 if !ok { 8115 return fmt.Errorf("unexpected JSON type %v", value) 8116 } 8117 8118 var sv *UpdateHITTypeOfHITOutput 8119 if *v == nil { 8120 sv = &UpdateHITTypeOfHITOutput{} 8121 } else { 8122 sv = *v 8123 } 8124 8125 for key, value := range shape { 8126 switch key { 8127 default: 8128 _, _ = key, value 8129 8130 } 8131 } 8132 *v = sv 8133 return nil 8134} 8135 8136func awsAwsjson11_deserializeOpDocumentUpdateNotificationSettingsOutput(v **UpdateNotificationSettingsOutput, value interface{}) error { 8137 if v == nil { 8138 return fmt.Errorf("unexpected nil of type %T", v) 8139 } 8140 if value == nil { 8141 return nil 8142 } 8143 8144 shape, ok := value.(map[string]interface{}) 8145 if !ok { 8146 return fmt.Errorf("unexpected JSON type %v", value) 8147 } 8148 8149 var sv *UpdateNotificationSettingsOutput 8150 if *v == nil { 8151 sv = &UpdateNotificationSettingsOutput{} 8152 } else { 8153 sv = *v 8154 } 8155 8156 for key, value := range shape { 8157 switch key { 8158 default: 8159 _, _ = key, value 8160 8161 } 8162 } 8163 *v = sv 8164 return nil 8165} 8166 8167func awsAwsjson11_deserializeOpDocumentUpdateQualificationTypeOutput(v **UpdateQualificationTypeOutput, value interface{}) error { 8168 if v == nil { 8169 return fmt.Errorf("unexpected nil of type %T", v) 8170 } 8171 if value == nil { 8172 return nil 8173 } 8174 8175 shape, ok := value.(map[string]interface{}) 8176 if !ok { 8177 return fmt.Errorf("unexpected JSON type %v", value) 8178 } 8179 8180 var sv *UpdateQualificationTypeOutput 8181 if *v == nil { 8182 sv = &UpdateQualificationTypeOutput{} 8183 } else { 8184 sv = *v 8185 } 8186 8187 for key, value := range shape { 8188 switch key { 8189 case "QualificationType": 8190 if err := awsAwsjson11_deserializeDocumentQualificationType(&sv.QualificationType, value); err != nil { 8191 return err 8192 } 8193 8194 default: 8195 _, _ = key, value 8196 8197 } 8198 } 8199 *v = sv 8200 return nil 8201} 8202