1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package resourcegroupstaggingapi 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/resourcegroupstaggingapi/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 smithyhttp "github.com/aws/smithy-go/transport/http" 17 "io" 18 "strings" 19) 20 21type awsAwsjson11_deserializeOpDescribeReportCreation struct { 22} 23 24func (*awsAwsjson11_deserializeOpDescribeReportCreation) ID() string { 25 return "OperationDeserializer" 26} 27 28func (m *awsAwsjson11_deserializeOpDescribeReportCreation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 29 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 30) { 31 out, metadata, err = next.HandleDeserialize(ctx, in) 32 if err != nil { 33 return out, metadata, err 34 } 35 36 response, ok := out.RawResponse.(*smithyhttp.Response) 37 if !ok { 38 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 39 } 40 41 if response.StatusCode < 200 || response.StatusCode >= 300 { 42 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeReportCreation(response, &metadata) 43 } 44 output := &DescribeReportCreationOutput{} 45 out.Result = output 46 47 var buff [1024]byte 48 ringBuffer := smithyio.NewRingBuffer(buff[:]) 49 50 body := io.TeeReader(response.Body, ringBuffer) 51 decoder := json.NewDecoder(body) 52 decoder.UseNumber() 53 var shape interface{} 54 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 55 var snapshot bytes.Buffer 56 io.Copy(&snapshot, ringBuffer) 57 err = &smithy.DeserializationError{ 58 Err: fmt.Errorf("failed to decode response body, %w", err), 59 Snapshot: snapshot.Bytes(), 60 } 61 return out, metadata, err 62 } 63 64 err = awsAwsjson11_deserializeOpDocumentDescribeReportCreationOutput(&output, shape) 65 if err != nil { 66 var snapshot bytes.Buffer 67 io.Copy(&snapshot, ringBuffer) 68 err = &smithy.DeserializationError{ 69 Err: fmt.Errorf("failed to decode response body, %w", err), 70 Snapshot: snapshot.Bytes(), 71 } 72 return out, metadata, err 73 } 74 75 return out, metadata, err 76} 77 78func awsAwsjson11_deserializeOpErrorDescribeReportCreation(response *smithyhttp.Response, metadata *middleware.Metadata) error { 79 var errorBuffer bytes.Buffer 80 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 81 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 82 } 83 errorBody := bytes.NewReader(errorBuffer.Bytes()) 84 85 errorCode := "UnknownError" 86 errorMessage := errorCode 87 88 code := response.Header.Get("X-Amzn-ErrorType") 89 if len(code) != 0 { 90 errorCode = restjson.SanitizeErrorCode(code) 91 } 92 93 var buff [1024]byte 94 ringBuffer := smithyio.NewRingBuffer(buff[:]) 95 96 body := io.TeeReader(errorBody, ringBuffer) 97 decoder := json.NewDecoder(body) 98 decoder.UseNumber() 99 code, message, err := restjson.GetErrorInfo(decoder) 100 if err != nil { 101 var snapshot bytes.Buffer 102 io.Copy(&snapshot, ringBuffer) 103 err = &smithy.DeserializationError{ 104 Err: fmt.Errorf("failed to decode response body, %w", err), 105 Snapshot: snapshot.Bytes(), 106 } 107 return err 108 } 109 110 errorBody.Seek(0, io.SeekStart) 111 if len(code) != 0 { 112 errorCode = restjson.SanitizeErrorCode(code) 113 } 114 if len(message) != 0 { 115 errorMessage = message 116 } 117 118 switch { 119 case strings.EqualFold("ConstraintViolationException", errorCode): 120 return awsAwsjson11_deserializeErrorConstraintViolationException(response, errorBody) 121 122 case strings.EqualFold("InternalServiceException", errorCode): 123 return awsAwsjson11_deserializeErrorInternalServiceException(response, errorBody) 124 125 case strings.EqualFold("InvalidParameterException", errorCode): 126 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 127 128 case strings.EqualFold("ThrottledException", errorCode): 129 return awsAwsjson11_deserializeErrorThrottledException(response, errorBody) 130 131 default: 132 genericError := &smithy.GenericAPIError{ 133 Code: errorCode, 134 Message: errorMessage, 135 } 136 return genericError 137 138 } 139} 140 141type awsAwsjson11_deserializeOpGetComplianceSummary struct { 142} 143 144func (*awsAwsjson11_deserializeOpGetComplianceSummary) ID() string { 145 return "OperationDeserializer" 146} 147 148func (m *awsAwsjson11_deserializeOpGetComplianceSummary) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 149 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 150) { 151 out, metadata, err = next.HandleDeserialize(ctx, in) 152 if err != nil { 153 return out, metadata, err 154 } 155 156 response, ok := out.RawResponse.(*smithyhttp.Response) 157 if !ok { 158 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 159 } 160 161 if response.StatusCode < 200 || response.StatusCode >= 300 { 162 return out, metadata, awsAwsjson11_deserializeOpErrorGetComplianceSummary(response, &metadata) 163 } 164 output := &GetComplianceSummaryOutput{} 165 out.Result = output 166 167 var buff [1024]byte 168 ringBuffer := smithyio.NewRingBuffer(buff[:]) 169 170 body := io.TeeReader(response.Body, ringBuffer) 171 decoder := json.NewDecoder(body) 172 decoder.UseNumber() 173 var shape interface{} 174 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 175 var snapshot bytes.Buffer 176 io.Copy(&snapshot, ringBuffer) 177 err = &smithy.DeserializationError{ 178 Err: fmt.Errorf("failed to decode response body, %w", err), 179 Snapshot: snapshot.Bytes(), 180 } 181 return out, metadata, err 182 } 183 184 err = awsAwsjson11_deserializeOpDocumentGetComplianceSummaryOutput(&output, shape) 185 if err != nil { 186 var snapshot bytes.Buffer 187 io.Copy(&snapshot, ringBuffer) 188 err = &smithy.DeserializationError{ 189 Err: fmt.Errorf("failed to decode response body, %w", err), 190 Snapshot: snapshot.Bytes(), 191 } 192 return out, metadata, err 193 } 194 195 return out, metadata, err 196} 197 198func awsAwsjson11_deserializeOpErrorGetComplianceSummary(response *smithyhttp.Response, metadata *middleware.Metadata) error { 199 var errorBuffer bytes.Buffer 200 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 201 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 202 } 203 errorBody := bytes.NewReader(errorBuffer.Bytes()) 204 205 errorCode := "UnknownError" 206 errorMessage := errorCode 207 208 code := response.Header.Get("X-Amzn-ErrorType") 209 if len(code) != 0 { 210 errorCode = restjson.SanitizeErrorCode(code) 211 } 212 213 var buff [1024]byte 214 ringBuffer := smithyio.NewRingBuffer(buff[:]) 215 216 body := io.TeeReader(errorBody, ringBuffer) 217 decoder := json.NewDecoder(body) 218 decoder.UseNumber() 219 code, message, err := restjson.GetErrorInfo(decoder) 220 if err != nil { 221 var snapshot bytes.Buffer 222 io.Copy(&snapshot, ringBuffer) 223 err = &smithy.DeserializationError{ 224 Err: fmt.Errorf("failed to decode response body, %w", err), 225 Snapshot: snapshot.Bytes(), 226 } 227 return err 228 } 229 230 errorBody.Seek(0, io.SeekStart) 231 if len(code) != 0 { 232 errorCode = restjson.SanitizeErrorCode(code) 233 } 234 if len(message) != 0 { 235 errorMessage = message 236 } 237 238 switch { 239 case strings.EqualFold("ConstraintViolationException", errorCode): 240 return awsAwsjson11_deserializeErrorConstraintViolationException(response, errorBody) 241 242 case strings.EqualFold("InternalServiceException", errorCode): 243 return awsAwsjson11_deserializeErrorInternalServiceException(response, errorBody) 244 245 case strings.EqualFold("InvalidParameterException", errorCode): 246 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 247 248 case strings.EqualFold("ThrottledException", errorCode): 249 return awsAwsjson11_deserializeErrorThrottledException(response, errorBody) 250 251 default: 252 genericError := &smithy.GenericAPIError{ 253 Code: errorCode, 254 Message: errorMessage, 255 } 256 return genericError 257 258 } 259} 260 261type awsAwsjson11_deserializeOpGetResources struct { 262} 263 264func (*awsAwsjson11_deserializeOpGetResources) ID() string { 265 return "OperationDeserializer" 266} 267 268func (m *awsAwsjson11_deserializeOpGetResources) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 269 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 270) { 271 out, metadata, err = next.HandleDeserialize(ctx, in) 272 if err != nil { 273 return out, metadata, err 274 } 275 276 response, ok := out.RawResponse.(*smithyhttp.Response) 277 if !ok { 278 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 279 } 280 281 if response.StatusCode < 200 || response.StatusCode >= 300 { 282 return out, metadata, awsAwsjson11_deserializeOpErrorGetResources(response, &metadata) 283 } 284 output := &GetResourcesOutput{} 285 out.Result = output 286 287 var buff [1024]byte 288 ringBuffer := smithyio.NewRingBuffer(buff[:]) 289 290 body := io.TeeReader(response.Body, ringBuffer) 291 decoder := json.NewDecoder(body) 292 decoder.UseNumber() 293 var shape interface{} 294 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 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 err = awsAwsjson11_deserializeOpDocumentGetResourcesOutput(&output, shape) 305 if err != nil { 306 var snapshot bytes.Buffer 307 io.Copy(&snapshot, ringBuffer) 308 err = &smithy.DeserializationError{ 309 Err: fmt.Errorf("failed to decode response body, %w", err), 310 Snapshot: snapshot.Bytes(), 311 } 312 return out, metadata, err 313 } 314 315 return out, metadata, err 316} 317 318func awsAwsjson11_deserializeOpErrorGetResources(response *smithyhttp.Response, metadata *middleware.Metadata) error { 319 var errorBuffer bytes.Buffer 320 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 321 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 322 } 323 errorBody := bytes.NewReader(errorBuffer.Bytes()) 324 325 errorCode := "UnknownError" 326 errorMessage := errorCode 327 328 code := response.Header.Get("X-Amzn-ErrorType") 329 if len(code) != 0 { 330 errorCode = restjson.SanitizeErrorCode(code) 331 } 332 333 var buff [1024]byte 334 ringBuffer := smithyio.NewRingBuffer(buff[:]) 335 336 body := io.TeeReader(errorBody, ringBuffer) 337 decoder := json.NewDecoder(body) 338 decoder.UseNumber() 339 code, message, err := restjson.GetErrorInfo(decoder) 340 if err != nil { 341 var snapshot bytes.Buffer 342 io.Copy(&snapshot, ringBuffer) 343 err = &smithy.DeserializationError{ 344 Err: fmt.Errorf("failed to decode response body, %w", err), 345 Snapshot: snapshot.Bytes(), 346 } 347 return err 348 } 349 350 errorBody.Seek(0, io.SeekStart) 351 if len(code) != 0 { 352 errorCode = restjson.SanitizeErrorCode(code) 353 } 354 if len(message) != 0 { 355 errorMessage = message 356 } 357 358 switch { 359 case strings.EqualFold("InternalServiceException", errorCode): 360 return awsAwsjson11_deserializeErrorInternalServiceException(response, errorBody) 361 362 case strings.EqualFold("InvalidParameterException", errorCode): 363 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 364 365 case strings.EqualFold("PaginationTokenExpiredException", errorCode): 366 return awsAwsjson11_deserializeErrorPaginationTokenExpiredException(response, errorBody) 367 368 case strings.EqualFold("ThrottledException", errorCode): 369 return awsAwsjson11_deserializeErrorThrottledException(response, errorBody) 370 371 default: 372 genericError := &smithy.GenericAPIError{ 373 Code: errorCode, 374 Message: errorMessage, 375 } 376 return genericError 377 378 } 379} 380 381type awsAwsjson11_deserializeOpGetTagKeys struct { 382} 383 384func (*awsAwsjson11_deserializeOpGetTagKeys) ID() string { 385 return "OperationDeserializer" 386} 387 388func (m *awsAwsjson11_deserializeOpGetTagKeys) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 389 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 390) { 391 out, metadata, err = next.HandleDeserialize(ctx, in) 392 if err != nil { 393 return out, metadata, err 394 } 395 396 response, ok := out.RawResponse.(*smithyhttp.Response) 397 if !ok { 398 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 399 } 400 401 if response.StatusCode < 200 || response.StatusCode >= 300 { 402 return out, metadata, awsAwsjson11_deserializeOpErrorGetTagKeys(response, &metadata) 403 } 404 output := &GetTagKeysOutput{} 405 out.Result = output 406 407 var buff [1024]byte 408 ringBuffer := smithyio.NewRingBuffer(buff[:]) 409 410 body := io.TeeReader(response.Body, ringBuffer) 411 decoder := json.NewDecoder(body) 412 decoder.UseNumber() 413 var shape interface{} 414 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 415 var snapshot bytes.Buffer 416 io.Copy(&snapshot, ringBuffer) 417 err = &smithy.DeserializationError{ 418 Err: fmt.Errorf("failed to decode response body, %w", err), 419 Snapshot: snapshot.Bytes(), 420 } 421 return out, metadata, err 422 } 423 424 err = awsAwsjson11_deserializeOpDocumentGetTagKeysOutput(&output, shape) 425 if err != nil { 426 var snapshot bytes.Buffer 427 io.Copy(&snapshot, ringBuffer) 428 err = &smithy.DeserializationError{ 429 Err: fmt.Errorf("failed to decode response body, %w", err), 430 Snapshot: snapshot.Bytes(), 431 } 432 return out, metadata, err 433 } 434 435 return out, metadata, err 436} 437 438func awsAwsjson11_deserializeOpErrorGetTagKeys(response *smithyhttp.Response, metadata *middleware.Metadata) error { 439 var errorBuffer bytes.Buffer 440 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 441 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 442 } 443 errorBody := bytes.NewReader(errorBuffer.Bytes()) 444 445 errorCode := "UnknownError" 446 errorMessage := errorCode 447 448 code := response.Header.Get("X-Amzn-ErrorType") 449 if len(code) != 0 { 450 errorCode = restjson.SanitizeErrorCode(code) 451 } 452 453 var buff [1024]byte 454 ringBuffer := smithyio.NewRingBuffer(buff[:]) 455 456 body := io.TeeReader(errorBody, ringBuffer) 457 decoder := json.NewDecoder(body) 458 decoder.UseNumber() 459 code, message, err := restjson.GetErrorInfo(decoder) 460 if err != nil { 461 var snapshot bytes.Buffer 462 io.Copy(&snapshot, ringBuffer) 463 err = &smithy.DeserializationError{ 464 Err: fmt.Errorf("failed to decode response body, %w", err), 465 Snapshot: snapshot.Bytes(), 466 } 467 return err 468 } 469 470 errorBody.Seek(0, io.SeekStart) 471 if len(code) != 0 { 472 errorCode = restjson.SanitizeErrorCode(code) 473 } 474 if len(message) != 0 { 475 errorMessage = message 476 } 477 478 switch { 479 case strings.EqualFold("InternalServiceException", errorCode): 480 return awsAwsjson11_deserializeErrorInternalServiceException(response, errorBody) 481 482 case strings.EqualFold("InvalidParameterException", errorCode): 483 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 484 485 case strings.EqualFold("PaginationTokenExpiredException", errorCode): 486 return awsAwsjson11_deserializeErrorPaginationTokenExpiredException(response, errorBody) 487 488 case strings.EqualFold("ThrottledException", errorCode): 489 return awsAwsjson11_deserializeErrorThrottledException(response, errorBody) 490 491 default: 492 genericError := &smithy.GenericAPIError{ 493 Code: errorCode, 494 Message: errorMessage, 495 } 496 return genericError 497 498 } 499} 500 501type awsAwsjson11_deserializeOpGetTagValues struct { 502} 503 504func (*awsAwsjson11_deserializeOpGetTagValues) ID() string { 505 return "OperationDeserializer" 506} 507 508func (m *awsAwsjson11_deserializeOpGetTagValues) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 509 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 510) { 511 out, metadata, err = next.HandleDeserialize(ctx, in) 512 if err != nil { 513 return out, metadata, err 514 } 515 516 response, ok := out.RawResponse.(*smithyhttp.Response) 517 if !ok { 518 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 519 } 520 521 if response.StatusCode < 200 || response.StatusCode >= 300 { 522 return out, metadata, awsAwsjson11_deserializeOpErrorGetTagValues(response, &metadata) 523 } 524 output := &GetTagValuesOutput{} 525 out.Result = output 526 527 var buff [1024]byte 528 ringBuffer := smithyio.NewRingBuffer(buff[:]) 529 530 body := io.TeeReader(response.Body, ringBuffer) 531 decoder := json.NewDecoder(body) 532 decoder.UseNumber() 533 var shape interface{} 534 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 535 var snapshot bytes.Buffer 536 io.Copy(&snapshot, ringBuffer) 537 err = &smithy.DeserializationError{ 538 Err: fmt.Errorf("failed to decode response body, %w", err), 539 Snapshot: snapshot.Bytes(), 540 } 541 return out, metadata, err 542 } 543 544 err = awsAwsjson11_deserializeOpDocumentGetTagValuesOutput(&output, shape) 545 if err != nil { 546 var snapshot bytes.Buffer 547 io.Copy(&snapshot, ringBuffer) 548 err = &smithy.DeserializationError{ 549 Err: fmt.Errorf("failed to decode response body, %w", err), 550 Snapshot: snapshot.Bytes(), 551 } 552 return out, metadata, err 553 } 554 555 return out, metadata, err 556} 557 558func awsAwsjson11_deserializeOpErrorGetTagValues(response *smithyhttp.Response, metadata *middleware.Metadata) error { 559 var errorBuffer bytes.Buffer 560 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 561 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 562 } 563 errorBody := bytes.NewReader(errorBuffer.Bytes()) 564 565 errorCode := "UnknownError" 566 errorMessage := errorCode 567 568 code := response.Header.Get("X-Amzn-ErrorType") 569 if len(code) != 0 { 570 errorCode = restjson.SanitizeErrorCode(code) 571 } 572 573 var buff [1024]byte 574 ringBuffer := smithyio.NewRingBuffer(buff[:]) 575 576 body := io.TeeReader(errorBody, ringBuffer) 577 decoder := json.NewDecoder(body) 578 decoder.UseNumber() 579 code, message, err := restjson.GetErrorInfo(decoder) 580 if err != nil { 581 var snapshot bytes.Buffer 582 io.Copy(&snapshot, ringBuffer) 583 err = &smithy.DeserializationError{ 584 Err: fmt.Errorf("failed to decode response body, %w", err), 585 Snapshot: snapshot.Bytes(), 586 } 587 return err 588 } 589 590 errorBody.Seek(0, io.SeekStart) 591 if len(code) != 0 { 592 errorCode = restjson.SanitizeErrorCode(code) 593 } 594 if len(message) != 0 { 595 errorMessage = message 596 } 597 598 switch { 599 case strings.EqualFold("InternalServiceException", errorCode): 600 return awsAwsjson11_deserializeErrorInternalServiceException(response, errorBody) 601 602 case strings.EqualFold("InvalidParameterException", errorCode): 603 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 604 605 case strings.EqualFold("PaginationTokenExpiredException", errorCode): 606 return awsAwsjson11_deserializeErrorPaginationTokenExpiredException(response, errorBody) 607 608 case strings.EqualFold("ThrottledException", errorCode): 609 return awsAwsjson11_deserializeErrorThrottledException(response, errorBody) 610 611 default: 612 genericError := &smithy.GenericAPIError{ 613 Code: errorCode, 614 Message: errorMessage, 615 } 616 return genericError 617 618 } 619} 620 621type awsAwsjson11_deserializeOpStartReportCreation struct { 622} 623 624func (*awsAwsjson11_deserializeOpStartReportCreation) ID() string { 625 return "OperationDeserializer" 626} 627 628func (m *awsAwsjson11_deserializeOpStartReportCreation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 629 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 630) { 631 out, metadata, err = next.HandleDeserialize(ctx, in) 632 if err != nil { 633 return out, metadata, err 634 } 635 636 response, ok := out.RawResponse.(*smithyhttp.Response) 637 if !ok { 638 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 639 } 640 641 if response.StatusCode < 200 || response.StatusCode >= 300 { 642 return out, metadata, awsAwsjson11_deserializeOpErrorStartReportCreation(response, &metadata) 643 } 644 output := &StartReportCreationOutput{} 645 out.Result = output 646 647 var buff [1024]byte 648 ringBuffer := smithyio.NewRingBuffer(buff[:]) 649 650 body := io.TeeReader(response.Body, ringBuffer) 651 decoder := json.NewDecoder(body) 652 decoder.UseNumber() 653 var shape interface{} 654 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 655 var snapshot bytes.Buffer 656 io.Copy(&snapshot, ringBuffer) 657 err = &smithy.DeserializationError{ 658 Err: fmt.Errorf("failed to decode response body, %w", err), 659 Snapshot: snapshot.Bytes(), 660 } 661 return out, metadata, err 662 } 663 664 err = awsAwsjson11_deserializeOpDocumentStartReportCreationOutput(&output, shape) 665 if err != nil { 666 var snapshot bytes.Buffer 667 io.Copy(&snapshot, ringBuffer) 668 err = &smithy.DeserializationError{ 669 Err: fmt.Errorf("failed to decode response body, %w", err), 670 Snapshot: snapshot.Bytes(), 671 } 672 return out, metadata, err 673 } 674 675 return out, metadata, err 676} 677 678func awsAwsjson11_deserializeOpErrorStartReportCreation(response *smithyhttp.Response, metadata *middleware.Metadata) error { 679 var errorBuffer bytes.Buffer 680 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 681 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 682 } 683 errorBody := bytes.NewReader(errorBuffer.Bytes()) 684 685 errorCode := "UnknownError" 686 errorMessage := errorCode 687 688 code := response.Header.Get("X-Amzn-ErrorType") 689 if len(code) != 0 { 690 errorCode = restjson.SanitizeErrorCode(code) 691 } 692 693 var buff [1024]byte 694 ringBuffer := smithyio.NewRingBuffer(buff[:]) 695 696 body := io.TeeReader(errorBody, ringBuffer) 697 decoder := json.NewDecoder(body) 698 decoder.UseNumber() 699 code, message, err := restjson.GetErrorInfo(decoder) 700 if err != nil { 701 var snapshot bytes.Buffer 702 io.Copy(&snapshot, ringBuffer) 703 err = &smithy.DeserializationError{ 704 Err: fmt.Errorf("failed to decode response body, %w", err), 705 Snapshot: snapshot.Bytes(), 706 } 707 return err 708 } 709 710 errorBody.Seek(0, io.SeekStart) 711 if len(code) != 0 { 712 errorCode = restjson.SanitizeErrorCode(code) 713 } 714 if len(message) != 0 { 715 errorMessage = message 716 } 717 718 switch { 719 case strings.EqualFold("ConcurrentModificationException", errorCode): 720 return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody) 721 722 case strings.EqualFold("ConstraintViolationException", errorCode): 723 return awsAwsjson11_deserializeErrorConstraintViolationException(response, errorBody) 724 725 case strings.EqualFold("InternalServiceException", errorCode): 726 return awsAwsjson11_deserializeErrorInternalServiceException(response, errorBody) 727 728 case strings.EqualFold("InvalidParameterException", errorCode): 729 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 730 731 case strings.EqualFold("ThrottledException", errorCode): 732 return awsAwsjson11_deserializeErrorThrottledException(response, errorBody) 733 734 default: 735 genericError := &smithy.GenericAPIError{ 736 Code: errorCode, 737 Message: errorMessage, 738 } 739 return genericError 740 741 } 742} 743 744type awsAwsjson11_deserializeOpTagResources struct { 745} 746 747func (*awsAwsjson11_deserializeOpTagResources) ID() string { 748 return "OperationDeserializer" 749} 750 751func (m *awsAwsjson11_deserializeOpTagResources) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 752 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 753) { 754 out, metadata, err = next.HandleDeserialize(ctx, in) 755 if err != nil { 756 return out, metadata, err 757 } 758 759 response, ok := out.RawResponse.(*smithyhttp.Response) 760 if !ok { 761 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 762 } 763 764 if response.StatusCode < 200 || response.StatusCode >= 300 { 765 return out, metadata, awsAwsjson11_deserializeOpErrorTagResources(response, &metadata) 766 } 767 output := &TagResourcesOutput{} 768 out.Result = output 769 770 var buff [1024]byte 771 ringBuffer := smithyio.NewRingBuffer(buff[:]) 772 773 body := io.TeeReader(response.Body, ringBuffer) 774 decoder := json.NewDecoder(body) 775 decoder.UseNumber() 776 var shape interface{} 777 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 778 var snapshot bytes.Buffer 779 io.Copy(&snapshot, ringBuffer) 780 err = &smithy.DeserializationError{ 781 Err: fmt.Errorf("failed to decode response body, %w", err), 782 Snapshot: snapshot.Bytes(), 783 } 784 return out, metadata, err 785 } 786 787 err = awsAwsjson11_deserializeOpDocumentTagResourcesOutput(&output, shape) 788 if err != nil { 789 var snapshot bytes.Buffer 790 io.Copy(&snapshot, ringBuffer) 791 err = &smithy.DeserializationError{ 792 Err: fmt.Errorf("failed to decode response body, %w", err), 793 Snapshot: snapshot.Bytes(), 794 } 795 return out, metadata, err 796 } 797 798 return out, metadata, err 799} 800 801func awsAwsjson11_deserializeOpErrorTagResources(response *smithyhttp.Response, metadata *middleware.Metadata) error { 802 var errorBuffer bytes.Buffer 803 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 804 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 805 } 806 errorBody := bytes.NewReader(errorBuffer.Bytes()) 807 808 errorCode := "UnknownError" 809 errorMessage := errorCode 810 811 code := response.Header.Get("X-Amzn-ErrorType") 812 if len(code) != 0 { 813 errorCode = restjson.SanitizeErrorCode(code) 814 } 815 816 var buff [1024]byte 817 ringBuffer := smithyio.NewRingBuffer(buff[:]) 818 819 body := io.TeeReader(errorBody, ringBuffer) 820 decoder := json.NewDecoder(body) 821 decoder.UseNumber() 822 code, message, err := restjson.GetErrorInfo(decoder) 823 if err != nil { 824 var snapshot bytes.Buffer 825 io.Copy(&snapshot, ringBuffer) 826 err = &smithy.DeserializationError{ 827 Err: fmt.Errorf("failed to decode response body, %w", err), 828 Snapshot: snapshot.Bytes(), 829 } 830 return err 831 } 832 833 errorBody.Seek(0, io.SeekStart) 834 if len(code) != 0 { 835 errorCode = restjson.SanitizeErrorCode(code) 836 } 837 if len(message) != 0 { 838 errorMessage = message 839 } 840 841 switch { 842 case strings.EqualFold("InternalServiceException", errorCode): 843 return awsAwsjson11_deserializeErrorInternalServiceException(response, errorBody) 844 845 case strings.EqualFold("InvalidParameterException", errorCode): 846 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 847 848 case strings.EqualFold("ThrottledException", errorCode): 849 return awsAwsjson11_deserializeErrorThrottledException(response, errorBody) 850 851 default: 852 genericError := &smithy.GenericAPIError{ 853 Code: errorCode, 854 Message: errorMessage, 855 } 856 return genericError 857 858 } 859} 860 861type awsAwsjson11_deserializeOpUntagResources struct { 862} 863 864func (*awsAwsjson11_deserializeOpUntagResources) ID() string { 865 return "OperationDeserializer" 866} 867 868func (m *awsAwsjson11_deserializeOpUntagResources) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 869 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 870) { 871 out, metadata, err = next.HandleDeserialize(ctx, in) 872 if err != nil { 873 return out, metadata, err 874 } 875 876 response, ok := out.RawResponse.(*smithyhttp.Response) 877 if !ok { 878 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 879 } 880 881 if response.StatusCode < 200 || response.StatusCode >= 300 { 882 return out, metadata, awsAwsjson11_deserializeOpErrorUntagResources(response, &metadata) 883 } 884 output := &UntagResourcesOutput{} 885 out.Result = output 886 887 var buff [1024]byte 888 ringBuffer := smithyio.NewRingBuffer(buff[:]) 889 890 body := io.TeeReader(response.Body, ringBuffer) 891 decoder := json.NewDecoder(body) 892 decoder.UseNumber() 893 var shape interface{} 894 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 895 var snapshot bytes.Buffer 896 io.Copy(&snapshot, ringBuffer) 897 err = &smithy.DeserializationError{ 898 Err: fmt.Errorf("failed to decode response body, %w", err), 899 Snapshot: snapshot.Bytes(), 900 } 901 return out, metadata, err 902 } 903 904 err = awsAwsjson11_deserializeOpDocumentUntagResourcesOutput(&output, shape) 905 if err != nil { 906 var snapshot bytes.Buffer 907 io.Copy(&snapshot, ringBuffer) 908 err = &smithy.DeserializationError{ 909 Err: fmt.Errorf("failed to decode response body, %w", err), 910 Snapshot: snapshot.Bytes(), 911 } 912 return out, metadata, err 913 } 914 915 return out, metadata, err 916} 917 918func awsAwsjson11_deserializeOpErrorUntagResources(response *smithyhttp.Response, metadata *middleware.Metadata) error { 919 var errorBuffer bytes.Buffer 920 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 921 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 922 } 923 errorBody := bytes.NewReader(errorBuffer.Bytes()) 924 925 errorCode := "UnknownError" 926 errorMessage := errorCode 927 928 code := response.Header.Get("X-Amzn-ErrorType") 929 if len(code) != 0 { 930 errorCode = restjson.SanitizeErrorCode(code) 931 } 932 933 var buff [1024]byte 934 ringBuffer := smithyio.NewRingBuffer(buff[:]) 935 936 body := io.TeeReader(errorBody, ringBuffer) 937 decoder := json.NewDecoder(body) 938 decoder.UseNumber() 939 code, message, err := restjson.GetErrorInfo(decoder) 940 if err != nil { 941 var snapshot bytes.Buffer 942 io.Copy(&snapshot, ringBuffer) 943 err = &smithy.DeserializationError{ 944 Err: fmt.Errorf("failed to decode response body, %w", err), 945 Snapshot: snapshot.Bytes(), 946 } 947 return err 948 } 949 950 errorBody.Seek(0, io.SeekStart) 951 if len(code) != 0 { 952 errorCode = restjson.SanitizeErrorCode(code) 953 } 954 if len(message) != 0 { 955 errorMessage = message 956 } 957 958 switch { 959 case strings.EqualFold("InternalServiceException", errorCode): 960 return awsAwsjson11_deserializeErrorInternalServiceException(response, errorBody) 961 962 case strings.EqualFold("InvalidParameterException", errorCode): 963 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 964 965 case strings.EqualFold("ThrottledException", errorCode): 966 return awsAwsjson11_deserializeErrorThrottledException(response, errorBody) 967 968 default: 969 genericError := &smithy.GenericAPIError{ 970 Code: errorCode, 971 Message: errorMessage, 972 } 973 return genericError 974 975 } 976} 977 978func awsAwsjson11_deserializeErrorConcurrentModificationException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 979 var buff [1024]byte 980 ringBuffer := smithyio.NewRingBuffer(buff[:]) 981 982 body := io.TeeReader(errorBody, ringBuffer) 983 decoder := json.NewDecoder(body) 984 decoder.UseNumber() 985 var shape interface{} 986 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 987 var snapshot bytes.Buffer 988 io.Copy(&snapshot, ringBuffer) 989 err = &smithy.DeserializationError{ 990 Err: fmt.Errorf("failed to decode response body, %w", err), 991 Snapshot: snapshot.Bytes(), 992 } 993 return err 994 } 995 996 output := &types.ConcurrentModificationException{} 997 err := awsAwsjson11_deserializeDocumentConcurrentModificationException(&output, shape) 998 999 if err != nil { 1000 var snapshot bytes.Buffer 1001 io.Copy(&snapshot, ringBuffer) 1002 err = &smithy.DeserializationError{ 1003 Err: fmt.Errorf("failed to decode response body, %w", err), 1004 Snapshot: snapshot.Bytes(), 1005 } 1006 return err 1007 } 1008 1009 errorBody.Seek(0, io.SeekStart) 1010 return output 1011} 1012 1013func awsAwsjson11_deserializeErrorConstraintViolationException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 1014 var buff [1024]byte 1015 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1016 1017 body := io.TeeReader(errorBody, ringBuffer) 1018 decoder := json.NewDecoder(body) 1019 decoder.UseNumber() 1020 var shape interface{} 1021 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1022 var snapshot bytes.Buffer 1023 io.Copy(&snapshot, ringBuffer) 1024 err = &smithy.DeserializationError{ 1025 Err: fmt.Errorf("failed to decode response body, %w", err), 1026 Snapshot: snapshot.Bytes(), 1027 } 1028 return err 1029 } 1030 1031 output := &types.ConstraintViolationException{} 1032 err := awsAwsjson11_deserializeDocumentConstraintViolationException(&output, shape) 1033 1034 if err != nil { 1035 var snapshot bytes.Buffer 1036 io.Copy(&snapshot, ringBuffer) 1037 err = &smithy.DeserializationError{ 1038 Err: fmt.Errorf("failed to decode response body, %w", err), 1039 Snapshot: snapshot.Bytes(), 1040 } 1041 return err 1042 } 1043 1044 errorBody.Seek(0, io.SeekStart) 1045 return output 1046} 1047 1048func awsAwsjson11_deserializeErrorInternalServiceException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 1049 var buff [1024]byte 1050 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1051 1052 body := io.TeeReader(errorBody, ringBuffer) 1053 decoder := json.NewDecoder(body) 1054 decoder.UseNumber() 1055 var shape interface{} 1056 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1057 var snapshot bytes.Buffer 1058 io.Copy(&snapshot, ringBuffer) 1059 err = &smithy.DeserializationError{ 1060 Err: fmt.Errorf("failed to decode response body, %w", err), 1061 Snapshot: snapshot.Bytes(), 1062 } 1063 return err 1064 } 1065 1066 output := &types.InternalServiceException{} 1067 err := awsAwsjson11_deserializeDocumentInternalServiceException(&output, shape) 1068 1069 if err != nil { 1070 var snapshot bytes.Buffer 1071 io.Copy(&snapshot, ringBuffer) 1072 err = &smithy.DeserializationError{ 1073 Err: fmt.Errorf("failed to decode response body, %w", err), 1074 Snapshot: snapshot.Bytes(), 1075 } 1076 return err 1077 } 1078 1079 errorBody.Seek(0, io.SeekStart) 1080 return output 1081} 1082 1083func awsAwsjson11_deserializeErrorInvalidParameterException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 1084 var buff [1024]byte 1085 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1086 1087 body := io.TeeReader(errorBody, ringBuffer) 1088 decoder := json.NewDecoder(body) 1089 decoder.UseNumber() 1090 var shape interface{} 1091 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1092 var snapshot bytes.Buffer 1093 io.Copy(&snapshot, ringBuffer) 1094 err = &smithy.DeserializationError{ 1095 Err: fmt.Errorf("failed to decode response body, %w", err), 1096 Snapshot: snapshot.Bytes(), 1097 } 1098 return err 1099 } 1100 1101 output := &types.InvalidParameterException{} 1102 err := awsAwsjson11_deserializeDocumentInvalidParameterException(&output, shape) 1103 1104 if err != nil { 1105 var snapshot bytes.Buffer 1106 io.Copy(&snapshot, ringBuffer) 1107 err = &smithy.DeserializationError{ 1108 Err: fmt.Errorf("failed to decode response body, %w", err), 1109 Snapshot: snapshot.Bytes(), 1110 } 1111 return err 1112 } 1113 1114 errorBody.Seek(0, io.SeekStart) 1115 return output 1116} 1117 1118func awsAwsjson11_deserializeErrorPaginationTokenExpiredException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 1119 var buff [1024]byte 1120 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1121 1122 body := io.TeeReader(errorBody, ringBuffer) 1123 decoder := json.NewDecoder(body) 1124 decoder.UseNumber() 1125 var shape interface{} 1126 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1127 var snapshot bytes.Buffer 1128 io.Copy(&snapshot, ringBuffer) 1129 err = &smithy.DeserializationError{ 1130 Err: fmt.Errorf("failed to decode response body, %w", err), 1131 Snapshot: snapshot.Bytes(), 1132 } 1133 return err 1134 } 1135 1136 output := &types.PaginationTokenExpiredException{} 1137 err := awsAwsjson11_deserializeDocumentPaginationTokenExpiredException(&output, shape) 1138 1139 if err != nil { 1140 var snapshot bytes.Buffer 1141 io.Copy(&snapshot, ringBuffer) 1142 err = &smithy.DeserializationError{ 1143 Err: fmt.Errorf("failed to decode response body, %w", err), 1144 Snapshot: snapshot.Bytes(), 1145 } 1146 return err 1147 } 1148 1149 errorBody.Seek(0, io.SeekStart) 1150 return output 1151} 1152 1153func awsAwsjson11_deserializeErrorThrottledException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 1154 var buff [1024]byte 1155 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1156 1157 body := io.TeeReader(errorBody, ringBuffer) 1158 decoder := json.NewDecoder(body) 1159 decoder.UseNumber() 1160 var shape interface{} 1161 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1162 var snapshot bytes.Buffer 1163 io.Copy(&snapshot, ringBuffer) 1164 err = &smithy.DeserializationError{ 1165 Err: fmt.Errorf("failed to decode response body, %w", err), 1166 Snapshot: snapshot.Bytes(), 1167 } 1168 return err 1169 } 1170 1171 output := &types.ThrottledException{} 1172 err := awsAwsjson11_deserializeDocumentThrottledException(&output, shape) 1173 1174 if err != nil { 1175 var snapshot bytes.Buffer 1176 io.Copy(&snapshot, ringBuffer) 1177 err = &smithy.DeserializationError{ 1178 Err: fmt.Errorf("failed to decode response body, %w", err), 1179 Snapshot: snapshot.Bytes(), 1180 } 1181 return err 1182 } 1183 1184 errorBody.Seek(0, io.SeekStart) 1185 return output 1186} 1187 1188func awsAwsjson11_deserializeDocumentComplianceDetails(v **types.ComplianceDetails, value interface{}) error { 1189 if v == nil { 1190 return fmt.Errorf("unexpected nil of type %T", v) 1191 } 1192 if value == nil { 1193 return nil 1194 } 1195 1196 shape, ok := value.(map[string]interface{}) 1197 if !ok { 1198 return fmt.Errorf("unexpected JSON type %v", value) 1199 } 1200 1201 var sv *types.ComplianceDetails 1202 if *v == nil { 1203 sv = &types.ComplianceDetails{} 1204 } else { 1205 sv = *v 1206 } 1207 1208 for key, value := range shape { 1209 switch key { 1210 case "ComplianceStatus": 1211 if value != nil { 1212 jtv, ok := value.(bool) 1213 if !ok { 1214 return fmt.Errorf("expected ComplianceStatus to be of type *bool, got %T instead", value) 1215 } 1216 sv.ComplianceStatus = ptr.Bool(jtv) 1217 } 1218 1219 case "KeysWithNoncompliantValues": 1220 if err := awsAwsjson11_deserializeDocumentTagKeyList(&sv.KeysWithNoncompliantValues, value); err != nil { 1221 return err 1222 } 1223 1224 case "NoncompliantKeys": 1225 if err := awsAwsjson11_deserializeDocumentTagKeyList(&sv.NoncompliantKeys, value); err != nil { 1226 return err 1227 } 1228 1229 default: 1230 _, _ = key, value 1231 1232 } 1233 } 1234 *v = sv 1235 return nil 1236} 1237 1238func awsAwsjson11_deserializeDocumentConcurrentModificationException(v **types.ConcurrentModificationException, value interface{}) error { 1239 if v == nil { 1240 return fmt.Errorf("unexpected nil of type %T", v) 1241 } 1242 if value == nil { 1243 return nil 1244 } 1245 1246 shape, ok := value.(map[string]interface{}) 1247 if !ok { 1248 return fmt.Errorf("unexpected JSON type %v", value) 1249 } 1250 1251 var sv *types.ConcurrentModificationException 1252 if *v == nil { 1253 sv = &types.ConcurrentModificationException{} 1254 } else { 1255 sv = *v 1256 } 1257 1258 for key, value := range shape { 1259 switch key { 1260 case "Message": 1261 if value != nil { 1262 jtv, ok := value.(string) 1263 if !ok { 1264 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 1265 } 1266 sv.Message = ptr.String(jtv) 1267 } 1268 1269 default: 1270 _, _ = key, value 1271 1272 } 1273 } 1274 *v = sv 1275 return nil 1276} 1277 1278func awsAwsjson11_deserializeDocumentConstraintViolationException(v **types.ConstraintViolationException, value interface{}) error { 1279 if v == nil { 1280 return fmt.Errorf("unexpected nil of type %T", v) 1281 } 1282 if value == nil { 1283 return nil 1284 } 1285 1286 shape, ok := value.(map[string]interface{}) 1287 if !ok { 1288 return fmt.Errorf("unexpected JSON type %v", value) 1289 } 1290 1291 var sv *types.ConstraintViolationException 1292 if *v == nil { 1293 sv = &types.ConstraintViolationException{} 1294 } else { 1295 sv = *v 1296 } 1297 1298 for key, value := range shape { 1299 switch key { 1300 case "Message": 1301 if value != nil { 1302 jtv, ok := value.(string) 1303 if !ok { 1304 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 1305 } 1306 sv.Message = ptr.String(jtv) 1307 } 1308 1309 default: 1310 _, _ = key, value 1311 1312 } 1313 } 1314 *v = sv 1315 return nil 1316} 1317 1318func awsAwsjson11_deserializeDocumentFailedResourcesMap(v *map[string]types.FailureInfo, value interface{}) error { 1319 if v == nil { 1320 return fmt.Errorf("unexpected nil of type %T", v) 1321 } 1322 if value == nil { 1323 return nil 1324 } 1325 1326 shape, ok := value.(map[string]interface{}) 1327 if !ok { 1328 return fmt.Errorf("unexpected JSON type %v", value) 1329 } 1330 1331 var mv map[string]types.FailureInfo 1332 if *v == nil { 1333 mv = map[string]types.FailureInfo{} 1334 } else { 1335 mv = *v 1336 } 1337 1338 for key, value := range shape { 1339 var parsedVal types.FailureInfo 1340 mapVar := parsedVal 1341 destAddr := &mapVar 1342 if err := awsAwsjson11_deserializeDocumentFailureInfo(&destAddr, value); err != nil { 1343 return err 1344 } 1345 parsedVal = *destAddr 1346 mv[key] = parsedVal 1347 1348 } 1349 *v = mv 1350 return nil 1351} 1352 1353func awsAwsjson11_deserializeDocumentFailureInfo(v **types.FailureInfo, value interface{}) error { 1354 if v == nil { 1355 return fmt.Errorf("unexpected nil of type %T", v) 1356 } 1357 if value == nil { 1358 return nil 1359 } 1360 1361 shape, ok := value.(map[string]interface{}) 1362 if !ok { 1363 return fmt.Errorf("unexpected JSON type %v", value) 1364 } 1365 1366 var sv *types.FailureInfo 1367 if *v == nil { 1368 sv = &types.FailureInfo{} 1369 } else { 1370 sv = *v 1371 } 1372 1373 for key, value := range shape { 1374 switch key { 1375 case "ErrorCode": 1376 if value != nil { 1377 jtv, ok := value.(string) 1378 if !ok { 1379 return fmt.Errorf("expected ErrorCode to be of type string, got %T instead", value) 1380 } 1381 sv.ErrorCode = types.ErrorCode(jtv) 1382 } 1383 1384 case "ErrorMessage": 1385 if value != nil { 1386 jtv, ok := value.(string) 1387 if !ok { 1388 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 1389 } 1390 sv.ErrorMessage = ptr.String(jtv) 1391 } 1392 1393 case "StatusCode": 1394 if value != nil { 1395 jtv, ok := value.(json.Number) 1396 if !ok { 1397 return fmt.Errorf("expected StatusCode to be json.Number, got %T instead", value) 1398 } 1399 i64, err := jtv.Int64() 1400 if err != nil { 1401 return err 1402 } 1403 sv.StatusCode = int32(i64) 1404 } 1405 1406 default: 1407 _, _ = key, value 1408 1409 } 1410 } 1411 *v = sv 1412 return nil 1413} 1414 1415func awsAwsjson11_deserializeDocumentInternalServiceException(v **types.InternalServiceException, value interface{}) error { 1416 if v == nil { 1417 return fmt.Errorf("unexpected nil of type %T", v) 1418 } 1419 if value == nil { 1420 return nil 1421 } 1422 1423 shape, ok := value.(map[string]interface{}) 1424 if !ok { 1425 return fmt.Errorf("unexpected JSON type %v", value) 1426 } 1427 1428 var sv *types.InternalServiceException 1429 if *v == nil { 1430 sv = &types.InternalServiceException{} 1431 } else { 1432 sv = *v 1433 } 1434 1435 for key, value := range shape { 1436 switch key { 1437 case "Message": 1438 if value != nil { 1439 jtv, ok := value.(string) 1440 if !ok { 1441 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 1442 } 1443 sv.Message = ptr.String(jtv) 1444 } 1445 1446 default: 1447 _, _ = key, value 1448 1449 } 1450 } 1451 *v = sv 1452 return nil 1453} 1454 1455func awsAwsjson11_deserializeDocumentInvalidParameterException(v **types.InvalidParameterException, value interface{}) error { 1456 if v == nil { 1457 return fmt.Errorf("unexpected nil of type %T", v) 1458 } 1459 if value == nil { 1460 return nil 1461 } 1462 1463 shape, ok := value.(map[string]interface{}) 1464 if !ok { 1465 return fmt.Errorf("unexpected JSON type %v", value) 1466 } 1467 1468 var sv *types.InvalidParameterException 1469 if *v == nil { 1470 sv = &types.InvalidParameterException{} 1471 } else { 1472 sv = *v 1473 } 1474 1475 for key, value := range shape { 1476 switch key { 1477 case "Message": 1478 if value != nil { 1479 jtv, ok := value.(string) 1480 if !ok { 1481 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 1482 } 1483 sv.Message = ptr.String(jtv) 1484 } 1485 1486 default: 1487 _, _ = key, value 1488 1489 } 1490 } 1491 *v = sv 1492 return nil 1493} 1494 1495func awsAwsjson11_deserializeDocumentPaginationTokenExpiredException(v **types.PaginationTokenExpiredException, value interface{}) error { 1496 if v == nil { 1497 return fmt.Errorf("unexpected nil of type %T", v) 1498 } 1499 if value == nil { 1500 return nil 1501 } 1502 1503 shape, ok := value.(map[string]interface{}) 1504 if !ok { 1505 return fmt.Errorf("unexpected JSON type %v", value) 1506 } 1507 1508 var sv *types.PaginationTokenExpiredException 1509 if *v == nil { 1510 sv = &types.PaginationTokenExpiredException{} 1511 } else { 1512 sv = *v 1513 } 1514 1515 for key, value := range shape { 1516 switch key { 1517 case "Message": 1518 if value != nil { 1519 jtv, ok := value.(string) 1520 if !ok { 1521 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 1522 } 1523 sv.Message = ptr.String(jtv) 1524 } 1525 1526 default: 1527 _, _ = key, value 1528 1529 } 1530 } 1531 *v = sv 1532 return nil 1533} 1534 1535func awsAwsjson11_deserializeDocumentResourceTagMapping(v **types.ResourceTagMapping, value interface{}) error { 1536 if v == nil { 1537 return fmt.Errorf("unexpected nil of type %T", v) 1538 } 1539 if value == nil { 1540 return nil 1541 } 1542 1543 shape, ok := value.(map[string]interface{}) 1544 if !ok { 1545 return fmt.Errorf("unexpected JSON type %v", value) 1546 } 1547 1548 var sv *types.ResourceTagMapping 1549 if *v == nil { 1550 sv = &types.ResourceTagMapping{} 1551 } else { 1552 sv = *v 1553 } 1554 1555 for key, value := range shape { 1556 switch key { 1557 case "ComplianceDetails": 1558 if err := awsAwsjson11_deserializeDocumentComplianceDetails(&sv.ComplianceDetails, value); err != nil { 1559 return err 1560 } 1561 1562 case "ResourceARN": 1563 if value != nil { 1564 jtv, ok := value.(string) 1565 if !ok { 1566 return fmt.Errorf("expected ResourceARN to be of type string, got %T instead", value) 1567 } 1568 sv.ResourceARN = ptr.String(jtv) 1569 } 1570 1571 case "Tags": 1572 if err := awsAwsjson11_deserializeDocumentTagList(&sv.Tags, value); err != nil { 1573 return err 1574 } 1575 1576 default: 1577 _, _ = key, value 1578 1579 } 1580 } 1581 *v = sv 1582 return nil 1583} 1584 1585func awsAwsjson11_deserializeDocumentResourceTagMappingList(v *[]types.ResourceTagMapping, value interface{}) error { 1586 if v == nil { 1587 return fmt.Errorf("unexpected nil of type %T", v) 1588 } 1589 if value == nil { 1590 return nil 1591 } 1592 1593 shape, ok := value.([]interface{}) 1594 if !ok { 1595 return fmt.Errorf("unexpected JSON type %v", value) 1596 } 1597 1598 var cv []types.ResourceTagMapping 1599 if *v == nil { 1600 cv = []types.ResourceTagMapping{} 1601 } else { 1602 cv = *v 1603 } 1604 1605 for _, value := range shape { 1606 var col types.ResourceTagMapping 1607 destAddr := &col 1608 if err := awsAwsjson11_deserializeDocumentResourceTagMapping(&destAddr, value); err != nil { 1609 return err 1610 } 1611 col = *destAddr 1612 cv = append(cv, col) 1613 1614 } 1615 *v = cv 1616 return nil 1617} 1618 1619func awsAwsjson11_deserializeDocumentSummary(v **types.Summary, value interface{}) error { 1620 if v == nil { 1621 return fmt.Errorf("unexpected nil of type %T", v) 1622 } 1623 if value == nil { 1624 return nil 1625 } 1626 1627 shape, ok := value.(map[string]interface{}) 1628 if !ok { 1629 return fmt.Errorf("unexpected JSON type %v", value) 1630 } 1631 1632 var sv *types.Summary 1633 if *v == nil { 1634 sv = &types.Summary{} 1635 } else { 1636 sv = *v 1637 } 1638 1639 for key, value := range shape { 1640 switch key { 1641 case "LastUpdated": 1642 if value != nil { 1643 jtv, ok := value.(string) 1644 if !ok { 1645 return fmt.Errorf("expected LastUpdated to be of type string, got %T instead", value) 1646 } 1647 sv.LastUpdated = ptr.String(jtv) 1648 } 1649 1650 case "NonCompliantResources": 1651 if value != nil { 1652 jtv, ok := value.(json.Number) 1653 if !ok { 1654 return fmt.Errorf("expected NonCompliantResources to be json.Number, got %T instead", value) 1655 } 1656 i64, err := jtv.Int64() 1657 if err != nil { 1658 return err 1659 } 1660 sv.NonCompliantResources = i64 1661 } 1662 1663 case "Region": 1664 if value != nil { 1665 jtv, ok := value.(string) 1666 if !ok { 1667 return fmt.Errorf("expected Region to be of type string, got %T instead", value) 1668 } 1669 sv.Region = ptr.String(jtv) 1670 } 1671 1672 case "ResourceType": 1673 if value != nil { 1674 jtv, ok := value.(string) 1675 if !ok { 1676 return fmt.Errorf("expected AmazonResourceType to be of type string, got %T instead", value) 1677 } 1678 sv.ResourceType = ptr.String(jtv) 1679 } 1680 1681 case "TargetId": 1682 if value != nil { 1683 jtv, ok := value.(string) 1684 if !ok { 1685 return fmt.Errorf("expected TargetId to be of type string, got %T instead", value) 1686 } 1687 sv.TargetId = ptr.String(jtv) 1688 } 1689 1690 case "TargetIdType": 1691 if value != nil { 1692 jtv, ok := value.(string) 1693 if !ok { 1694 return fmt.Errorf("expected TargetIdType to be of type string, got %T instead", value) 1695 } 1696 sv.TargetIdType = types.TargetIdType(jtv) 1697 } 1698 1699 default: 1700 _, _ = key, value 1701 1702 } 1703 } 1704 *v = sv 1705 return nil 1706} 1707 1708func awsAwsjson11_deserializeDocumentSummaryList(v *[]types.Summary, value interface{}) error { 1709 if v == nil { 1710 return fmt.Errorf("unexpected nil of type %T", v) 1711 } 1712 if value == nil { 1713 return nil 1714 } 1715 1716 shape, ok := value.([]interface{}) 1717 if !ok { 1718 return fmt.Errorf("unexpected JSON type %v", value) 1719 } 1720 1721 var cv []types.Summary 1722 if *v == nil { 1723 cv = []types.Summary{} 1724 } else { 1725 cv = *v 1726 } 1727 1728 for _, value := range shape { 1729 var col types.Summary 1730 destAddr := &col 1731 if err := awsAwsjson11_deserializeDocumentSummary(&destAddr, value); err != nil { 1732 return err 1733 } 1734 col = *destAddr 1735 cv = append(cv, col) 1736 1737 } 1738 *v = cv 1739 return nil 1740} 1741 1742func awsAwsjson11_deserializeDocumentTag(v **types.Tag, value interface{}) error { 1743 if v == nil { 1744 return fmt.Errorf("unexpected nil of type %T", v) 1745 } 1746 if value == nil { 1747 return nil 1748 } 1749 1750 shape, ok := value.(map[string]interface{}) 1751 if !ok { 1752 return fmt.Errorf("unexpected JSON type %v", value) 1753 } 1754 1755 var sv *types.Tag 1756 if *v == nil { 1757 sv = &types.Tag{} 1758 } else { 1759 sv = *v 1760 } 1761 1762 for key, value := range shape { 1763 switch key { 1764 case "Key": 1765 if value != nil { 1766 jtv, ok := value.(string) 1767 if !ok { 1768 return fmt.Errorf("expected TagKey to be of type string, got %T instead", value) 1769 } 1770 sv.Key = ptr.String(jtv) 1771 } 1772 1773 case "Value": 1774 if value != nil { 1775 jtv, ok := value.(string) 1776 if !ok { 1777 return fmt.Errorf("expected TagValue to be of type string, got %T instead", value) 1778 } 1779 sv.Value = ptr.String(jtv) 1780 } 1781 1782 default: 1783 _, _ = key, value 1784 1785 } 1786 } 1787 *v = sv 1788 return nil 1789} 1790 1791func awsAwsjson11_deserializeDocumentTagKeyList(v *[]string, value interface{}) error { 1792 if v == nil { 1793 return fmt.Errorf("unexpected nil of type %T", v) 1794 } 1795 if value == nil { 1796 return nil 1797 } 1798 1799 shape, ok := value.([]interface{}) 1800 if !ok { 1801 return fmt.Errorf("unexpected JSON type %v", value) 1802 } 1803 1804 var cv []string 1805 if *v == nil { 1806 cv = []string{} 1807 } else { 1808 cv = *v 1809 } 1810 1811 for _, value := range shape { 1812 var col string 1813 if value != nil { 1814 jtv, ok := value.(string) 1815 if !ok { 1816 return fmt.Errorf("expected TagKey to be of type string, got %T instead", value) 1817 } 1818 col = jtv 1819 } 1820 cv = append(cv, col) 1821 1822 } 1823 *v = cv 1824 return nil 1825} 1826 1827func awsAwsjson11_deserializeDocumentTagList(v *[]types.Tag, value interface{}) error { 1828 if v == nil { 1829 return fmt.Errorf("unexpected nil of type %T", v) 1830 } 1831 if value == nil { 1832 return nil 1833 } 1834 1835 shape, ok := value.([]interface{}) 1836 if !ok { 1837 return fmt.Errorf("unexpected JSON type %v", value) 1838 } 1839 1840 var cv []types.Tag 1841 if *v == nil { 1842 cv = []types.Tag{} 1843 } else { 1844 cv = *v 1845 } 1846 1847 for _, value := range shape { 1848 var col types.Tag 1849 destAddr := &col 1850 if err := awsAwsjson11_deserializeDocumentTag(&destAddr, value); err != nil { 1851 return err 1852 } 1853 col = *destAddr 1854 cv = append(cv, col) 1855 1856 } 1857 *v = cv 1858 return nil 1859} 1860 1861func awsAwsjson11_deserializeDocumentTagValuesOutputList(v *[]string, value interface{}) error { 1862 if v == nil { 1863 return fmt.Errorf("unexpected nil of type %T", v) 1864 } 1865 if value == nil { 1866 return nil 1867 } 1868 1869 shape, ok := value.([]interface{}) 1870 if !ok { 1871 return fmt.Errorf("unexpected JSON type %v", value) 1872 } 1873 1874 var cv []string 1875 if *v == nil { 1876 cv = []string{} 1877 } else { 1878 cv = *v 1879 } 1880 1881 for _, value := range shape { 1882 var col string 1883 if value != nil { 1884 jtv, ok := value.(string) 1885 if !ok { 1886 return fmt.Errorf("expected TagValue to be of type string, got %T instead", value) 1887 } 1888 col = jtv 1889 } 1890 cv = append(cv, col) 1891 1892 } 1893 *v = cv 1894 return nil 1895} 1896 1897func awsAwsjson11_deserializeDocumentThrottledException(v **types.ThrottledException, value interface{}) error { 1898 if v == nil { 1899 return fmt.Errorf("unexpected nil of type %T", v) 1900 } 1901 if value == nil { 1902 return nil 1903 } 1904 1905 shape, ok := value.(map[string]interface{}) 1906 if !ok { 1907 return fmt.Errorf("unexpected JSON type %v", value) 1908 } 1909 1910 var sv *types.ThrottledException 1911 if *v == nil { 1912 sv = &types.ThrottledException{} 1913 } else { 1914 sv = *v 1915 } 1916 1917 for key, value := range shape { 1918 switch key { 1919 case "Message": 1920 if value != nil { 1921 jtv, ok := value.(string) 1922 if !ok { 1923 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 1924 } 1925 sv.Message = ptr.String(jtv) 1926 } 1927 1928 default: 1929 _, _ = key, value 1930 1931 } 1932 } 1933 *v = sv 1934 return nil 1935} 1936 1937func awsAwsjson11_deserializeOpDocumentDescribeReportCreationOutput(v **DescribeReportCreationOutput, value interface{}) error { 1938 if v == nil { 1939 return fmt.Errorf("unexpected nil of type %T", v) 1940 } 1941 if value == nil { 1942 return nil 1943 } 1944 1945 shape, ok := value.(map[string]interface{}) 1946 if !ok { 1947 return fmt.Errorf("unexpected JSON type %v", value) 1948 } 1949 1950 var sv *DescribeReportCreationOutput 1951 if *v == nil { 1952 sv = &DescribeReportCreationOutput{} 1953 } else { 1954 sv = *v 1955 } 1956 1957 for key, value := range shape { 1958 switch key { 1959 case "ErrorMessage": 1960 if value != nil { 1961 jtv, ok := value.(string) 1962 if !ok { 1963 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 1964 } 1965 sv.ErrorMessage = ptr.String(jtv) 1966 } 1967 1968 case "S3Location": 1969 if value != nil { 1970 jtv, ok := value.(string) 1971 if !ok { 1972 return fmt.Errorf("expected S3Location to be of type string, got %T instead", value) 1973 } 1974 sv.S3Location = ptr.String(jtv) 1975 } 1976 1977 case "StartDate": 1978 if value != nil { 1979 jtv, ok := value.(string) 1980 if !ok { 1981 return fmt.Errorf("expected StartDate to be of type string, got %T instead", value) 1982 } 1983 sv.StartDate = ptr.String(jtv) 1984 } 1985 1986 case "Status": 1987 if value != nil { 1988 jtv, ok := value.(string) 1989 if !ok { 1990 return fmt.Errorf("expected Status to be of type string, got %T instead", value) 1991 } 1992 sv.Status = ptr.String(jtv) 1993 } 1994 1995 default: 1996 _, _ = key, value 1997 1998 } 1999 } 2000 *v = sv 2001 return nil 2002} 2003 2004func awsAwsjson11_deserializeOpDocumentGetComplianceSummaryOutput(v **GetComplianceSummaryOutput, value interface{}) error { 2005 if v == nil { 2006 return fmt.Errorf("unexpected nil of type %T", v) 2007 } 2008 if value == nil { 2009 return nil 2010 } 2011 2012 shape, ok := value.(map[string]interface{}) 2013 if !ok { 2014 return fmt.Errorf("unexpected JSON type %v", value) 2015 } 2016 2017 var sv *GetComplianceSummaryOutput 2018 if *v == nil { 2019 sv = &GetComplianceSummaryOutput{} 2020 } else { 2021 sv = *v 2022 } 2023 2024 for key, value := range shape { 2025 switch key { 2026 case "PaginationToken": 2027 if value != nil { 2028 jtv, ok := value.(string) 2029 if !ok { 2030 return fmt.Errorf("expected PaginationToken to be of type string, got %T instead", value) 2031 } 2032 sv.PaginationToken = ptr.String(jtv) 2033 } 2034 2035 case "SummaryList": 2036 if err := awsAwsjson11_deserializeDocumentSummaryList(&sv.SummaryList, value); err != nil { 2037 return err 2038 } 2039 2040 default: 2041 _, _ = key, value 2042 2043 } 2044 } 2045 *v = sv 2046 return nil 2047} 2048 2049func awsAwsjson11_deserializeOpDocumentGetResourcesOutput(v **GetResourcesOutput, value interface{}) error { 2050 if v == nil { 2051 return fmt.Errorf("unexpected nil of type %T", v) 2052 } 2053 if value == nil { 2054 return nil 2055 } 2056 2057 shape, ok := value.(map[string]interface{}) 2058 if !ok { 2059 return fmt.Errorf("unexpected JSON type %v", value) 2060 } 2061 2062 var sv *GetResourcesOutput 2063 if *v == nil { 2064 sv = &GetResourcesOutput{} 2065 } else { 2066 sv = *v 2067 } 2068 2069 for key, value := range shape { 2070 switch key { 2071 case "PaginationToken": 2072 if value != nil { 2073 jtv, ok := value.(string) 2074 if !ok { 2075 return fmt.Errorf("expected PaginationToken to be of type string, got %T instead", value) 2076 } 2077 sv.PaginationToken = ptr.String(jtv) 2078 } 2079 2080 case "ResourceTagMappingList": 2081 if err := awsAwsjson11_deserializeDocumentResourceTagMappingList(&sv.ResourceTagMappingList, value); err != nil { 2082 return err 2083 } 2084 2085 default: 2086 _, _ = key, value 2087 2088 } 2089 } 2090 *v = sv 2091 return nil 2092} 2093 2094func awsAwsjson11_deserializeOpDocumentGetTagKeysOutput(v **GetTagKeysOutput, value interface{}) error { 2095 if v == nil { 2096 return fmt.Errorf("unexpected nil of type %T", v) 2097 } 2098 if value == nil { 2099 return nil 2100 } 2101 2102 shape, ok := value.(map[string]interface{}) 2103 if !ok { 2104 return fmt.Errorf("unexpected JSON type %v", value) 2105 } 2106 2107 var sv *GetTagKeysOutput 2108 if *v == nil { 2109 sv = &GetTagKeysOutput{} 2110 } else { 2111 sv = *v 2112 } 2113 2114 for key, value := range shape { 2115 switch key { 2116 case "PaginationToken": 2117 if value != nil { 2118 jtv, ok := value.(string) 2119 if !ok { 2120 return fmt.Errorf("expected PaginationToken to be of type string, got %T instead", value) 2121 } 2122 sv.PaginationToken = ptr.String(jtv) 2123 } 2124 2125 case "TagKeys": 2126 if err := awsAwsjson11_deserializeDocumentTagKeyList(&sv.TagKeys, value); err != nil { 2127 return err 2128 } 2129 2130 default: 2131 _, _ = key, value 2132 2133 } 2134 } 2135 *v = sv 2136 return nil 2137} 2138 2139func awsAwsjson11_deserializeOpDocumentGetTagValuesOutput(v **GetTagValuesOutput, value interface{}) error { 2140 if v == nil { 2141 return fmt.Errorf("unexpected nil of type %T", v) 2142 } 2143 if value == nil { 2144 return nil 2145 } 2146 2147 shape, ok := value.(map[string]interface{}) 2148 if !ok { 2149 return fmt.Errorf("unexpected JSON type %v", value) 2150 } 2151 2152 var sv *GetTagValuesOutput 2153 if *v == nil { 2154 sv = &GetTagValuesOutput{} 2155 } else { 2156 sv = *v 2157 } 2158 2159 for key, value := range shape { 2160 switch key { 2161 case "PaginationToken": 2162 if value != nil { 2163 jtv, ok := value.(string) 2164 if !ok { 2165 return fmt.Errorf("expected PaginationToken to be of type string, got %T instead", value) 2166 } 2167 sv.PaginationToken = ptr.String(jtv) 2168 } 2169 2170 case "TagValues": 2171 if err := awsAwsjson11_deserializeDocumentTagValuesOutputList(&sv.TagValues, value); err != nil { 2172 return err 2173 } 2174 2175 default: 2176 _, _ = key, value 2177 2178 } 2179 } 2180 *v = sv 2181 return nil 2182} 2183 2184func awsAwsjson11_deserializeOpDocumentStartReportCreationOutput(v **StartReportCreationOutput, value interface{}) error { 2185 if v == nil { 2186 return fmt.Errorf("unexpected nil of type %T", v) 2187 } 2188 if value == nil { 2189 return nil 2190 } 2191 2192 shape, ok := value.(map[string]interface{}) 2193 if !ok { 2194 return fmt.Errorf("unexpected JSON type %v", value) 2195 } 2196 2197 var sv *StartReportCreationOutput 2198 if *v == nil { 2199 sv = &StartReportCreationOutput{} 2200 } else { 2201 sv = *v 2202 } 2203 2204 for key, value := range shape { 2205 switch key { 2206 default: 2207 _, _ = key, value 2208 2209 } 2210 } 2211 *v = sv 2212 return nil 2213} 2214 2215func awsAwsjson11_deserializeOpDocumentTagResourcesOutput(v **TagResourcesOutput, value interface{}) error { 2216 if v == nil { 2217 return fmt.Errorf("unexpected nil of type %T", v) 2218 } 2219 if value == nil { 2220 return nil 2221 } 2222 2223 shape, ok := value.(map[string]interface{}) 2224 if !ok { 2225 return fmt.Errorf("unexpected JSON type %v", value) 2226 } 2227 2228 var sv *TagResourcesOutput 2229 if *v == nil { 2230 sv = &TagResourcesOutput{} 2231 } else { 2232 sv = *v 2233 } 2234 2235 for key, value := range shape { 2236 switch key { 2237 case "FailedResourcesMap": 2238 if err := awsAwsjson11_deserializeDocumentFailedResourcesMap(&sv.FailedResourcesMap, value); err != nil { 2239 return err 2240 } 2241 2242 default: 2243 _, _ = key, value 2244 2245 } 2246 } 2247 *v = sv 2248 return nil 2249} 2250 2251func awsAwsjson11_deserializeOpDocumentUntagResourcesOutput(v **UntagResourcesOutput, value interface{}) error { 2252 if v == nil { 2253 return fmt.Errorf("unexpected nil of type %T", v) 2254 } 2255 if value == nil { 2256 return nil 2257 } 2258 2259 shape, ok := value.(map[string]interface{}) 2260 if !ok { 2261 return fmt.Errorf("unexpected JSON type %v", value) 2262 } 2263 2264 var sv *UntagResourcesOutput 2265 if *v == nil { 2266 sv = &UntagResourcesOutput{} 2267 } else { 2268 sv = *v 2269 } 2270 2271 for key, value := range shape { 2272 switch key { 2273 case "FailedResourcesMap": 2274 if err := awsAwsjson11_deserializeDocumentFailedResourcesMap(&sv.FailedResourcesMap, value); err != nil { 2275 return err 2276 } 2277 2278 default: 2279 _, _ = key, value 2280 2281 } 2282 } 2283 *v = sv 2284 return nil 2285} 2286