1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package applicationinsights 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/applicationinsights/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_deserializeOpCreateApplication struct { 23} 24 25func (*awsAwsjson11_deserializeOpCreateApplication) ID() string { 26 return "OperationDeserializer" 27} 28 29func (m *awsAwsjson11_deserializeOpCreateApplication) 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_deserializeOpErrorCreateApplication(response, &metadata) 44 } 45 output := &CreateApplicationOutput{} 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_deserializeOpDocumentCreateApplicationOutput(&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_deserializeOpErrorCreateApplication(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("AccessDeniedException", errorCode): 121 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 122 123 case strings.EqualFold("InternalServerException", errorCode): 124 return awsAwsjson11_deserializeErrorInternalServerException(response, errorBody) 125 126 case strings.EqualFold("ResourceInUseException", errorCode): 127 return awsAwsjson11_deserializeErrorResourceInUseException(response, errorBody) 128 129 case strings.EqualFold("ResourceNotFoundException", errorCode): 130 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 131 132 case strings.EqualFold("TagsAlreadyExistException", errorCode): 133 return awsAwsjson11_deserializeErrorTagsAlreadyExistException(response, errorBody) 134 135 case strings.EqualFold("ValidationException", errorCode): 136 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 137 138 default: 139 genericError := &smithy.GenericAPIError{ 140 Code: errorCode, 141 Message: errorMessage, 142 } 143 return genericError 144 145 } 146} 147 148type awsAwsjson11_deserializeOpCreateComponent struct { 149} 150 151func (*awsAwsjson11_deserializeOpCreateComponent) ID() string { 152 return "OperationDeserializer" 153} 154 155func (m *awsAwsjson11_deserializeOpCreateComponent) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 156 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 157) { 158 out, metadata, err = next.HandleDeserialize(ctx, in) 159 if err != nil { 160 return out, metadata, err 161 } 162 163 response, ok := out.RawResponse.(*smithyhttp.Response) 164 if !ok { 165 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 166 } 167 168 if response.StatusCode < 200 || response.StatusCode >= 300 { 169 return out, metadata, awsAwsjson11_deserializeOpErrorCreateComponent(response, &metadata) 170 } 171 output := &CreateComponentOutput{} 172 out.Result = output 173 174 var buff [1024]byte 175 ringBuffer := smithyio.NewRingBuffer(buff[:]) 176 177 body := io.TeeReader(response.Body, ringBuffer) 178 decoder := json.NewDecoder(body) 179 decoder.UseNumber() 180 var shape interface{} 181 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 182 var snapshot bytes.Buffer 183 io.Copy(&snapshot, ringBuffer) 184 err = &smithy.DeserializationError{ 185 Err: fmt.Errorf("failed to decode response body, %w", err), 186 Snapshot: snapshot.Bytes(), 187 } 188 return out, metadata, err 189 } 190 191 err = awsAwsjson11_deserializeOpDocumentCreateComponentOutput(&output, shape) 192 if err != nil { 193 var snapshot bytes.Buffer 194 io.Copy(&snapshot, ringBuffer) 195 err = &smithy.DeserializationError{ 196 Err: fmt.Errorf("failed to decode response body, %w", err), 197 Snapshot: snapshot.Bytes(), 198 } 199 return out, metadata, err 200 } 201 202 return out, metadata, err 203} 204 205func awsAwsjson11_deserializeOpErrorCreateComponent(response *smithyhttp.Response, metadata *middleware.Metadata) error { 206 var errorBuffer bytes.Buffer 207 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 208 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 209 } 210 errorBody := bytes.NewReader(errorBuffer.Bytes()) 211 212 errorCode := "UnknownError" 213 errorMessage := errorCode 214 215 code := response.Header.Get("X-Amzn-ErrorType") 216 if len(code) != 0 { 217 errorCode = restjson.SanitizeErrorCode(code) 218 } 219 220 var buff [1024]byte 221 ringBuffer := smithyio.NewRingBuffer(buff[:]) 222 223 body := io.TeeReader(errorBody, ringBuffer) 224 decoder := json.NewDecoder(body) 225 decoder.UseNumber() 226 code, message, err := restjson.GetErrorInfo(decoder) 227 if err != nil { 228 var snapshot bytes.Buffer 229 io.Copy(&snapshot, ringBuffer) 230 err = &smithy.DeserializationError{ 231 Err: fmt.Errorf("failed to decode response body, %w", err), 232 Snapshot: snapshot.Bytes(), 233 } 234 return err 235 } 236 237 errorBody.Seek(0, io.SeekStart) 238 if len(code) != 0 { 239 errorCode = restjson.SanitizeErrorCode(code) 240 } 241 if len(message) != 0 { 242 errorMessage = message 243 } 244 245 switch { 246 case strings.EqualFold("InternalServerException", errorCode): 247 return awsAwsjson11_deserializeErrorInternalServerException(response, errorBody) 248 249 case strings.EqualFold("ResourceInUseException", errorCode): 250 return awsAwsjson11_deserializeErrorResourceInUseException(response, errorBody) 251 252 case strings.EqualFold("ResourceNotFoundException", errorCode): 253 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 254 255 case strings.EqualFold("ValidationException", errorCode): 256 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 257 258 default: 259 genericError := &smithy.GenericAPIError{ 260 Code: errorCode, 261 Message: errorMessage, 262 } 263 return genericError 264 265 } 266} 267 268type awsAwsjson11_deserializeOpCreateLogPattern struct { 269} 270 271func (*awsAwsjson11_deserializeOpCreateLogPattern) ID() string { 272 return "OperationDeserializer" 273} 274 275func (m *awsAwsjson11_deserializeOpCreateLogPattern) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 276 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 277) { 278 out, metadata, err = next.HandleDeserialize(ctx, in) 279 if err != nil { 280 return out, metadata, err 281 } 282 283 response, ok := out.RawResponse.(*smithyhttp.Response) 284 if !ok { 285 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 286 } 287 288 if response.StatusCode < 200 || response.StatusCode >= 300 { 289 return out, metadata, awsAwsjson11_deserializeOpErrorCreateLogPattern(response, &metadata) 290 } 291 output := &CreateLogPatternOutput{} 292 out.Result = output 293 294 var buff [1024]byte 295 ringBuffer := smithyio.NewRingBuffer(buff[:]) 296 297 body := io.TeeReader(response.Body, ringBuffer) 298 decoder := json.NewDecoder(body) 299 decoder.UseNumber() 300 var shape interface{} 301 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 302 var snapshot bytes.Buffer 303 io.Copy(&snapshot, ringBuffer) 304 err = &smithy.DeserializationError{ 305 Err: fmt.Errorf("failed to decode response body, %w", err), 306 Snapshot: snapshot.Bytes(), 307 } 308 return out, metadata, err 309 } 310 311 err = awsAwsjson11_deserializeOpDocumentCreateLogPatternOutput(&output, shape) 312 if err != nil { 313 var snapshot bytes.Buffer 314 io.Copy(&snapshot, ringBuffer) 315 err = &smithy.DeserializationError{ 316 Err: fmt.Errorf("failed to decode response body, %w", err), 317 Snapshot: snapshot.Bytes(), 318 } 319 return out, metadata, err 320 } 321 322 return out, metadata, err 323} 324 325func awsAwsjson11_deserializeOpErrorCreateLogPattern(response *smithyhttp.Response, metadata *middleware.Metadata) error { 326 var errorBuffer bytes.Buffer 327 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 328 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 329 } 330 errorBody := bytes.NewReader(errorBuffer.Bytes()) 331 332 errorCode := "UnknownError" 333 errorMessage := errorCode 334 335 code := response.Header.Get("X-Amzn-ErrorType") 336 if len(code) != 0 { 337 errorCode = restjson.SanitizeErrorCode(code) 338 } 339 340 var buff [1024]byte 341 ringBuffer := smithyio.NewRingBuffer(buff[:]) 342 343 body := io.TeeReader(errorBody, ringBuffer) 344 decoder := json.NewDecoder(body) 345 decoder.UseNumber() 346 code, message, err := restjson.GetErrorInfo(decoder) 347 if err != nil { 348 var snapshot bytes.Buffer 349 io.Copy(&snapshot, ringBuffer) 350 err = &smithy.DeserializationError{ 351 Err: fmt.Errorf("failed to decode response body, %w", err), 352 Snapshot: snapshot.Bytes(), 353 } 354 return err 355 } 356 357 errorBody.Seek(0, io.SeekStart) 358 if len(code) != 0 { 359 errorCode = restjson.SanitizeErrorCode(code) 360 } 361 if len(message) != 0 { 362 errorMessage = message 363 } 364 365 switch { 366 case strings.EqualFold("InternalServerException", errorCode): 367 return awsAwsjson11_deserializeErrorInternalServerException(response, errorBody) 368 369 case strings.EqualFold("ResourceInUseException", errorCode): 370 return awsAwsjson11_deserializeErrorResourceInUseException(response, errorBody) 371 372 case strings.EqualFold("ResourceNotFoundException", errorCode): 373 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 374 375 case strings.EqualFold("ValidationException", errorCode): 376 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 377 378 default: 379 genericError := &smithy.GenericAPIError{ 380 Code: errorCode, 381 Message: errorMessage, 382 } 383 return genericError 384 385 } 386} 387 388type awsAwsjson11_deserializeOpDeleteApplication struct { 389} 390 391func (*awsAwsjson11_deserializeOpDeleteApplication) ID() string { 392 return "OperationDeserializer" 393} 394 395func (m *awsAwsjson11_deserializeOpDeleteApplication) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 396 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 397) { 398 out, metadata, err = next.HandleDeserialize(ctx, in) 399 if err != nil { 400 return out, metadata, err 401 } 402 403 response, ok := out.RawResponse.(*smithyhttp.Response) 404 if !ok { 405 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 406 } 407 408 if response.StatusCode < 200 || response.StatusCode >= 300 { 409 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteApplication(response, &metadata) 410 } 411 output := &DeleteApplicationOutput{} 412 out.Result = output 413 414 var buff [1024]byte 415 ringBuffer := smithyio.NewRingBuffer(buff[:]) 416 417 body := io.TeeReader(response.Body, ringBuffer) 418 decoder := json.NewDecoder(body) 419 decoder.UseNumber() 420 var shape interface{} 421 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 422 var snapshot bytes.Buffer 423 io.Copy(&snapshot, ringBuffer) 424 err = &smithy.DeserializationError{ 425 Err: fmt.Errorf("failed to decode response body, %w", err), 426 Snapshot: snapshot.Bytes(), 427 } 428 return out, metadata, err 429 } 430 431 err = awsAwsjson11_deserializeOpDocumentDeleteApplicationOutput(&output, shape) 432 if err != nil { 433 var snapshot bytes.Buffer 434 io.Copy(&snapshot, ringBuffer) 435 err = &smithy.DeserializationError{ 436 Err: fmt.Errorf("failed to decode response body, %w", err), 437 Snapshot: snapshot.Bytes(), 438 } 439 return out, metadata, err 440 } 441 442 return out, metadata, err 443} 444 445func awsAwsjson11_deserializeOpErrorDeleteApplication(response *smithyhttp.Response, metadata *middleware.Metadata) error { 446 var errorBuffer bytes.Buffer 447 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 448 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 449 } 450 errorBody := bytes.NewReader(errorBuffer.Bytes()) 451 452 errorCode := "UnknownError" 453 errorMessage := errorCode 454 455 code := response.Header.Get("X-Amzn-ErrorType") 456 if len(code) != 0 { 457 errorCode = restjson.SanitizeErrorCode(code) 458 } 459 460 var buff [1024]byte 461 ringBuffer := smithyio.NewRingBuffer(buff[:]) 462 463 body := io.TeeReader(errorBody, ringBuffer) 464 decoder := json.NewDecoder(body) 465 decoder.UseNumber() 466 code, message, err := restjson.GetErrorInfo(decoder) 467 if err != nil { 468 var snapshot bytes.Buffer 469 io.Copy(&snapshot, ringBuffer) 470 err = &smithy.DeserializationError{ 471 Err: fmt.Errorf("failed to decode response body, %w", err), 472 Snapshot: snapshot.Bytes(), 473 } 474 return err 475 } 476 477 errorBody.Seek(0, io.SeekStart) 478 if len(code) != 0 { 479 errorCode = restjson.SanitizeErrorCode(code) 480 } 481 if len(message) != 0 { 482 errorMessage = message 483 } 484 485 switch { 486 case strings.EqualFold("BadRequestException", errorCode): 487 return awsAwsjson11_deserializeErrorBadRequestException(response, errorBody) 488 489 case strings.EqualFold("InternalServerException", errorCode): 490 return awsAwsjson11_deserializeErrorInternalServerException(response, errorBody) 491 492 case strings.EqualFold("ResourceNotFoundException", errorCode): 493 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 494 495 case strings.EqualFold("ValidationException", errorCode): 496 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 497 498 default: 499 genericError := &smithy.GenericAPIError{ 500 Code: errorCode, 501 Message: errorMessage, 502 } 503 return genericError 504 505 } 506} 507 508type awsAwsjson11_deserializeOpDeleteComponent struct { 509} 510 511func (*awsAwsjson11_deserializeOpDeleteComponent) ID() string { 512 return "OperationDeserializer" 513} 514 515func (m *awsAwsjson11_deserializeOpDeleteComponent) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 516 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 517) { 518 out, metadata, err = next.HandleDeserialize(ctx, in) 519 if err != nil { 520 return out, metadata, err 521 } 522 523 response, ok := out.RawResponse.(*smithyhttp.Response) 524 if !ok { 525 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 526 } 527 528 if response.StatusCode < 200 || response.StatusCode >= 300 { 529 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteComponent(response, &metadata) 530 } 531 output := &DeleteComponentOutput{} 532 out.Result = output 533 534 var buff [1024]byte 535 ringBuffer := smithyio.NewRingBuffer(buff[:]) 536 537 body := io.TeeReader(response.Body, ringBuffer) 538 decoder := json.NewDecoder(body) 539 decoder.UseNumber() 540 var shape interface{} 541 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 542 var snapshot bytes.Buffer 543 io.Copy(&snapshot, ringBuffer) 544 err = &smithy.DeserializationError{ 545 Err: fmt.Errorf("failed to decode response body, %w", err), 546 Snapshot: snapshot.Bytes(), 547 } 548 return out, metadata, err 549 } 550 551 err = awsAwsjson11_deserializeOpDocumentDeleteComponentOutput(&output, shape) 552 if err != nil { 553 var snapshot bytes.Buffer 554 io.Copy(&snapshot, ringBuffer) 555 err = &smithy.DeserializationError{ 556 Err: fmt.Errorf("failed to decode response body, %w", err), 557 Snapshot: snapshot.Bytes(), 558 } 559 return out, metadata, err 560 } 561 562 return out, metadata, err 563} 564 565func awsAwsjson11_deserializeOpErrorDeleteComponent(response *smithyhttp.Response, metadata *middleware.Metadata) error { 566 var errorBuffer bytes.Buffer 567 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 568 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 569 } 570 errorBody := bytes.NewReader(errorBuffer.Bytes()) 571 572 errorCode := "UnknownError" 573 errorMessage := errorCode 574 575 code := response.Header.Get("X-Amzn-ErrorType") 576 if len(code) != 0 { 577 errorCode = restjson.SanitizeErrorCode(code) 578 } 579 580 var buff [1024]byte 581 ringBuffer := smithyio.NewRingBuffer(buff[:]) 582 583 body := io.TeeReader(errorBody, ringBuffer) 584 decoder := json.NewDecoder(body) 585 decoder.UseNumber() 586 code, message, err := restjson.GetErrorInfo(decoder) 587 if err != nil { 588 var snapshot bytes.Buffer 589 io.Copy(&snapshot, ringBuffer) 590 err = &smithy.DeserializationError{ 591 Err: fmt.Errorf("failed to decode response body, %w", err), 592 Snapshot: snapshot.Bytes(), 593 } 594 return err 595 } 596 597 errorBody.Seek(0, io.SeekStart) 598 if len(code) != 0 { 599 errorCode = restjson.SanitizeErrorCode(code) 600 } 601 if len(message) != 0 { 602 errorMessage = message 603 } 604 605 switch { 606 case strings.EqualFold("InternalServerException", errorCode): 607 return awsAwsjson11_deserializeErrorInternalServerException(response, errorBody) 608 609 case strings.EqualFold("ResourceNotFoundException", errorCode): 610 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 611 612 case strings.EqualFold("ValidationException", errorCode): 613 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 614 615 default: 616 genericError := &smithy.GenericAPIError{ 617 Code: errorCode, 618 Message: errorMessage, 619 } 620 return genericError 621 622 } 623} 624 625type awsAwsjson11_deserializeOpDeleteLogPattern struct { 626} 627 628func (*awsAwsjson11_deserializeOpDeleteLogPattern) ID() string { 629 return "OperationDeserializer" 630} 631 632func (m *awsAwsjson11_deserializeOpDeleteLogPattern) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 633 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 634) { 635 out, metadata, err = next.HandleDeserialize(ctx, in) 636 if err != nil { 637 return out, metadata, err 638 } 639 640 response, ok := out.RawResponse.(*smithyhttp.Response) 641 if !ok { 642 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 643 } 644 645 if response.StatusCode < 200 || response.StatusCode >= 300 { 646 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteLogPattern(response, &metadata) 647 } 648 output := &DeleteLogPatternOutput{} 649 out.Result = output 650 651 var buff [1024]byte 652 ringBuffer := smithyio.NewRingBuffer(buff[:]) 653 654 body := io.TeeReader(response.Body, ringBuffer) 655 decoder := json.NewDecoder(body) 656 decoder.UseNumber() 657 var shape interface{} 658 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 659 var snapshot bytes.Buffer 660 io.Copy(&snapshot, ringBuffer) 661 err = &smithy.DeserializationError{ 662 Err: fmt.Errorf("failed to decode response body, %w", err), 663 Snapshot: snapshot.Bytes(), 664 } 665 return out, metadata, err 666 } 667 668 err = awsAwsjson11_deserializeOpDocumentDeleteLogPatternOutput(&output, shape) 669 if err != nil { 670 var snapshot bytes.Buffer 671 io.Copy(&snapshot, ringBuffer) 672 err = &smithy.DeserializationError{ 673 Err: fmt.Errorf("failed to decode response body, %w", err), 674 Snapshot: snapshot.Bytes(), 675 } 676 return out, metadata, err 677 } 678 679 return out, metadata, err 680} 681 682func awsAwsjson11_deserializeOpErrorDeleteLogPattern(response *smithyhttp.Response, metadata *middleware.Metadata) error { 683 var errorBuffer bytes.Buffer 684 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 685 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 686 } 687 errorBody := bytes.NewReader(errorBuffer.Bytes()) 688 689 errorCode := "UnknownError" 690 errorMessage := errorCode 691 692 code := response.Header.Get("X-Amzn-ErrorType") 693 if len(code) != 0 { 694 errorCode = restjson.SanitizeErrorCode(code) 695 } 696 697 var buff [1024]byte 698 ringBuffer := smithyio.NewRingBuffer(buff[:]) 699 700 body := io.TeeReader(errorBody, ringBuffer) 701 decoder := json.NewDecoder(body) 702 decoder.UseNumber() 703 code, message, err := restjson.GetErrorInfo(decoder) 704 if err != nil { 705 var snapshot bytes.Buffer 706 io.Copy(&snapshot, ringBuffer) 707 err = &smithy.DeserializationError{ 708 Err: fmt.Errorf("failed to decode response body, %w", err), 709 Snapshot: snapshot.Bytes(), 710 } 711 return err 712 } 713 714 errorBody.Seek(0, io.SeekStart) 715 if len(code) != 0 { 716 errorCode = restjson.SanitizeErrorCode(code) 717 } 718 if len(message) != 0 { 719 errorMessage = message 720 } 721 722 switch { 723 case strings.EqualFold("BadRequestException", errorCode): 724 return awsAwsjson11_deserializeErrorBadRequestException(response, errorBody) 725 726 case strings.EqualFold("InternalServerException", errorCode): 727 return awsAwsjson11_deserializeErrorInternalServerException(response, errorBody) 728 729 case strings.EqualFold("ResourceNotFoundException", errorCode): 730 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 731 732 case strings.EqualFold("ValidationException", errorCode): 733 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 734 735 default: 736 genericError := &smithy.GenericAPIError{ 737 Code: errorCode, 738 Message: errorMessage, 739 } 740 return genericError 741 742 } 743} 744 745type awsAwsjson11_deserializeOpDescribeApplication struct { 746} 747 748func (*awsAwsjson11_deserializeOpDescribeApplication) ID() string { 749 return "OperationDeserializer" 750} 751 752func (m *awsAwsjson11_deserializeOpDescribeApplication) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 753 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 754) { 755 out, metadata, err = next.HandleDeserialize(ctx, in) 756 if err != nil { 757 return out, metadata, err 758 } 759 760 response, ok := out.RawResponse.(*smithyhttp.Response) 761 if !ok { 762 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 763 } 764 765 if response.StatusCode < 200 || response.StatusCode >= 300 { 766 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeApplication(response, &metadata) 767 } 768 output := &DescribeApplicationOutput{} 769 out.Result = output 770 771 var buff [1024]byte 772 ringBuffer := smithyio.NewRingBuffer(buff[:]) 773 774 body := io.TeeReader(response.Body, ringBuffer) 775 decoder := json.NewDecoder(body) 776 decoder.UseNumber() 777 var shape interface{} 778 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 779 var snapshot bytes.Buffer 780 io.Copy(&snapshot, ringBuffer) 781 err = &smithy.DeserializationError{ 782 Err: fmt.Errorf("failed to decode response body, %w", err), 783 Snapshot: snapshot.Bytes(), 784 } 785 return out, metadata, err 786 } 787 788 err = awsAwsjson11_deserializeOpDocumentDescribeApplicationOutput(&output, shape) 789 if err != nil { 790 var snapshot bytes.Buffer 791 io.Copy(&snapshot, ringBuffer) 792 err = &smithy.DeserializationError{ 793 Err: fmt.Errorf("failed to decode response body, %w", err), 794 Snapshot: snapshot.Bytes(), 795 } 796 return out, metadata, err 797 } 798 799 return out, metadata, err 800} 801 802func awsAwsjson11_deserializeOpErrorDescribeApplication(response *smithyhttp.Response, metadata *middleware.Metadata) error { 803 var errorBuffer bytes.Buffer 804 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 805 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 806 } 807 errorBody := bytes.NewReader(errorBuffer.Bytes()) 808 809 errorCode := "UnknownError" 810 errorMessage := errorCode 811 812 code := response.Header.Get("X-Amzn-ErrorType") 813 if len(code) != 0 { 814 errorCode = restjson.SanitizeErrorCode(code) 815 } 816 817 var buff [1024]byte 818 ringBuffer := smithyio.NewRingBuffer(buff[:]) 819 820 body := io.TeeReader(errorBody, ringBuffer) 821 decoder := json.NewDecoder(body) 822 decoder.UseNumber() 823 code, message, err := restjson.GetErrorInfo(decoder) 824 if err != nil { 825 var snapshot bytes.Buffer 826 io.Copy(&snapshot, ringBuffer) 827 err = &smithy.DeserializationError{ 828 Err: fmt.Errorf("failed to decode response body, %w", err), 829 Snapshot: snapshot.Bytes(), 830 } 831 return err 832 } 833 834 errorBody.Seek(0, io.SeekStart) 835 if len(code) != 0 { 836 errorCode = restjson.SanitizeErrorCode(code) 837 } 838 if len(message) != 0 { 839 errorMessage = message 840 } 841 842 switch { 843 case strings.EqualFold("InternalServerException", errorCode): 844 return awsAwsjson11_deserializeErrorInternalServerException(response, errorBody) 845 846 case strings.EqualFold("ResourceNotFoundException", errorCode): 847 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 848 849 case strings.EqualFold("ValidationException", errorCode): 850 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 851 852 default: 853 genericError := &smithy.GenericAPIError{ 854 Code: errorCode, 855 Message: errorMessage, 856 } 857 return genericError 858 859 } 860} 861 862type awsAwsjson11_deserializeOpDescribeComponent struct { 863} 864 865func (*awsAwsjson11_deserializeOpDescribeComponent) ID() string { 866 return "OperationDeserializer" 867} 868 869func (m *awsAwsjson11_deserializeOpDescribeComponent) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 870 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 871) { 872 out, metadata, err = next.HandleDeserialize(ctx, in) 873 if err != nil { 874 return out, metadata, err 875 } 876 877 response, ok := out.RawResponse.(*smithyhttp.Response) 878 if !ok { 879 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 880 } 881 882 if response.StatusCode < 200 || response.StatusCode >= 300 { 883 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeComponent(response, &metadata) 884 } 885 output := &DescribeComponentOutput{} 886 out.Result = output 887 888 var buff [1024]byte 889 ringBuffer := smithyio.NewRingBuffer(buff[:]) 890 891 body := io.TeeReader(response.Body, ringBuffer) 892 decoder := json.NewDecoder(body) 893 decoder.UseNumber() 894 var shape interface{} 895 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 896 var snapshot bytes.Buffer 897 io.Copy(&snapshot, ringBuffer) 898 err = &smithy.DeserializationError{ 899 Err: fmt.Errorf("failed to decode response body, %w", err), 900 Snapshot: snapshot.Bytes(), 901 } 902 return out, metadata, err 903 } 904 905 err = awsAwsjson11_deserializeOpDocumentDescribeComponentOutput(&output, shape) 906 if err != nil { 907 var snapshot bytes.Buffer 908 io.Copy(&snapshot, ringBuffer) 909 err = &smithy.DeserializationError{ 910 Err: fmt.Errorf("failed to decode response body, %w", err), 911 Snapshot: snapshot.Bytes(), 912 } 913 return out, metadata, err 914 } 915 916 return out, metadata, err 917} 918 919func awsAwsjson11_deserializeOpErrorDescribeComponent(response *smithyhttp.Response, metadata *middleware.Metadata) error { 920 var errorBuffer bytes.Buffer 921 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 922 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 923 } 924 errorBody := bytes.NewReader(errorBuffer.Bytes()) 925 926 errorCode := "UnknownError" 927 errorMessage := errorCode 928 929 code := response.Header.Get("X-Amzn-ErrorType") 930 if len(code) != 0 { 931 errorCode = restjson.SanitizeErrorCode(code) 932 } 933 934 var buff [1024]byte 935 ringBuffer := smithyio.NewRingBuffer(buff[:]) 936 937 body := io.TeeReader(errorBody, ringBuffer) 938 decoder := json.NewDecoder(body) 939 decoder.UseNumber() 940 code, message, err := restjson.GetErrorInfo(decoder) 941 if err != nil { 942 var snapshot bytes.Buffer 943 io.Copy(&snapshot, ringBuffer) 944 err = &smithy.DeserializationError{ 945 Err: fmt.Errorf("failed to decode response body, %w", err), 946 Snapshot: snapshot.Bytes(), 947 } 948 return err 949 } 950 951 errorBody.Seek(0, io.SeekStart) 952 if len(code) != 0 { 953 errorCode = restjson.SanitizeErrorCode(code) 954 } 955 if len(message) != 0 { 956 errorMessage = message 957 } 958 959 switch { 960 case strings.EqualFold("InternalServerException", errorCode): 961 return awsAwsjson11_deserializeErrorInternalServerException(response, errorBody) 962 963 case strings.EqualFold("ResourceNotFoundException", errorCode): 964 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 965 966 case strings.EqualFold("ValidationException", errorCode): 967 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 968 969 default: 970 genericError := &smithy.GenericAPIError{ 971 Code: errorCode, 972 Message: errorMessage, 973 } 974 return genericError 975 976 } 977} 978 979type awsAwsjson11_deserializeOpDescribeComponentConfiguration struct { 980} 981 982func (*awsAwsjson11_deserializeOpDescribeComponentConfiguration) ID() string { 983 return "OperationDeserializer" 984} 985 986func (m *awsAwsjson11_deserializeOpDescribeComponentConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 987 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 988) { 989 out, metadata, err = next.HandleDeserialize(ctx, in) 990 if err != nil { 991 return out, metadata, err 992 } 993 994 response, ok := out.RawResponse.(*smithyhttp.Response) 995 if !ok { 996 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 997 } 998 999 if response.StatusCode < 200 || response.StatusCode >= 300 { 1000 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeComponentConfiguration(response, &metadata) 1001 } 1002 output := &DescribeComponentConfigurationOutput{} 1003 out.Result = output 1004 1005 var buff [1024]byte 1006 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1007 1008 body := io.TeeReader(response.Body, ringBuffer) 1009 decoder := json.NewDecoder(body) 1010 decoder.UseNumber() 1011 var shape interface{} 1012 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1013 var snapshot bytes.Buffer 1014 io.Copy(&snapshot, ringBuffer) 1015 err = &smithy.DeserializationError{ 1016 Err: fmt.Errorf("failed to decode response body, %w", err), 1017 Snapshot: snapshot.Bytes(), 1018 } 1019 return out, metadata, err 1020 } 1021 1022 err = awsAwsjson11_deserializeOpDocumentDescribeComponentConfigurationOutput(&output, shape) 1023 if err != nil { 1024 var snapshot bytes.Buffer 1025 io.Copy(&snapshot, ringBuffer) 1026 err = &smithy.DeserializationError{ 1027 Err: fmt.Errorf("failed to decode response body, %w", err), 1028 Snapshot: snapshot.Bytes(), 1029 } 1030 return out, metadata, err 1031 } 1032 1033 return out, metadata, err 1034} 1035 1036func awsAwsjson11_deserializeOpErrorDescribeComponentConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1037 var errorBuffer bytes.Buffer 1038 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1039 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1040 } 1041 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1042 1043 errorCode := "UnknownError" 1044 errorMessage := errorCode 1045 1046 code := response.Header.Get("X-Amzn-ErrorType") 1047 if len(code) != 0 { 1048 errorCode = restjson.SanitizeErrorCode(code) 1049 } 1050 1051 var buff [1024]byte 1052 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1053 1054 body := io.TeeReader(errorBody, ringBuffer) 1055 decoder := json.NewDecoder(body) 1056 decoder.UseNumber() 1057 code, message, err := restjson.GetErrorInfo(decoder) 1058 if err != nil { 1059 var snapshot bytes.Buffer 1060 io.Copy(&snapshot, ringBuffer) 1061 err = &smithy.DeserializationError{ 1062 Err: fmt.Errorf("failed to decode response body, %w", err), 1063 Snapshot: snapshot.Bytes(), 1064 } 1065 return err 1066 } 1067 1068 errorBody.Seek(0, io.SeekStart) 1069 if len(code) != 0 { 1070 errorCode = restjson.SanitizeErrorCode(code) 1071 } 1072 if len(message) != 0 { 1073 errorMessage = message 1074 } 1075 1076 switch { 1077 case strings.EqualFold("InternalServerException", errorCode): 1078 return awsAwsjson11_deserializeErrorInternalServerException(response, errorBody) 1079 1080 case strings.EqualFold("ResourceNotFoundException", errorCode): 1081 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 1082 1083 case strings.EqualFold("ValidationException", errorCode): 1084 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 1085 1086 default: 1087 genericError := &smithy.GenericAPIError{ 1088 Code: errorCode, 1089 Message: errorMessage, 1090 } 1091 return genericError 1092 1093 } 1094} 1095 1096type awsAwsjson11_deserializeOpDescribeComponentConfigurationRecommendation struct { 1097} 1098 1099func (*awsAwsjson11_deserializeOpDescribeComponentConfigurationRecommendation) ID() string { 1100 return "OperationDeserializer" 1101} 1102 1103func (m *awsAwsjson11_deserializeOpDescribeComponentConfigurationRecommendation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1104 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1105) { 1106 out, metadata, err = next.HandleDeserialize(ctx, in) 1107 if err != nil { 1108 return out, metadata, err 1109 } 1110 1111 response, ok := out.RawResponse.(*smithyhttp.Response) 1112 if !ok { 1113 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1114 } 1115 1116 if response.StatusCode < 200 || response.StatusCode >= 300 { 1117 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeComponentConfigurationRecommendation(response, &metadata) 1118 } 1119 output := &DescribeComponentConfigurationRecommendationOutput{} 1120 out.Result = output 1121 1122 var buff [1024]byte 1123 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1124 1125 body := io.TeeReader(response.Body, ringBuffer) 1126 decoder := json.NewDecoder(body) 1127 decoder.UseNumber() 1128 var shape interface{} 1129 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1130 var snapshot bytes.Buffer 1131 io.Copy(&snapshot, ringBuffer) 1132 err = &smithy.DeserializationError{ 1133 Err: fmt.Errorf("failed to decode response body, %w", err), 1134 Snapshot: snapshot.Bytes(), 1135 } 1136 return out, metadata, err 1137 } 1138 1139 err = awsAwsjson11_deserializeOpDocumentDescribeComponentConfigurationRecommendationOutput(&output, shape) 1140 if err != nil { 1141 var snapshot bytes.Buffer 1142 io.Copy(&snapshot, ringBuffer) 1143 err = &smithy.DeserializationError{ 1144 Err: fmt.Errorf("failed to decode response body, %w", err), 1145 Snapshot: snapshot.Bytes(), 1146 } 1147 return out, metadata, err 1148 } 1149 1150 return out, metadata, err 1151} 1152 1153func awsAwsjson11_deserializeOpErrorDescribeComponentConfigurationRecommendation(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1154 var errorBuffer bytes.Buffer 1155 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1156 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1157 } 1158 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1159 1160 errorCode := "UnknownError" 1161 errorMessage := errorCode 1162 1163 code := response.Header.Get("X-Amzn-ErrorType") 1164 if len(code) != 0 { 1165 errorCode = restjson.SanitizeErrorCode(code) 1166 } 1167 1168 var buff [1024]byte 1169 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1170 1171 body := io.TeeReader(errorBody, ringBuffer) 1172 decoder := json.NewDecoder(body) 1173 decoder.UseNumber() 1174 code, message, err := restjson.GetErrorInfo(decoder) 1175 if err != nil { 1176 var snapshot bytes.Buffer 1177 io.Copy(&snapshot, ringBuffer) 1178 err = &smithy.DeserializationError{ 1179 Err: fmt.Errorf("failed to decode response body, %w", err), 1180 Snapshot: snapshot.Bytes(), 1181 } 1182 return err 1183 } 1184 1185 errorBody.Seek(0, io.SeekStart) 1186 if len(code) != 0 { 1187 errorCode = restjson.SanitizeErrorCode(code) 1188 } 1189 if len(message) != 0 { 1190 errorMessage = message 1191 } 1192 1193 switch { 1194 case strings.EqualFold("InternalServerException", errorCode): 1195 return awsAwsjson11_deserializeErrorInternalServerException(response, errorBody) 1196 1197 case strings.EqualFold("ResourceNotFoundException", errorCode): 1198 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 1199 1200 case strings.EqualFold("ValidationException", errorCode): 1201 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 1202 1203 default: 1204 genericError := &smithy.GenericAPIError{ 1205 Code: errorCode, 1206 Message: errorMessage, 1207 } 1208 return genericError 1209 1210 } 1211} 1212 1213type awsAwsjson11_deserializeOpDescribeLogPattern struct { 1214} 1215 1216func (*awsAwsjson11_deserializeOpDescribeLogPattern) ID() string { 1217 return "OperationDeserializer" 1218} 1219 1220func (m *awsAwsjson11_deserializeOpDescribeLogPattern) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1221 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1222) { 1223 out, metadata, err = next.HandleDeserialize(ctx, in) 1224 if err != nil { 1225 return out, metadata, err 1226 } 1227 1228 response, ok := out.RawResponse.(*smithyhttp.Response) 1229 if !ok { 1230 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1231 } 1232 1233 if response.StatusCode < 200 || response.StatusCode >= 300 { 1234 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeLogPattern(response, &metadata) 1235 } 1236 output := &DescribeLogPatternOutput{} 1237 out.Result = output 1238 1239 var buff [1024]byte 1240 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1241 1242 body := io.TeeReader(response.Body, ringBuffer) 1243 decoder := json.NewDecoder(body) 1244 decoder.UseNumber() 1245 var shape interface{} 1246 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1247 var snapshot bytes.Buffer 1248 io.Copy(&snapshot, ringBuffer) 1249 err = &smithy.DeserializationError{ 1250 Err: fmt.Errorf("failed to decode response body, %w", err), 1251 Snapshot: snapshot.Bytes(), 1252 } 1253 return out, metadata, err 1254 } 1255 1256 err = awsAwsjson11_deserializeOpDocumentDescribeLogPatternOutput(&output, shape) 1257 if err != nil { 1258 var snapshot bytes.Buffer 1259 io.Copy(&snapshot, ringBuffer) 1260 err = &smithy.DeserializationError{ 1261 Err: fmt.Errorf("failed to decode response body, %w", err), 1262 Snapshot: snapshot.Bytes(), 1263 } 1264 return out, metadata, err 1265 } 1266 1267 return out, metadata, err 1268} 1269 1270func awsAwsjson11_deserializeOpErrorDescribeLogPattern(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1271 var errorBuffer bytes.Buffer 1272 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1273 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1274 } 1275 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1276 1277 errorCode := "UnknownError" 1278 errorMessage := errorCode 1279 1280 code := response.Header.Get("X-Amzn-ErrorType") 1281 if len(code) != 0 { 1282 errorCode = restjson.SanitizeErrorCode(code) 1283 } 1284 1285 var buff [1024]byte 1286 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1287 1288 body := io.TeeReader(errorBody, ringBuffer) 1289 decoder := json.NewDecoder(body) 1290 decoder.UseNumber() 1291 code, message, err := restjson.GetErrorInfo(decoder) 1292 if err != nil { 1293 var snapshot bytes.Buffer 1294 io.Copy(&snapshot, ringBuffer) 1295 err = &smithy.DeserializationError{ 1296 Err: fmt.Errorf("failed to decode response body, %w", err), 1297 Snapshot: snapshot.Bytes(), 1298 } 1299 return err 1300 } 1301 1302 errorBody.Seek(0, io.SeekStart) 1303 if len(code) != 0 { 1304 errorCode = restjson.SanitizeErrorCode(code) 1305 } 1306 if len(message) != 0 { 1307 errorMessage = message 1308 } 1309 1310 switch { 1311 case strings.EqualFold("InternalServerException", errorCode): 1312 return awsAwsjson11_deserializeErrorInternalServerException(response, errorBody) 1313 1314 case strings.EqualFold("ResourceNotFoundException", errorCode): 1315 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 1316 1317 case strings.EqualFold("ValidationException", errorCode): 1318 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 1319 1320 default: 1321 genericError := &smithy.GenericAPIError{ 1322 Code: errorCode, 1323 Message: errorMessage, 1324 } 1325 return genericError 1326 1327 } 1328} 1329 1330type awsAwsjson11_deserializeOpDescribeObservation struct { 1331} 1332 1333func (*awsAwsjson11_deserializeOpDescribeObservation) ID() string { 1334 return "OperationDeserializer" 1335} 1336 1337func (m *awsAwsjson11_deserializeOpDescribeObservation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1338 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1339) { 1340 out, metadata, err = next.HandleDeserialize(ctx, in) 1341 if err != nil { 1342 return out, metadata, err 1343 } 1344 1345 response, ok := out.RawResponse.(*smithyhttp.Response) 1346 if !ok { 1347 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1348 } 1349 1350 if response.StatusCode < 200 || response.StatusCode >= 300 { 1351 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeObservation(response, &metadata) 1352 } 1353 output := &DescribeObservationOutput{} 1354 out.Result = output 1355 1356 var buff [1024]byte 1357 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1358 1359 body := io.TeeReader(response.Body, ringBuffer) 1360 decoder := json.NewDecoder(body) 1361 decoder.UseNumber() 1362 var shape interface{} 1363 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1364 var snapshot bytes.Buffer 1365 io.Copy(&snapshot, ringBuffer) 1366 err = &smithy.DeserializationError{ 1367 Err: fmt.Errorf("failed to decode response body, %w", err), 1368 Snapshot: snapshot.Bytes(), 1369 } 1370 return out, metadata, err 1371 } 1372 1373 err = awsAwsjson11_deserializeOpDocumentDescribeObservationOutput(&output, shape) 1374 if err != nil { 1375 var snapshot bytes.Buffer 1376 io.Copy(&snapshot, ringBuffer) 1377 err = &smithy.DeserializationError{ 1378 Err: fmt.Errorf("failed to decode response body, %w", err), 1379 Snapshot: snapshot.Bytes(), 1380 } 1381 return out, metadata, err 1382 } 1383 1384 return out, metadata, err 1385} 1386 1387func awsAwsjson11_deserializeOpErrorDescribeObservation(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1388 var errorBuffer bytes.Buffer 1389 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1390 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1391 } 1392 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1393 1394 errorCode := "UnknownError" 1395 errorMessage := errorCode 1396 1397 code := response.Header.Get("X-Amzn-ErrorType") 1398 if len(code) != 0 { 1399 errorCode = restjson.SanitizeErrorCode(code) 1400 } 1401 1402 var buff [1024]byte 1403 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1404 1405 body := io.TeeReader(errorBody, ringBuffer) 1406 decoder := json.NewDecoder(body) 1407 decoder.UseNumber() 1408 code, message, err := restjson.GetErrorInfo(decoder) 1409 if err != nil { 1410 var snapshot bytes.Buffer 1411 io.Copy(&snapshot, ringBuffer) 1412 err = &smithy.DeserializationError{ 1413 Err: fmt.Errorf("failed to decode response body, %w", err), 1414 Snapshot: snapshot.Bytes(), 1415 } 1416 return err 1417 } 1418 1419 errorBody.Seek(0, io.SeekStart) 1420 if len(code) != 0 { 1421 errorCode = restjson.SanitizeErrorCode(code) 1422 } 1423 if len(message) != 0 { 1424 errorMessage = message 1425 } 1426 1427 switch { 1428 case strings.EqualFold("InternalServerException", errorCode): 1429 return awsAwsjson11_deserializeErrorInternalServerException(response, errorBody) 1430 1431 case strings.EqualFold("ResourceNotFoundException", errorCode): 1432 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 1433 1434 case strings.EqualFold("ValidationException", errorCode): 1435 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 1436 1437 default: 1438 genericError := &smithy.GenericAPIError{ 1439 Code: errorCode, 1440 Message: errorMessage, 1441 } 1442 return genericError 1443 1444 } 1445} 1446 1447type awsAwsjson11_deserializeOpDescribeProblem struct { 1448} 1449 1450func (*awsAwsjson11_deserializeOpDescribeProblem) ID() string { 1451 return "OperationDeserializer" 1452} 1453 1454func (m *awsAwsjson11_deserializeOpDescribeProblem) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1455 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1456) { 1457 out, metadata, err = next.HandleDeserialize(ctx, in) 1458 if err != nil { 1459 return out, metadata, err 1460 } 1461 1462 response, ok := out.RawResponse.(*smithyhttp.Response) 1463 if !ok { 1464 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1465 } 1466 1467 if response.StatusCode < 200 || response.StatusCode >= 300 { 1468 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeProblem(response, &metadata) 1469 } 1470 output := &DescribeProblemOutput{} 1471 out.Result = output 1472 1473 var buff [1024]byte 1474 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1475 1476 body := io.TeeReader(response.Body, ringBuffer) 1477 decoder := json.NewDecoder(body) 1478 decoder.UseNumber() 1479 var shape interface{} 1480 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1481 var snapshot bytes.Buffer 1482 io.Copy(&snapshot, ringBuffer) 1483 err = &smithy.DeserializationError{ 1484 Err: fmt.Errorf("failed to decode response body, %w", err), 1485 Snapshot: snapshot.Bytes(), 1486 } 1487 return out, metadata, err 1488 } 1489 1490 err = awsAwsjson11_deserializeOpDocumentDescribeProblemOutput(&output, shape) 1491 if err != nil { 1492 var snapshot bytes.Buffer 1493 io.Copy(&snapshot, ringBuffer) 1494 err = &smithy.DeserializationError{ 1495 Err: fmt.Errorf("failed to decode response body, %w", err), 1496 Snapshot: snapshot.Bytes(), 1497 } 1498 return out, metadata, err 1499 } 1500 1501 return out, metadata, err 1502} 1503 1504func awsAwsjson11_deserializeOpErrorDescribeProblem(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1505 var errorBuffer bytes.Buffer 1506 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1507 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1508 } 1509 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1510 1511 errorCode := "UnknownError" 1512 errorMessage := errorCode 1513 1514 code := response.Header.Get("X-Amzn-ErrorType") 1515 if len(code) != 0 { 1516 errorCode = restjson.SanitizeErrorCode(code) 1517 } 1518 1519 var buff [1024]byte 1520 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1521 1522 body := io.TeeReader(errorBody, ringBuffer) 1523 decoder := json.NewDecoder(body) 1524 decoder.UseNumber() 1525 code, message, err := restjson.GetErrorInfo(decoder) 1526 if err != nil { 1527 var snapshot bytes.Buffer 1528 io.Copy(&snapshot, ringBuffer) 1529 err = &smithy.DeserializationError{ 1530 Err: fmt.Errorf("failed to decode response body, %w", err), 1531 Snapshot: snapshot.Bytes(), 1532 } 1533 return err 1534 } 1535 1536 errorBody.Seek(0, io.SeekStart) 1537 if len(code) != 0 { 1538 errorCode = restjson.SanitizeErrorCode(code) 1539 } 1540 if len(message) != 0 { 1541 errorMessage = message 1542 } 1543 1544 switch { 1545 case strings.EqualFold("InternalServerException", errorCode): 1546 return awsAwsjson11_deserializeErrorInternalServerException(response, errorBody) 1547 1548 case strings.EqualFold("ResourceNotFoundException", errorCode): 1549 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 1550 1551 case strings.EqualFold("ValidationException", errorCode): 1552 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 1553 1554 default: 1555 genericError := &smithy.GenericAPIError{ 1556 Code: errorCode, 1557 Message: errorMessage, 1558 } 1559 return genericError 1560 1561 } 1562} 1563 1564type awsAwsjson11_deserializeOpDescribeProblemObservations struct { 1565} 1566 1567func (*awsAwsjson11_deserializeOpDescribeProblemObservations) ID() string { 1568 return "OperationDeserializer" 1569} 1570 1571func (m *awsAwsjson11_deserializeOpDescribeProblemObservations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1572 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1573) { 1574 out, metadata, err = next.HandleDeserialize(ctx, in) 1575 if err != nil { 1576 return out, metadata, err 1577 } 1578 1579 response, ok := out.RawResponse.(*smithyhttp.Response) 1580 if !ok { 1581 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1582 } 1583 1584 if response.StatusCode < 200 || response.StatusCode >= 300 { 1585 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeProblemObservations(response, &metadata) 1586 } 1587 output := &DescribeProblemObservationsOutput{} 1588 out.Result = output 1589 1590 var buff [1024]byte 1591 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1592 1593 body := io.TeeReader(response.Body, ringBuffer) 1594 decoder := json.NewDecoder(body) 1595 decoder.UseNumber() 1596 var shape interface{} 1597 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1598 var snapshot bytes.Buffer 1599 io.Copy(&snapshot, ringBuffer) 1600 err = &smithy.DeserializationError{ 1601 Err: fmt.Errorf("failed to decode response body, %w", err), 1602 Snapshot: snapshot.Bytes(), 1603 } 1604 return out, metadata, err 1605 } 1606 1607 err = awsAwsjson11_deserializeOpDocumentDescribeProblemObservationsOutput(&output, shape) 1608 if err != nil { 1609 var snapshot bytes.Buffer 1610 io.Copy(&snapshot, ringBuffer) 1611 err = &smithy.DeserializationError{ 1612 Err: fmt.Errorf("failed to decode response body, %w", err), 1613 Snapshot: snapshot.Bytes(), 1614 } 1615 return out, metadata, err 1616 } 1617 1618 return out, metadata, err 1619} 1620 1621func awsAwsjson11_deserializeOpErrorDescribeProblemObservations(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1622 var errorBuffer bytes.Buffer 1623 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1624 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1625 } 1626 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1627 1628 errorCode := "UnknownError" 1629 errorMessage := errorCode 1630 1631 code := response.Header.Get("X-Amzn-ErrorType") 1632 if len(code) != 0 { 1633 errorCode = restjson.SanitizeErrorCode(code) 1634 } 1635 1636 var buff [1024]byte 1637 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1638 1639 body := io.TeeReader(errorBody, ringBuffer) 1640 decoder := json.NewDecoder(body) 1641 decoder.UseNumber() 1642 code, message, err := restjson.GetErrorInfo(decoder) 1643 if err != nil { 1644 var snapshot bytes.Buffer 1645 io.Copy(&snapshot, ringBuffer) 1646 err = &smithy.DeserializationError{ 1647 Err: fmt.Errorf("failed to decode response body, %w", err), 1648 Snapshot: snapshot.Bytes(), 1649 } 1650 return err 1651 } 1652 1653 errorBody.Seek(0, io.SeekStart) 1654 if len(code) != 0 { 1655 errorCode = restjson.SanitizeErrorCode(code) 1656 } 1657 if len(message) != 0 { 1658 errorMessage = message 1659 } 1660 1661 switch { 1662 case strings.EqualFold("InternalServerException", errorCode): 1663 return awsAwsjson11_deserializeErrorInternalServerException(response, errorBody) 1664 1665 case strings.EqualFold("ResourceNotFoundException", errorCode): 1666 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 1667 1668 case strings.EqualFold("ValidationException", errorCode): 1669 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 1670 1671 default: 1672 genericError := &smithy.GenericAPIError{ 1673 Code: errorCode, 1674 Message: errorMessage, 1675 } 1676 return genericError 1677 1678 } 1679} 1680 1681type awsAwsjson11_deserializeOpListApplications struct { 1682} 1683 1684func (*awsAwsjson11_deserializeOpListApplications) ID() string { 1685 return "OperationDeserializer" 1686} 1687 1688func (m *awsAwsjson11_deserializeOpListApplications) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1689 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1690) { 1691 out, metadata, err = next.HandleDeserialize(ctx, in) 1692 if err != nil { 1693 return out, metadata, err 1694 } 1695 1696 response, ok := out.RawResponse.(*smithyhttp.Response) 1697 if !ok { 1698 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1699 } 1700 1701 if response.StatusCode < 200 || response.StatusCode >= 300 { 1702 return out, metadata, awsAwsjson11_deserializeOpErrorListApplications(response, &metadata) 1703 } 1704 output := &ListApplicationsOutput{} 1705 out.Result = output 1706 1707 var buff [1024]byte 1708 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1709 1710 body := io.TeeReader(response.Body, ringBuffer) 1711 decoder := json.NewDecoder(body) 1712 decoder.UseNumber() 1713 var shape interface{} 1714 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1715 var snapshot bytes.Buffer 1716 io.Copy(&snapshot, ringBuffer) 1717 err = &smithy.DeserializationError{ 1718 Err: fmt.Errorf("failed to decode response body, %w", err), 1719 Snapshot: snapshot.Bytes(), 1720 } 1721 return out, metadata, err 1722 } 1723 1724 err = awsAwsjson11_deserializeOpDocumentListApplicationsOutput(&output, shape) 1725 if err != nil { 1726 var snapshot bytes.Buffer 1727 io.Copy(&snapshot, ringBuffer) 1728 err = &smithy.DeserializationError{ 1729 Err: fmt.Errorf("failed to decode response body, %w", err), 1730 Snapshot: snapshot.Bytes(), 1731 } 1732 return out, metadata, err 1733 } 1734 1735 return out, metadata, err 1736} 1737 1738func awsAwsjson11_deserializeOpErrorListApplications(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1739 var errorBuffer bytes.Buffer 1740 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1741 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1742 } 1743 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1744 1745 errorCode := "UnknownError" 1746 errorMessage := errorCode 1747 1748 code := response.Header.Get("X-Amzn-ErrorType") 1749 if len(code) != 0 { 1750 errorCode = restjson.SanitizeErrorCode(code) 1751 } 1752 1753 var buff [1024]byte 1754 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1755 1756 body := io.TeeReader(errorBody, ringBuffer) 1757 decoder := json.NewDecoder(body) 1758 decoder.UseNumber() 1759 code, message, err := restjson.GetErrorInfo(decoder) 1760 if err != nil { 1761 var snapshot bytes.Buffer 1762 io.Copy(&snapshot, ringBuffer) 1763 err = &smithy.DeserializationError{ 1764 Err: fmt.Errorf("failed to decode response body, %w", err), 1765 Snapshot: snapshot.Bytes(), 1766 } 1767 return err 1768 } 1769 1770 errorBody.Seek(0, io.SeekStart) 1771 if len(code) != 0 { 1772 errorCode = restjson.SanitizeErrorCode(code) 1773 } 1774 if len(message) != 0 { 1775 errorMessage = message 1776 } 1777 1778 switch { 1779 case strings.EqualFold("InternalServerException", errorCode): 1780 return awsAwsjson11_deserializeErrorInternalServerException(response, errorBody) 1781 1782 case strings.EqualFold("ValidationException", errorCode): 1783 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 1784 1785 default: 1786 genericError := &smithy.GenericAPIError{ 1787 Code: errorCode, 1788 Message: errorMessage, 1789 } 1790 return genericError 1791 1792 } 1793} 1794 1795type awsAwsjson11_deserializeOpListComponents struct { 1796} 1797 1798func (*awsAwsjson11_deserializeOpListComponents) ID() string { 1799 return "OperationDeserializer" 1800} 1801 1802func (m *awsAwsjson11_deserializeOpListComponents) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1803 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1804) { 1805 out, metadata, err = next.HandleDeserialize(ctx, in) 1806 if err != nil { 1807 return out, metadata, err 1808 } 1809 1810 response, ok := out.RawResponse.(*smithyhttp.Response) 1811 if !ok { 1812 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1813 } 1814 1815 if response.StatusCode < 200 || response.StatusCode >= 300 { 1816 return out, metadata, awsAwsjson11_deserializeOpErrorListComponents(response, &metadata) 1817 } 1818 output := &ListComponentsOutput{} 1819 out.Result = output 1820 1821 var buff [1024]byte 1822 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1823 1824 body := io.TeeReader(response.Body, ringBuffer) 1825 decoder := json.NewDecoder(body) 1826 decoder.UseNumber() 1827 var shape interface{} 1828 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1829 var snapshot bytes.Buffer 1830 io.Copy(&snapshot, ringBuffer) 1831 err = &smithy.DeserializationError{ 1832 Err: fmt.Errorf("failed to decode response body, %w", err), 1833 Snapshot: snapshot.Bytes(), 1834 } 1835 return out, metadata, err 1836 } 1837 1838 err = awsAwsjson11_deserializeOpDocumentListComponentsOutput(&output, shape) 1839 if err != nil { 1840 var snapshot bytes.Buffer 1841 io.Copy(&snapshot, ringBuffer) 1842 err = &smithy.DeserializationError{ 1843 Err: fmt.Errorf("failed to decode response body, %w", err), 1844 Snapshot: snapshot.Bytes(), 1845 } 1846 return out, metadata, err 1847 } 1848 1849 return out, metadata, err 1850} 1851 1852func awsAwsjson11_deserializeOpErrorListComponents(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1853 var errorBuffer bytes.Buffer 1854 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1855 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1856 } 1857 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1858 1859 errorCode := "UnknownError" 1860 errorMessage := errorCode 1861 1862 code := response.Header.Get("X-Amzn-ErrorType") 1863 if len(code) != 0 { 1864 errorCode = restjson.SanitizeErrorCode(code) 1865 } 1866 1867 var buff [1024]byte 1868 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1869 1870 body := io.TeeReader(errorBody, ringBuffer) 1871 decoder := json.NewDecoder(body) 1872 decoder.UseNumber() 1873 code, message, err := restjson.GetErrorInfo(decoder) 1874 if err != nil { 1875 var snapshot bytes.Buffer 1876 io.Copy(&snapshot, ringBuffer) 1877 err = &smithy.DeserializationError{ 1878 Err: fmt.Errorf("failed to decode response body, %w", err), 1879 Snapshot: snapshot.Bytes(), 1880 } 1881 return err 1882 } 1883 1884 errorBody.Seek(0, io.SeekStart) 1885 if len(code) != 0 { 1886 errorCode = restjson.SanitizeErrorCode(code) 1887 } 1888 if len(message) != 0 { 1889 errorMessage = message 1890 } 1891 1892 switch { 1893 case strings.EqualFold("InternalServerException", errorCode): 1894 return awsAwsjson11_deserializeErrorInternalServerException(response, errorBody) 1895 1896 case strings.EqualFold("ResourceNotFoundException", errorCode): 1897 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 1898 1899 case strings.EqualFold("ValidationException", errorCode): 1900 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 1901 1902 default: 1903 genericError := &smithy.GenericAPIError{ 1904 Code: errorCode, 1905 Message: errorMessage, 1906 } 1907 return genericError 1908 1909 } 1910} 1911 1912type awsAwsjson11_deserializeOpListConfigurationHistory struct { 1913} 1914 1915func (*awsAwsjson11_deserializeOpListConfigurationHistory) ID() string { 1916 return "OperationDeserializer" 1917} 1918 1919func (m *awsAwsjson11_deserializeOpListConfigurationHistory) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1920 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1921) { 1922 out, metadata, err = next.HandleDeserialize(ctx, in) 1923 if err != nil { 1924 return out, metadata, err 1925 } 1926 1927 response, ok := out.RawResponse.(*smithyhttp.Response) 1928 if !ok { 1929 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1930 } 1931 1932 if response.StatusCode < 200 || response.StatusCode >= 300 { 1933 return out, metadata, awsAwsjson11_deserializeOpErrorListConfigurationHistory(response, &metadata) 1934 } 1935 output := &ListConfigurationHistoryOutput{} 1936 out.Result = output 1937 1938 var buff [1024]byte 1939 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1940 1941 body := io.TeeReader(response.Body, ringBuffer) 1942 decoder := json.NewDecoder(body) 1943 decoder.UseNumber() 1944 var shape interface{} 1945 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1946 var snapshot bytes.Buffer 1947 io.Copy(&snapshot, ringBuffer) 1948 err = &smithy.DeserializationError{ 1949 Err: fmt.Errorf("failed to decode response body, %w", err), 1950 Snapshot: snapshot.Bytes(), 1951 } 1952 return out, metadata, err 1953 } 1954 1955 err = awsAwsjson11_deserializeOpDocumentListConfigurationHistoryOutput(&output, shape) 1956 if err != nil { 1957 var snapshot bytes.Buffer 1958 io.Copy(&snapshot, ringBuffer) 1959 err = &smithy.DeserializationError{ 1960 Err: fmt.Errorf("failed to decode response body, %w", err), 1961 Snapshot: snapshot.Bytes(), 1962 } 1963 return out, metadata, err 1964 } 1965 1966 return out, metadata, err 1967} 1968 1969func awsAwsjson11_deserializeOpErrorListConfigurationHistory(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1970 var errorBuffer bytes.Buffer 1971 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1972 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1973 } 1974 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1975 1976 errorCode := "UnknownError" 1977 errorMessage := errorCode 1978 1979 code := response.Header.Get("X-Amzn-ErrorType") 1980 if len(code) != 0 { 1981 errorCode = restjson.SanitizeErrorCode(code) 1982 } 1983 1984 var buff [1024]byte 1985 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1986 1987 body := io.TeeReader(errorBody, ringBuffer) 1988 decoder := json.NewDecoder(body) 1989 decoder.UseNumber() 1990 code, message, err := restjson.GetErrorInfo(decoder) 1991 if err != nil { 1992 var snapshot bytes.Buffer 1993 io.Copy(&snapshot, ringBuffer) 1994 err = &smithy.DeserializationError{ 1995 Err: fmt.Errorf("failed to decode response body, %w", err), 1996 Snapshot: snapshot.Bytes(), 1997 } 1998 return err 1999 } 2000 2001 errorBody.Seek(0, io.SeekStart) 2002 if len(code) != 0 { 2003 errorCode = restjson.SanitizeErrorCode(code) 2004 } 2005 if len(message) != 0 { 2006 errorMessage = message 2007 } 2008 2009 switch { 2010 case strings.EqualFold("InternalServerException", errorCode): 2011 return awsAwsjson11_deserializeErrorInternalServerException(response, errorBody) 2012 2013 case strings.EqualFold("ResourceNotFoundException", errorCode): 2014 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 2015 2016 case strings.EqualFold("ValidationException", errorCode): 2017 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 2018 2019 default: 2020 genericError := &smithy.GenericAPIError{ 2021 Code: errorCode, 2022 Message: errorMessage, 2023 } 2024 return genericError 2025 2026 } 2027} 2028 2029type awsAwsjson11_deserializeOpListLogPatterns struct { 2030} 2031 2032func (*awsAwsjson11_deserializeOpListLogPatterns) ID() string { 2033 return "OperationDeserializer" 2034} 2035 2036func (m *awsAwsjson11_deserializeOpListLogPatterns) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2037 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2038) { 2039 out, metadata, err = next.HandleDeserialize(ctx, in) 2040 if err != nil { 2041 return out, metadata, err 2042 } 2043 2044 response, ok := out.RawResponse.(*smithyhttp.Response) 2045 if !ok { 2046 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2047 } 2048 2049 if response.StatusCode < 200 || response.StatusCode >= 300 { 2050 return out, metadata, awsAwsjson11_deserializeOpErrorListLogPatterns(response, &metadata) 2051 } 2052 output := &ListLogPatternsOutput{} 2053 out.Result = output 2054 2055 var buff [1024]byte 2056 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2057 2058 body := io.TeeReader(response.Body, ringBuffer) 2059 decoder := json.NewDecoder(body) 2060 decoder.UseNumber() 2061 var shape interface{} 2062 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2063 var snapshot bytes.Buffer 2064 io.Copy(&snapshot, ringBuffer) 2065 err = &smithy.DeserializationError{ 2066 Err: fmt.Errorf("failed to decode response body, %w", err), 2067 Snapshot: snapshot.Bytes(), 2068 } 2069 return out, metadata, err 2070 } 2071 2072 err = awsAwsjson11_deserializeOpDocumentListLogPatternsOutput(&output, shape) 2073 if err != nil { 2074 var snapshot bytes.Buffer 2075 io.Copy(&snapshot, ringBuffer) 2076 err = &smithy.DeserializationError{ 2077 Err: fmt.Errorf("failed to decode response body, %w", err), 2078 Snapshot: snapshot.Bytes(), 2079 } 2080 return out, metadata, err 2081 } 2082 2083 return out, metadata, err 2084} 2085 2086func awsAwsjson11_deserializeOpErrorListLogPatterns(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2087 var errorBuffer bytes.Buffer 2088 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2089 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2090 } 2091 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2092 2093 errorCode := "UnknownError" 2094 errorMessage := errorCode 2095 2096 code := response.Header.Get("X-Amzn-ErrorType") 2097 if len(code) != 0 { 2098 errorCode = restjson.SanitizeErrorCode(code) 2099 } 2100 2101 var buff [1024]byte 2102 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2103 2104 body := io.TeeReader(errorBody, ringBuffer) 2105 decoder := json.NewDecoder(body) 2106 decoder.UseNumber() 2107 code, message, err := restjson.GetErrorInfo(decoder) 2108 if err != nil { 2109 var snapshot bytes.Buffer 2110 io.Copy(&snapshot, ringBuffer) 2111 err = &smithy.DeserializationError{ 2112 Err: fmt.Errorf("failed to decode response body, %w", err), 2113 Snapshot: snapshot.Bytes(), 2114 } 2115 return err 2116 } 2117 2118 errorBody.Seek(0, io.SeekStart) 2119 if len(code) != 0 { 2120 errorCode = restjson.SanitizeErrorCode(code) 2121 } 2122 if len(message) != 0 { 2123 errorMessage = message 2124 } 2125 2126 switch { 2127 case strings.EqualFold("InternalServerException", errorCode): 2128 return awsAwsjson11_deserializeErrorInternalServerException(response, errorBody) 2129 2130 case strings.EqualFold("ResourceNotFoundException", errorCode): 2131 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 2132 2133 case strings.EqualFold("ValidationException", errorCode): 2134 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 2135 2136 default: 2137 genericError := &smithy.GenericAPIError{ 2138 Code: errorCode, 2139 Message: errorMessage, 2140 } 2141 return genericError 2142 2143 } 2144} 2145 2146type awsAwsjson11_deserializeOpListLogPatternSets struct { 2147} 2148 2149func (*awsAwsjson11_deserializeOpListLogPatternSets) ID() string { 2150 return "OperationDeserializer" 2151} 2152 2153func (m *awsAwsjson11_deserializeOpListLogPatternSets) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2154 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2155) { 2156 out, metadata, err = next.HandleDeserialize(ctx, in) 2157 if err != nil { 2158 return out, metadata, err 2159 } 2160 2161 response, ok := out.RawResponse.(*smithyhttp.Response) 2162 if !ok { 2163 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2164 } 2165 2166 if response.StatusCode < 200 || response.StatusCode >= 300 { 2167 return out, metadata, awsAwsjson11_deserializeOpErrorListLogPatternSets(response, &metadata) 2168 } 2169 output := &ListLogPatternSetsOutput{} 2170 out.Result = output 2171 2172 var buff [1024]byte 2173 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2174 2175 body := io.TeeReader(response.Body, ringBuffer) 2176 decoder := json.NewDecoder(body) 2177 decoder.UseNumber() 2178 var shape interface{} 2179 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2180 var snapshot bytes.Buffer 2181 io.Copy(&snapshot, ringBuffer) 2182 err = &smithy.DeserializationError{ 2183 Err: fmt.Errorf("failed to decode response body, %w", err), 2184 Snapshot: snapshot.Bytes(), 2185 } 2186 return out, metadata, err 2187 } 2188 2189 err = awsAwsjson11_deserializeOpDocumentListLogPatternSetsOutput(&output, shape) 2190 if err != nil { 2191 var snapshot bytes.Buffer 2192 io.Copy(&snapshot, ringBuffer) 2193 err = &smithy.DeserializationError{ 2194 Err: fmt.Errorf("failed to decode response body, %w", err), 2195 Snapshot: snapshot.Bytes(), 2196 } 2197 return out, metadata, err 2198 } 2199 2200 return out, metadata, err 2201} 2202 2203func awsAwsjson11_deserializeOpErrorListLogPatternSets(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2204 var errorBuffer bytes.Buffer 2205 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2206 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2207 } 2208 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2209 2210 errorCode := "UnknownError" 2211 errorMessage := errorCode 2212 2213 code := response.Header.Get("X-Amzn-ErrorType") 2214 if len(code) != 0 { 2215 errorCode = restjson.SanitizeErrorCode(code) 2216 } 2217 2218 var buff [1024]byte 2219 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2220 2221 body := io.TeeReader(errorBody, ringBuffer) 2222 decoder := json.NewDecoder(body) 2223 decoder.UseNumber() 2224 code, message, err := restjson.GetErrorInfo(decoder) 2225 if err != nil { 2226 var snapshot bytes.Buffer 2227 io.Copy(&snapshot, ringBuffer) 2228 err = &smithy.DeserializationError{ 2229 Err: fmt.Errorf("failed to decode response body, %w", err), 2230 Snapshot: snapshot.Bytes(), 2231 } 2232 return err 2233 } 2234 2235 errorBody.Seek(0, io.SeekStart) 2236 if len(code) != 0 { 2237 errorCode = restjson.SanitizeErrorCode(code) 2238 } 2239 if len(message) != 0 { 2240 errorMessage = message 2241 } 2242 2243 switch { 2244 case strings.EqualFold("InternalServerException", errorCode): 2245 return awsAwsjson11_deserializeErrorInternalServerException(response, errorBody) 2246 2247 case strings.EqualFold("ResourceNotFoundException", errorCode): 2248 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 2249 2250 case strings.EqualFold("ValidationException", errorCode): 2251 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 2252 2253 default: 2254 genericError := &smithy.GenericAPIError{ 2255 Code: errorCode, 2256 Message: errorMessage, 2257 } 2258 return genericError 2259 2260 } 2261} 2262 2263type awsAwsjson11_deserializeOpListProblems struct { 2264} 2265 2266func (*awsAwsjson11_deserializeOpListProblems) ID() string { 2267 return "OperationDeserializer" 2268} 2269 2270func (m *awsAwsjson11_deserializeOpListProblems) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2271 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2272) { 2273 out, metadata, err = next.HandleDeserialize(ctx, in) 2274 if err != nil { 2275 return out, metadata, err 2276 } 2277 2278 response, ok := out.RawResponse.(*smithyhttp.Response) 2279 if !ok { 2280 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2281 } 2282 2283 if response.StatusCode < 200 || response.StatusCode >= 300 { 2284 return out, metadata, awsAwsjson11_deserializeOpErrorListProblems(response, &metadata) 2285 } 2286 output := &ListProblemsOutput{} 2287 out.Result = output 2288 2289 var buff [1024]byte 2290 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2291 2292 body := io.TeeReader(response.Body, ringBuffer) 2293 decoder := json.NewDecoder(body) 2294 decoder.UseNumber() 2295 var shape interface{} 2296 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2297 var snapshot bytes.Buffer 2298 io.Copy(&snapshot, ringBuffer) 2299 err = &smithy.DeserializationError{ 2300 Err: fmt.Errorf("failed to decode response body, %w", err), 2301 Snapshot: snapshot.Bytes(), 2302 } 2303 return out, metadata, err 2304 } 2305 2306 err = awsAwsjson11_deserializeOpDocumentListProblemsOutput(&output, shape) 2307 if err != nil { 2308 var snapshot bytes.Buffer 2309 io.Copy(&snapshot, ringBuffer) 2310 err = &smithy.DeserializationError{ 2311 Err: fmt.Errorf("failed to decode response body, %w", err), 2312 Snapshot: snapshot.Bytes(), 2313 } 2314 return out, metadata, err 2315 } 2316 2317 return out, metadata, err 2318} 2319 2320func awsAwsjson11_deserializeOpErrorListProblems(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2321 var errorBuffer bytes.Buffer 2322 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2323 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2324 } 2325 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2326 2327 errorCode := "UnknownError" 2328 errorMessage := errorCode 2329 2330 code := response.Header.Get("X-Amzn-ErrorType") 2331 if len(code) != 0 { 2332 errorCode = restjson.SanitizeErrorCode(code) 2333 } 2334 2335 var buff [1024]byte 2336 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2337 2338 body := io.TeeReader(errorBody, ringBuffer) 2339 decoder := json.NewDecoder(body) 2340 decoder.UseNumber() 2341 code, message, err := restjson.GetErrorInfo(decoder) 2342 if err != nil { 2343 var snapshot bytes.Buffer 2344 io.Copy(&snapshot, ringBuffer) 2345 err = &smithy.DeserializationError{ 2346 Err: fmt.Errorf("failed to decode response body, %w", err), 2347 Snapshot: snapshot.Bytes(), 2348 } 2349 return err 2350 } 2351 2352 errorBody.Seek(0, io.SeekStart) 2353 if len(code) != 0 { 2354 errorCode = restjson.SanitizeErrorCode(code) 2355 } 2356 if len(message) != 0 { 2357 errorMessage = message 2358 } 2359 2360 switch { 2361 case strings.EqualFold("InternalServerException", errorCode): 2362 return awsAwsjson11_deserializeErrorInternalServerException(response, errorBody) 2363 2364 case strings.EqualFold("ResourceNotFoundException", errorCode): 2365 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 2366 2367 case strings.EqualFold("ValidationException", errorCode): 2368 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 2369 2370 default: 2371 genericError := &smithy.GenericAPIError{ 2372 Code: errorCode, 2373 Message: errorMessage, 2374 } 2375 return genericError 2376 2377 } 2378} 2379 2380type awsAwsjson11_deserializeOpListTagsForResource struct { 2381} 2382 2383func (*awsAwsjson11_deserializeOpListTagsForResource) ID() string { 2384 return "OperationDeserializer" 2385} 2386 2387func (m *awsAwsjson11_deserializeOpListTagsForResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2388 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2389) { 2390 out, metadata, err = next.HandleDeserialize(ctx, in) 2391 if err != nil { 2392 return out, metadata, err 2393 } 2394 2395 response, ok := out.RawResponse.(*smithyhttp.Response) 2396 if !ok { 2397 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2398 } 2399 2400 if response.StatusCode < 200 || response.StatusCode >= 300 { 2401 return out, metadata, awsAwsjson11_deserializeOpErrorListTagsForResource(response, &metadata) 2402 } 2403 output := &ListTagsForResourceOutput{} 2404 out.Result = output 2405 2406 var buff [1024]byte 2407 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2408 2409 body := io.TeeReader(response.Body, ringBuffer) 2410 decoder := json.NewDecoder(body) 2411 decoder.UseNumber() 2412 var shape interface{} 2413 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2414 var snapshot bytes.Buffer 2415 io.Copy(&snapshot, ringBuffer) 2416 err = &smithy.DeserializationError{ 2417 Err: fmt.Errorf("failed to decode response body, %w", err), 2418 Snapshot: snapshot.Bytes(), 2419 } 2420 return out, metadata, err 2421 } 2422 2423 err = awsAwsjson11_deserializeOpDocumentListTagsForResourceOutput(&output, shape) 2424 if err != nil { 2425 var snapshot bytes.Buffer 2426 io.Copy(&snapshot, ringBuffer) 2427 err = &smithy.DeserializationError{ 2428 Err: fmt.Errorf("failed to decode response body, %w", err), 2429 Snapshot: snapshot.Bytes(), 2430 } 2431 return out, metadata, err 2432 } 2433 2434 return out, metadata, err 2435} 2436 2437func awsAwsjson11_deserializeOpErrorListTagsForResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2438 var errorBuffer bytes.Buffer 2439 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2440 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2441 } 2442 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2443 2444 errorCode := "UnknownError" 2445 errorMessage := errorCode 2446 2447 code := response.Header.Get("X-Amzn-ErrorType") 2448 if len(code) != 0 { 2449 errorCode = restjson.SanitizeErrorCode(code) 2450 } 2451 2452 var buff [1024]byte 2453 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2454 2455 body := io.TeeReader(errorBody, ringBuffer) 2456 decoder := json.NewDecoder(body) 2457 decoder.UseNumber() 2458 code, message, err := restjson.GetErrorInfo(decoder) 2459 if err != nil { 2460 var snapshot bytes.Buffer 2461 io.Copy(&snapshot, ringBuffer) 2462 err = &smithy.DeserializationError{ 2463 Err: fmt.Errorf("failed to decode response body, %w", err), 2464 Snapshot: snapshot.Bytes(), 2465 } 2466 return err 2467 } 2468 2469 errorBody.Seek(0, io.SeekStart) 2470 if len(code) != 0 { 2471 errorCode = restjson.SanitizeErrorCode(code) 2472 } 2473 if len(message) != 0 { 2474 errorMessage = message 2475 } 2476 2477 switch { 2478 case strings.EqualFold("ResourceNotFoundException", errorCode): 2479 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 2480 2481 case strings.EqualFold("ValidationException", errorCode): 2482 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 2483 2484 default: 2485 genericError := &smithy.GenericAPIError{ 2486 Code: errorCode, 2487 Message: errorMessage, 2488 } 2489 return genericError 2490 2491 } 2492} 2493 2494type awsAwsjson11_deserializeOpTagResource struct { 2495} 2496 2497func (*awsAwsjson11_deserializeOpTagResource) ID() string { 2498 return "OperationDeserializer" 2499} 2500 2501func (m *awsAwsjson11_deserializeOpTagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2502 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2503) { 2504 out, metadata, err = next.HandleDeserialize(ctx, in) 2505 if err != nil { 2506 return out, metadata, err 2507 } 2508 2509 response, ok := out.RawResponse.(*smithyhttp.Response) 2510 if !ok { 2511 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2512 } 2513 2514 if response.StatusCode < 200 || response.StatusCode >= 300 { 2515 return out, metadata, awsAwsjson11_deserializeOpErrorTagResource(response, &metadata) 2516 } 2517 output := &TagResourceOutput{} 2518 out.Result = output 2519 2520 var buff [1024]byte 2521 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2522 2523 body := io.TeeReader(response.Body, ringBuffer) 2524 decoder := json.NewDecoder(body) 2525 decoder.UseNumber() 2526 var shape interface{} 2527 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2528 var snapshot bytes.Buffer 2529 io.Copy(&snapshot, ringBuffer) 2530 err = &smithy.DeserializationError{ 2531 Err: fmt.Errorf("failed to decode response body, %w", err), 2532 Snapshot: snapshot.Bytes(), 2533 } 2534 return out, metadata, err 2535 } 2536 2537 err = awsAwsjson11_deserializeOpDocumentTagResourceOutput(&output, shape) 2538 if err != nil { 2539 var snapshot bytes.Buffer 2540 io.Copy(&snapshot, ringBuffer) 2541 err = &smithy.DeserializationError{ 2542 Err: fmt.Errorf("failed to decode response body, %w", err), 2543 Snapshot: snapshot.Bytes(), 2544 } 2545 return out, metadata, err 2546 } 2547 2548 return out, metadata, err 2549} 2550 2551func awsAwsjson11_deserializeOpErrorTagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2552 var errorBuffer bytes.Buffer 2553 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2554 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2555 } 2556 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2557 2558 errorCode := "UnknownError" 2559 errorMessage := errorCode 2560 2561 code := response.Header.Get("X-Amzn-ErrorType") 2562 if len(code) != 0 { 2563 errorCode = restjson.SanitizeErrorCode(code) 2564 } 2565 2566 var buff [1024]byte 2567 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2568 2569 body := io.TeeReader(errorBody, ringBuffer) 2570 decoder := json.NewDecoder(body) 2571 decoder.UseNumber() 2572 code, message, err := restjson.GetErrorInfo(decoder) 2573 if err != nil { 2574 var snapshot bytes.Buffer 2575 io.Copy(&snapshot, ringBuffer) 2576 err = &smithy.DeserializationError{ 2577 Err: fmt.Errorf("failed to decode response body, %w", err), 2578 Snapshot: snapshot.Bytes(), 2579 } 2580 return err 2581 } 2582 2583 errorBody.Seek(0, io.SeekStart) 2584 if len(code) != 0 { 2585 errorCode = restjson.SanitizeErrorCode(code) 2586 } 2587 if len(message) != 0 { 2588 errorMessage = message 2589 } 2590 2591 switch { 2592 case strings.EqualFold("ResourceNotFoundException", errorCode): 2593 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 2594 2595 case strings.EqualFold("TooManyTagsException", errorCode): 2596 return awsAwsjson11_deserializeErrorTooManyTagsException(response, errorBody) 2597 2598 case strings.EqualFold("ValidationException", errorCode): 2599 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 2600 2601 default: 2602 genericError := &smithy.GenericAPIError{ 2603 Code: errorCode, 2604 Message: errorMessage, 2605 } 2606 return genericError 2607 2608 } 2609} 2610 2611type awsAwsjson11_deserializeOpUntagResource struct { 2612} 2613 2614func (*awsAwsjson11_deserializeOpUntagResource) ID() string { 2615 return "OperationDeserializer" 2616} 2617 2618func (m *awsAwsjson11_deserializeOpUntagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2619 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2620) { 2621 out, metadata, err = next.HandleDeserialize(ctx, in) 2622 if err != nil { 2623 return out, metadata, err 2624 } 2625 2626 response, ok := out.RawResponse.(*smithyhttp.Response) 2627 if !ok { 2628 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2629 } 2630 2631 if response.StatusCode < 200 || response.StatusCode >= 300 { 2632 return out, metadata, awsAwsjson11_deserializeOpErrorUntagResource(response, &metadata) 2633 } 2634 output := &UntagResourceOutput{} 2635 out.Result = output 2636 2637 var buff [1024]byte 2638 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2639 2640 body := io.TeeReader(response.Body, ringBuffer) 2641 decoder := json.NewDecoder(body) 2642 decoder.UseNumber() 2643 var shape interface{} 2644 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2645 var snapshot bytes.Buffer 2646 io.Copy(&snapshot, ringBuffer) 2647 err = &smithy.DeserializationError{ 2648 Err: fmt.Errorf("failed to decode response body, %w", err), 2649 Snapshot: snapshot.Bytes(), 2650 } 2651 return out, metadata, err 2652 } 2653 2654 err = awsAwsjson11_deserializeOpDocumentUntagResourceOutput(&output, shape) 2655 if err != nil { 2656 var snapshot bytes.Buffer 2657 io.Copy(&snapshot, ringBuffer) 2658 err = &smithy.DeserializationError{ 2659 Err: fmt.Errorf("failed to decode response body, %w", err), 2660 Snapshot: snapshot.Bytes(), 2661 } 2662 return out, metadata, err 2663 } 2664 2665 return out, metadata, err 2666} 2667 2668func awsAwsjson11_deserializeOpErrorUntagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2669 var errorBuffer bytes.Buffer 2670 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2671 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2672 } 2673 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2674 2675 errorCode := "UnknownError" 2676 errorMessage := errorCode 2677 2678 code := response.Header.Get("X-Amzn-ErrorType") 2679 if len(code) != 0 { 2680 errorCode = restjson.SanitizeErrorCode(code) 2681 } 2682 2683 var buff [1024]byte 2684 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2685 2686 body := io.TeeReader(errorBody, ringBuffer) 2687 decoder := json.NewDecoder(body) 2688 decoder.UseNumber() 2689 code, message, err := restjson.GetErrorInfo(decoder) 2690 if err != nil { 2691 var snapshot bytes.Buffer 2692 io.Copy(&snapshot, ringBuffer) 2693 err = &smithy.DeserializationError{ 2694 Err: fmt.Errorf("failed to decode response body, %w", err), 2695 Snapshot: snapshot.Bytes(), 2696 } 2697 return err 2698 } 2699 2700 errorBody.Seek(0, io.SeekStart) 2701 if len(code) != 0 { 2702 errorCode = restjson.SanitizeErrorCode(code) 2703 } 2704 if len(message) != 0 { 2705 errorMessage = message 2706 } 2707 2708 switch { 2709 case strings.EqualFold("ResourceNotFoundException", errorCode): 2710 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 2711 2712 case strings.EqualFold("ValidationException", errorCode): 2713 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 2714 2715 default: 2716 genericError := &smithy.GenericAPIError{ 2717 Code: errorCode, 2718 Message: errorMessage, 2719 } 2720 return genericError 2721 2722 } 2723} 2724 2725type awsAwsjson11_deserializeOpUpdateApplication struct { 2726} 2727 2728func (*awsAwsjson11_deserializeOpUpdateApplication) ID() string { 2729 return "OperationDeserializer" 2730} 2731 2732func (m *awsAwsjson11_deserializeOpUpdateApplication) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2733 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2734) { 2735 out, metadata, err = next.HandleDeserialize(ctx, in) 2736 if err != nil { 2737 return out, metadata, err 2738 } 2739 2740 response, ok := out.RawResponse.(*smithyhttp.Response) 2741 if !ok { 2742 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2743 } 2744 2745 if response.StatusCode < 200 || response.StatusCode >= 300 { 2746 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateApplication(response, &metadata) 2747 } 2748 output := &UpdateApplicationOutput{} 2749 out.Result = output 2750 2751 var buff [1024]byte 2752 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2753 2754 body := io.TeeReader(response.Body, ringBuffer) 2755 decoder := json.NewDecoder(body) 2756 decoder.UseNumber() 2757 var shape interface{} 2758 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2759 var snapshot bytes.Buffer 2760 io.Copy(&snapshot, ringBuffer) 2761 err = &smithy.DeserializationError{ 2762 Err: fmt.Errorf("failed to decode response body, %w", err), 2763 Snapshot: snapshot.Bytes(), 2764 } 2765 return out, metadata, err 2766 } 2767 2768 err = awsAwsjson11_deserializeOpDocumentUpdateApplicationOutput(&output, shape) 2769 if err != nil { 2770 var snapshot bytes.Buffer 2771 io.Copy(&snapshot, ringBuffer) 2772 err = &smithy.DeserializationError{ 2773 Err: fmt.Errorf("failed to decode response body, %w", err), 2774 Snapshot: snapshot.Bytes(), 2775 } 2776 return out, metadata, err 2777 } 2778 2779 return out, metadata, err 2780} 2781 2782func awsAwsjson11_deserializeOpErrorUpdateApplication(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2783 var errorBuffer bytes.Buffer 2784 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2785 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2786 } 2787 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2788 2789 errorCode := "UnknownError" 2790 errorMessage := errorCode 2791 2792 code := response.Header.Get("X-Amzn-ErrorType") 2793 if len(code) != 0 { 2794 errorCode = restjson.SanitizeErrorCode(code) 2795 } 2796 2797 var buff [1024]byte 2798 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2799 2800 body := io.TeeReader(errorBody, ringBuffer) 2801 decoder := json.NewDecoder(body) 2802 decoder.UseNumber() 2803 code, message, err := restjson.GetErrorInfo(decoder) 2804 if err != nil { 2805 var snapshot bytes.Buffer 2806 io.Copy(&snapshot, ringBuffer) 2807 err = &smithy.DeserializationError{ 2808 Err: fmt.Errorf("failed to decode response body, %w", err), 2809 Snapshot: snapshot.Bytes(), 2810 } 2811 return err 2812 } 2813 2814 errorBody.Seek(0, io.SeekStart) 2815 if len(code) != 0 { 2816 errorCode = restjson.SanitizeErrorCode(code) 2817 } 2818 if len(message) != 0 { 2819 errorMessage = message 2820 } 2821 2822 switch { 2823 case strings.EqualFold("InternalServerException", errorCode): 2824 return awsAwsjson11_deserializeErrorInternalServerException(response, errorBody) 2825 2826 case strings.EqualFold("ResourceNotFoundException", errorCode): 2827 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 2828 2829 case strings.EqualFold("ValidationException", errorCode): 2830 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 2831 2832 default: 2833 genericError := &smithy.GenericAPIError{ 2834 Code: errorCode, 2835 Message: errorMessage, 2836 } 2837 return genericError 2838 2839 } 2840} 2841 2842type awsAwsjson11_deserializeOpUpdateComponent struct { 2843} 2844 2845func (*awsAwsjson11_deserializeOpUpdateComponent) ID() string { 2846 return "OperationDeserializer" 2847} 2848 2849func (m *awsAwsjson11_deserializeOpUpdateComponent) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2850 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2851) { 2852 out, metadata, err = next.HandleDeserialize(ctx, in) 2853 if err != nil { 2854 return out, metadata, err 2855 } 2856 2857 response, ok := out.RawResponse.(*smithyhttp.Response) 2858 if !ok { 2859 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2860 } 2861 2862 if response.StatusCode < 200 || response.StatusCode >= 300 { 2863 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateComponent(response, &metadata) 2864 } 2865 output := &UpdateComponentOutput{} 2866 out.Result = output 2867 2868 var buff [1024]byte 2869 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2870 2871 body := io.TeeReader(response.Body, ringBuffer) 2872 decoder := json.NewDecoder(body) 2873 decoder.UseNumber() 2874 var shape interface{} 2875 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2876 var snapshot bytes.Buffer 2877 io.Copy(&snapshot, ringBuffer) 2878 err = &smithy.DeserializationError{ 2879 Err: fmt.Errorf("failed to decode response body, %w", err), 2880 Snapshot: snapshot.Bytes(), 2881 } 2882 return out, metadata, err 2883 } 2884 2885 err = awsAwsjson11_deserializeOpDocumentUpdateComponentOutput(&output, shape) 2886 if err != nil { 2887 var snapshot bytes.Buffer 2888 io.Copy(&snapshot, ringBuffer) 2889 err = &smithy.DeserializationError{ 2890 Err: fmt.Errorf("failed to decode response body, %w", err), 2891 Snapshot: snapshot.Bytes(), 2892 } 2893 return out, metadata, err 2894 } 2895 2896 return out, metadata, err 2897} 2898 2899func awsAwsjson11_deserializeOpErrorUpdateComponent(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2900 var errorBuffer bytes.Buffer 2901 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2902 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2903 } 2904 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2905 2906 errorCode := "UnknownError" 2907 errorMessage := errorCode 2908 2909 code := response.Header.Get("X-Amzn-ErrorType") 2910 if len(code) != 0 { 2911 errorCode = restjson.SanitizeErrorCode(code) 2912 } 2913 2914 var buff [1024]byte 2915 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2916 2917 body := io.TeeReader(errorBody, ringBuffer) 2918 decoder := json.NewDecoder(body) 2919 decoder.UseNumber() 2920 code, message, err := restjson.GetErrorInfo(decoder) 2921 if err != nil { 2922 var snapshot bytes.Buffer 2923 io.Copy(&snapshot, ringBuffer) 2924 err = &smithy.DeserializationError{ 2925 Err: fmt.Errorf("failed to decode response body, %w", err), 2926 Snapshot: snapshot.Bytes(), 2927 } 2928 return err 2929 } 2930 2931 errorBody.Seek(0, io.SeekStart) 2932 if len(code) != 0 { 2933 errorCode = restjson.SanitizeErrorCode(code) 2934 } 2935 if len(message) != 0 { 2936 errorMessage = message 2937 } 2938 2939 switch { 2940 case strings.EqualFold("InternalServerException", errorCode): 2941 return awsAwsjson11_deserializeErrorInternalServerException(response, errorBody) 2942 2943 case strings.EqualFold("ResourceInUseException", errorCode): 2944 return awsAwsjson11_deserializeErrorResourceInUseException(response, errorBody) 2945 2946 case strings.EqualFold("ResourceNotFoundException", errorCode): 2947 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 2948 2949 case strings.EqualFold("ValidationException", errorCode): 2950 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 2951 2952 default: 2953 genericError := &smithy.GenericAPIError{ 2954 Code: errorCode, 2955 Message: errorMessage, 2956 } 2957 return genericError 2958 2959 } 2960} 2961 2962type awsAwsjson11_deserializeOpUpdateComponentConfiguration struct { 2963} 2964 2965func (*awsAwsjson11_deserializeOpUpdateComponentConfiguration) ID() string { 2966 return "OperationDeserializer" 2967} 2968 2969func (m *awsAwsjson11_deserializeOpUpdateComponentConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2970 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2971) { 2972 out, metadata, err = next.HandleDeserialize(ctx, in) 2973 if err != nil { 2974 return out, metadata, err 2975 } 2976 2977 response, ok := out.RawResponse.(*smithyhttp.Response) 2978 if !ok { 2979 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2980 } 2981 2982 if response.StatusCode < 200 || response.StatusCode >= 300 { 2983 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateComponentConfiguration(response, &metadata) 2984 } 2985 output := &UpdateComponentConfigurationOutput{} 2986 out.Result = output 2987 2988 var buff [1024]byte 2989 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2990 2991 body := io.TeeReader(response.Body, ringBuffer) 2992 decoder := json.NewDecoder(body) 2993 decoder.UseNumber() 2994 var shape interface{} 2995 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2996 var snapshot bytes.Buffer 2997 io.Copy(&snapshot, ringBuffer) 2998 err = &smithy.DeserializationError{ 2999 Err: fmt.Errorf("failed to decode response body, %w", err), 3000 Snapshot: snapshot.Bytes(), 3001 } 3002 return out, metadata, err 3003 } 3004 3005 err = awsAwsjson11_deserializeOpDocumentUpdateComponentConfigurationOutput(&output, shape) 3006 if err != nil { 3007 var snapshot bytes.Buffer 3008 io.Copy(&snapshot, ringBuffer) 3009 err = &smithy.DeserializationError{ 3010 Err: fmt.Errorf("failed to decode response body, %w", err), 3011 Snapshot: snapshot.Bytes(), 3012 } 3013 return out, metadata, err 3014 } 3015 3016 return out, metadata, err 3017} 3018 3019func awsAwsjson11_deserializeOpErrorUpdateComponentConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3020 var errorBuffer bytes.Buffer 3021 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3022 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3023 } 3024 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3025 3026 errorCode := "UnknownError" 3027 errorMessage := errorCode 3028 3029 code := response.Header.Get("X-Amzn-ErrorType") 3030 if len(code) != 0 { 3031 errorCode = restjson.SanitizeErrorCode(code) 3032 } 3033 3034 var buff [1024]byte 3035 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3036 3037 body := io.TeeReader(errorBody, ringBuffer) 3038 decoder := json.NewDecoder(body) 3039 decoder.UseNumber() 3040 code, message, err := restjson.GetErrorInfo(decoder) 3041 if err != nil { 3042 var snapshot bytes.Buffer 3043 io.Copy(&snapshot, ringBuffer) 3044 err = &smithy.DeserializationError{ 3045 Err: fmt.Errorf("failed to decode response body, %w", err), 3046 Snapshot: snapshot.Bytes(), 3047 } 3048 return err 3049 } 3050 3051 errorBody.Seek(0, io.SeekStart) 3052 if len(code) != 0 { 3053 errorCode = restjson.SanitizeErrorCode(code) 3054 } 3055 if len(message) != 0 { 3056 errorMessage = message 3057 } 3058 3059 switch { 3060 case strings.EqualFold("InternalServerException", errorCode): 3061 return awsAwsjson11_deserializeErrorInternalServerException(response, errorBody) 3062 3063 case strings.EqualFold("ResourceNotFoundException", errorCode): 3064 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 3065 3066 case strings.EqualFold("ValidationException", errorCode): 3067 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 3068 3069 default: 3070 genericError := &smithy.GenericAPIError{ 3071 Code: errorCode, 3072 Message: errorMessage, 3073 } 3074 return genericError 3075 3076 } 3077} 3078 3079type awsAwsjson11_deserializeOpUpdateLogPattern struct { 3080} 3081 3082func (*awsAwsjson11_deserializeOpUpdateLogPattern) ID() string { 3083 return "OperationDeserializer" 3084} 3085 3086func (m *awsAwsjson11_deserializeOpUpdateLogPattern) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3087 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3088) { 3089 out, metadata, err = next.HandleDeserialize(ctx, in) 3090 if err != nil { 3091 return out, metadata, err 3092 } 3093 3094 response, ok := out.RawResponse.(*smithyhttp.Response) 3095 if !ok { 3096 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3097 } 3098 3099 if response.StatusCode < 200 || response.StatusCode >= 300 { 3100 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateLogPattern(response, &metadata) 3101 } 3102 output := &UpdateLogPatternOutput{} 3103 out.Result = output 3104 3105 var buff [1024]byte 3106 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3107 3108 body := io.TeeReader(response.Body, ringBuffer) 3109 decoder := json.NewDecoder(body) 3110 decoder.UseNumber() 3111 var shape interface{} 3112 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3113 var snapshot bytes.Buffer 3114 io.Copy(&snapshot, ringBuffer) 3115 err = &smithy.DeserializationError{ 3116 Err: fmt.Errorf("failed to decode response body, %w", err), 3117 Snapshot: snapshot.Bytes(), 3118 } 3119 return out, metadata, err 3120 } 3121 3122 err = awsAwsjson11_deserializeOpDocumentUpdateLogPatternOutput(&output, shape) 3123 if err != nil { 3124 var snapshot bytes.Buffer 3125 io.Copy(&snapshot, ringBuffer) 3126 err = &smithy.DeserializationError{ 3127 Err: fmt.Errorf("failed to decode response body, %w", err), 3128 Snapshot: snapshot.Bytes(), 3129 } 3130 return out, metadata, err 3131 } 3132 3133 return out, metadata, err 3134} 3135 3136func awsAwsjson11_deserializeOpErrorUpdateLogPattern(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3137 var errorBuffer bytes.Buffer 3138 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3139 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3140 } 3141 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3142 3143 errorCode := "UnknownError" 3144 errorMessage := errorCode 3145 3146 code := response.Header.Get("X-Amzn-ErrorType") 3147 if len(code) != 0 { 3148 errorCode = restjson.SanitizeErrorCode(code) 3149 } 3150 3151 var buff [1024]byte 3152 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3153 3154 body := io.TeeReader(errorBody, ringBuffer) 3155 decoder := json.NewDecoder(body) 3156 decoder.UseNumber() 3157 code, message, err := restjson.GetErrorInfo(decoder) 3158 if err != nil { 3159 var snapshot bytes.Buffer 3160 io.Copy(&snapshot, ringBuffer) 3161 err = &smithy.DeserializationError{ 3162 Err: fmt.Errorf("failed to decode response body, %w", err), 3163 Snapshot: snapshot.Bytes(), 3164 } 3165 return err 3166 } 3167 3168 errorBody.Seek(0, io.SeekStart) 3169 if len(code) != 0 { 3170 errorCode = restjson.SanitizeErrorCode(code) 3171 } 3172 if len(message) != 0 { 3173 errorMessage = message 3174 } 3175 3176 switch { 3177 case strings.EqualFold("InternalServerException", errorCode): 3178 return awsAwsjson11_deserializeErrorInternalServerException(response, errorBody) 3179 3180 case strings.EqualFold("ResourceInUseException", errorCode): 3181 return awsAwsjson11_deserializeErrorResourceInUseException(response, errorBody) 3182 3183 case strings.EqualFold("ResourceNotFoundException", errorCode): 3184 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 3185 3186 case strings.EqualFold("ValidationException", errorCode): 3187 return awsAwsjson11_deserializeErrorValidationException(response, errorBody) 3188 3189 default: 3190 genericError := &smithy.GenericAPIError{ 3191 Code: errorCode, 3192 Message: errorMessage, 3193 } 3194 return genericError 3195 3196 } 3197} 3198 3199func awsAwsjson11_deserializeErrorAccessDeniedException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 3200 var buff [1024]byte 3201 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3202 3203 body := io.TeeReader(errorBody, ringBuffer) 3204 decoder := json.NewDecoder(body) 3205 decoder.UseNumber() 3206 var shape interface{} 3207 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3208 var snapshot bytes.Buffer 3209 io.Copy(&snapshot, ringBuffer) 3210 err = &smithy.DeserializationError{ 3211 Err: fmt.Errorf("failed to decode response body, %w", err), 3212 Snapshot: snapshot.Bytes(), 3213 } 3214 return err 3215 } 3216 3217 output := &types.AccessDeniedException{} 3218 err := awsAwsjson11_deserializeDocumentAccessDeniedException(&output, shape) 3219 3220 if err != nil { 3221 var snapshot bytes.Buffer 3222 io.Copy(&snapshot, ringBuffer) 3223 err = &smithy.DeserializationError{ 3224 Err: fmt.Errorf("failed to decode response body, %w", err), 3225 Snapshot: snapshot.Bytes(), 3226 } 3227 return err 3228 } 3229 3230 errorBody.Seek(0, io.SeekStart) 3231 return output 3232} 3233 3234func awsAwsjson11_deserializeErrorBadRequestException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 3235 var buff [1024]byte 3236 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3237 3238 body := io.TeeReader(errorBody, ringBuffer) 3239 decoder := json.NewDecoder(body) 3240 decoder.UseNumber() 3241 var shape interface{} 3242 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3243 var snapshot bytes.Buffer 3244 io.Copy(&snapshot, ringBuffer) 3245 err = &smithy.DeserializationError{ 3246 Err: fmt.Errorf("failed to decode response body, %w", err), 3247 Snapshot: snapshot.Bytes(), 3248 } 3249 return err 3250 } 3251 3252 output := &types.BadRequestException{} 3253 err := awsAwsjson11_deserializeDocumentBadRequestException(&output, shape) 3254 3255 if err != nil { 3256 var snapshot bytes.Buffer 3257 io.Copy(&snapshot, ringBuffer) 3258 err = &smithy.DeserializationError{ 3259 Err: fmt.Errorf("failed to decode response body, %w", err), 3260 Snapshot: snapshot.Bytes(), 3261 } 3262 return err 3263 } 3264 3265 errorBody.Seek(0, io.SeekStart) 3266 return output 3267} 3268 3269func awsAwsjson11_deserializeErrorInternalServerException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 3270 var buff [1024]byte 3271 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3272 3273 body := io.TeeReader(errorBody, ringBuffer) 3274 decoder := json.NewDecoder(body) 3275 decoder.UseNumber() 3276 var shape interface{} 3277 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3278 var snapshot bytes.Buffer 3279 io.Copy(&snapshot, ringBuffer) 3280 err = &smithy.DeserializationError{ 3281 Err: fmt.Errorf("failed to decode response body, %w", err), 3282 Snapshot: snapshot.Bytes(), 3283 } 3284 return err 3285 } 3286 3287 output := &types.InternalServerException{} 3288 err := awsAwsjson11_deserializeDocumentInternalServerException(&output, shape) 3289 3290 if err != nil { 3291 var snapshot bytes.Buffer 3292 io.Copy(&snapshot, ringBuffer) 3293 err = &smithy.DeserializationError{ 3294 Err: fmt.Errorf("failed to decode response body, %w", err), 3295 Snapshot: snapshot.Bytes(), 3296 } 3297 return err 3298 } 3299 3300 errorBody.Seek(0, io.SeekStart) 3301 return output 3302} 3303 3304func awsAwsjson11_deserializeErrorResourceInUseException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 3305 var buff [1024]byte 3306 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3307 3308 body := io.TeeReader(errorBody, ringBuffer) 3309 decoder := json.NewDecoder(body) 3310 decoder.UseNumber() 3311 var shape interface{} 3312 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3313 var snapshot bytes.Buffer 3314 io.Copy(&snapshot, ringBuffer) 3315 err = &smithy.DeserializationError{ 3316 Err: fmt.Errorf("failed to decode response body, %w", err), 3317 Snapshot: snapshot.Bytes(), 3318 } 3319 return err 3320 } 3321 3322 output := &types.ResourceInUseException{} 3323 err := awsAwsjson11_deserializeDocumentResourceInUseException(&output, shape) 3324 3325 if err != nil { 3326 var snapshot bytes.Buffer 3327 io.Copy(&snapshot, ringBuffer) 3328 err = &smithy.DeserializationError{ 3329 Err: fmt.Errorf("failed to decode response body, %w", err), 3330 Snapshot: snapshot.Bytes(), 3331 } 3332 return err 3333 } 3334 3335 errorBody.Seek(0, io.SeekStart) 3336 return output 3337} 3338 3339func awsAwsjson11_deserializeErrorResourceNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 3340 var buff [1024]byte 3341 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3342 3343 body := io.TeeReader(errorBody, ringBuffer) 3344 decoder := json.NewDecoder(body) 3345 decoder.UseNumber() 3346 var shape interface{} 3347 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3348 var snapshot bytes.Buffer 3349 io.Copy(&snapshot, ringBuffer) 3350 err = &smithy.DeserializationError{ 3351 Err: fmt.Errorf("failed to decode response body, %w", err), 3352 Snapshot: snapshot.Bytes(), 3353 } 3354 return err 3355 } 3356 3357 output := &types.ResourceNotFoundException{} 3358 err := awsAwsjson11_deserializeDocumentResourceNotFoundException(&output, shape) 3359 3360 if err != nil { 3361 var snapshot bytes.Buffer 3362 io.Copy(&snapshot, ringBuffer) 3363 err = &smithy.DeserializationError{ 3364 Err: fmt.Errorf("failed to decode response body, %w", err), 3365 Snapshot: snapshot.Bytes(), 3366 } 3367 return err 3368 } 3369 3370 errorBody.Seek(0, io.SeekStart) 3371 return output 3372} 3373 3374func awsAwsjson11_deserializeErrorTagsAlreadyExistException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 3375 var buff [1024]byte 3376 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3377 3378 body := io.TeeReader(errorBody, ringBuffer) 3379 decoder := json.NewDecoder(body) 3380 decoder.UseNumber() 3381 var shape interface{} 3382 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3383 var snapshot bytes.Buffer 3384 io.Copy(&snapshot, ringBuffer) 3385 err = &smithy.DeserializationError{ 3386 Err: fmt.Errorf("failed to decode response body, %w", err), 3387 Snapshot: snapshot.Bytes(), 3388 } 3389 return err 3390 } 3391 3392 output := &types.TagsAlreadyExistException{} 3393 err := awsAwsjson11_deserializeDocumentTagsAlreadyExistException(&output, shape) 3394 3395 if err != nil { 3396 var snapshot bytes.Buffer 3397 io.Copy(&snapshot, ringBuffer) 3398 err = &smithy.DeserializationError{ 3399 Err: fmt.Errorf("failed to decode response body, %w", err), 3400 Snapshot: snapshot.Bytes(), 3401 } 3402 return err 3403 } 3404 3405 errorBody.Seek(0, io.SeekStart) 3406 return output 3407} 3408 3409func awsAwsjson11_deserializeErrorTooManyTagsException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 3410 var buff [1024]byte 3411 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3412 3413 body := io.TeeReader(errorBody, ringBuffer) 3414 decoder := json.NewDecoder(body) 3415 decoder.UseNumber() 3416 var shape interface{} 3417 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3418 var snapshot bytes.Buffer 3419 io.Copy(&snapshot, ringBuffer) 3420 err = &smithy.DeserializationError{ 3421 Err: fmt.Errorf("failed to decode response body, %w", err), 3422 Snapshot: snapshot.Bytes(), 3423 } 3424 return err 3425 } 3426 3427 output := &types.TooManyTagsException{} 3428 err := awsAwsjson11_deserializeDocumentTooManyTagsException(&output, shape) 3429 3430 if err != nil { 3431 var snapshot bytes.Buffer 3432 io.Copy(&snapshot, ringBuffer) 3433 err = &smithy.DeserializationError{ 3434 Err: fmt.Errorf("failed to decode response body, %w", err), 3435 Snapshot: snapshot.Bytes(), 3436 } 3437 return err 3438 } 3439 3440 errorBody.Seek(0, io.SeekStart) 3441 return output 3442} 3443 3444func awsAwsjson11_deserializeErrorValidationException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 3445 var buff [1024]byte 3446 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3447 3448 body := io.TeeReader(errorBody, ringBuffer) 3449 decoder := json.NewDecoder(body) 3450 decoder.UseNumber() 3451 var shape interface{} 3452 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3453 var snapshot bytes.Buffer 3454 io.Copy(&snapshot, ringBuffer) 3455 err = &smithy.DeserializationError{ 3456 Err: fmt.Errorf("failed to decode response body, %w", err), 3457 Snapshot: snapshot.Bytes(), 3458 } 3459 return err 3460 } 3461 3462 output := &types.ValidationException{} 3463 err := awsAwsjson11_deserializeDocumentValidationException(&output, shape) 3464 3465 if err != nil { 3466 var snapshot bytes.Buffer 3467 io.Copy(&snapshot, ringBuffer) 3468 err = &smithy.DeserializationError{ 3469 Err: fmt.Errorf("failed to decode response body, %w", err), 3470 Snapshot: snapshot.Bytes(), 3471 } 3472 return err 3473 } 3474 3475 errorBody.Seek(0, io.SeekStart) 3476 return output 3477} 3478 3479func awsAwsjson11_deserializeDocumentAccessDeniedException(v **types.AccessDeniedException, value interface{}) error { 3480 if v == nil { 3481 return fmt.Errorf("unexpected nil of type %T", v) 3482 } 3483 if value == nil { 3484 return nil 3485 } 3486 3487 shape, ok := value.(map[string]interface{}) 3488 if !ok { 3489 return fmt.Errorf("unexpected JSON type %v", value) 3490 } 3491 3492 var sv *types.AccessDeniedException 3493 if *v == nil { 3494 sv = &types.AccessDeniedException{} 3495 } else { 3496 sv = *v 3497 } 3498 3499 for key, value := range shape { 3500 switch key { 3501 case "Message": 3502 if value != nil { 3503 jtv, ok := value.(string) 3504 if !ok { 3505 return fmt.Errorf("expected ErrorMsg to be of type string, got %T instead", value) 3506 } 3507 sv.Message = ptr.String(jtv) 3508 } 3509 3510 default: 3511 _, _ = key, value 3512 3513 } 3514 } 3515 *v = sv 3516 return nil 3517} 3518 3519func awsAwsjson11_deserializeDocumentApplicationComponent(v **types.ApplicationComponent, value interface{}) error { 3520 if v == nil { 3521 return fmt.Errorf("unexpected nil of type %T", v) 3522 } 3523 if value == nil { 3524 return nil 3525 } 3526 3527 shape, ok := value.(map[string]interface{}) 3528 if !ok { 3529 return fmt.Errorf("unexpected JSON type %v", value) 3530 } 3531 3532 var sv *types.ApplicationComponent 3533 if *v == nil { 3534 sv = &types.ApplicationComponent{} 3535 } else { 3536 sv = *v 3537 } 3538 3539 for key, value := range shape { 3540 switch key { 3541 case "ComponentName": 3542 if value != nil { 3543 jtv, ok := value.(string) 3544 if !ok { 3545 return fmt.Errorf("expected ComponentName to be of type string, got %T instead", value) 3546 } 3547 sv.ComponentName = ptr.String(jtv) 3548 } 3549 3550 case "ComponentRemarks": 3551 if value != nil { 3552 jtv, ok := value.(string) 3553 if !ok { 3554 return fmt.Errorf("expected Remarks to be of type string, got %T instead", value) 3555 } 3556 sv.ComponentRemarks = ptr.String(jtv) 3557 } 3558 3559 case "DetectedWorkload": 3560 if err := awsAwsjson11_deserializeDocumentDetectedWorkload(&sv.DetectedWorkload, value); err != nil { 3561 return err 3562 } 3563 3564 case "Monitor": 3565 if value != nil { 3566 jtv, ok := value.(bool) 3567 if !ok { 3568 return fmt.Errorf("expected Monitor to be of type *bool, got %T instead", value) 3569 } 3570 sv.Monitor = ptr.Bool(jtv) 3571 } 3572 3573 case "OsType": 3574 if value != nil { 3575 jtv, ok := value.(string) 3576 if !ok { 3577 return fmt.Errorf("expected OsType to be of type string, got %T instead", value) 3578 } 3579 sv.OsType = types.OsType(jtv) 3580 } 3581 3582 case "ResourceType": 3583 if value != nil { 3584 jtv, ok := value.(string) 3585 if !ok { 3586 return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value) 3587 } 3588 sv.ResourceType = ptr.String(jtv) 3589 } 3590 3591 case "Tier": 3592 if value != nil { 3593 jtv, ok := value.(string) 3594 if !ok { 3595 return fmt.Errorf("expected Tier to be of type string, got %T instead", value) 3596 } 3597 sv.Tier = types.Tier(jtv) 3598 } 3599 3600 default: 3601 _, _ = key, value 3602 3603 } 3604 } 3605 *v = sv 3606 return nil 3607} 3608 3609func awsAwsjson11_deserializeDocumentApplicationComponentList(v *[]types.ApplicationComponent, value interface{}) error { 3610 if v == nil { 3611 return fmt.Errorf("unexpected nil of type %T", v) 3612 } 3613 if value == nil { 3614 return nil 3615 } 3616 3617 shape, ok := value.([]interface{}) 3618 if !ok { 3619 return fmt.Errorf("unexpected JSON type %v", value) 3620 } 3621 3622 var cv []types.ApplicationComponent 3623 if *v == nil { 3624 cv = []types.ApplicationComponent{} 3625 } else { 3626 cv = *v 3627 } 3628 3629 for _, value := range shape { 3630 var col types.ApplicationComponent 3631 destAddr := &col 3632 if err := awsAwsjson11_deserializeDocumentApplicationComponent(&destAddr, value); err != nil { 3633 return err 3634 } 3635 col = *destAddr 3636 cv = append(cv, col) 3637 3638 } 3639 *v = cv 3640 return nil 3641} 3642 3643func awsAwsjson11_deserializeDocumentApplicationInfo(v **types.ApplicationInfo, value interface{}) error { 3644 if v == nil { 3645 return fmt.Errorf("unexpected nil of type %T", v) 3646 } 3647 if value == nil { 3648 return nil 3649 } 3650 3651 shape, ok := value.(map[string]interface{}) 3652 if !ok { 3653 return fmt.Errorf("unexpected JSON type %v", value) 3654 } 3655 3656 var sv *types.ApplicationInfo 3657 if *v == nil { 3658 sv = &types.ApplicationInfo{} 3659 } else { 3660 sv = *v 3661 } 3662 3663 for key, value := range shape { 3664 switch key { 3665 case "CWEMonitorEnabled": 3666 if value != nil { 3667 jtv, ok := value.(bool) 3668 if !ok { 3669 return fmt.Errorf("expected CWEMonitorEnabled to be of type *bool, got %T instead", value) 3670 } 3671 sv.CWEMonitorEnabled = ptr.Bool(jtv) 3672 } 3673 3674 case "LifeCycle": 3675 if value != nil { 3676 jtv, ok := value.(string) 3677 if !ok { 3678 return fmt.Errorf("expected LifeCycle to be of type string, got %T instead", value) 3679 } 3680 sv.LifeCycle = ptr.String(jtv) 3681 } 3682 3683 case "OpsCenterEnabled": 3684 if value != nil { 3685 jtv, ok := value.(bool) 3686 if !ok { 3687 return fmt.Errorf("expected OpsCenterEnabled to be of type *bool, got %T instead", value) 3688 } 3689 sv.OpsCenterEnabled = ptr.Bool(jtv) 3690 } 3691 3692 case "OpsItemSNSTopicArn": 3693 if value != nil { 3694 jtv, ok := value.(string) 3695 if !ok { 3696 return fmt.Errorf("expected OpsItemSNSTopicArn to be of type string, got %T instead", value) 3697 } 3698 sv.OpsItemSNSTopicArn = ptr.String(jtv) 3699 } 3700 3701 case "Remarks": 3702 if value != nil { 3703 jtv, ok := value.(string) 3704 if !ok { 3705 return fmt.Errorf("expected Remarks to be of type string, got %T instead", value) 3706 } 3707 sv.Remarks = ptr.String(jtv) 3708 } 3709 3710 case "ResourceGroupName": 3711 if value != nil { 3712 jtv, ok := value.(string) 3713 if !ok { 3714 return fmt.Errorf("expected ResourceGroupName to be of type string, got %T instead", value) 3715 } 3716 sv.ResourceGroupName = ptr.String(jtv) 3717 } 3718 3719 default: 3720 _, _ = key, value 3721 3722 } 3723 } 3724 *v = sv 3725 return nil 3726} 3727 3728func awsAwsjson11_deserializeDocumentApplicationInfoList(v *[]types.ApplicationInfo, value interface{}) error { 3729 if v == nil { 3730 return fmt.Errorf("unexpected nil of type %T", v) 3731 } 3732 if value == nil { 3733 return nil 3734 } 3735 3736 shape, ok := value.([]interface{}) 3737 if !ok { 3738 return fmt.Errorf("unexpected JSON type %v", value) 3739 } 3740 3741 var cv []types.ApplicationInfo 3742 if *v == nil { 3743 cv = []types.ApplicationInfo{} 3744 } else { 3745 cv = *v 3746 } 3747 3748 for _, value := range shape { 3749 var col types.ApplicationInfo 3750 destAddr := &col 3751 if err := awsAwsjson11_deserializeDocumentApplicationInfo(&destAddr, value); err != nil { 3752 return err 3753 } 3754 col = *destAddr 3755 cv = append(cv, col) 3756 3757 } 3758 *v = cv 3759 return nil 3760} 3761 3762func awsAwsjson11_deserializeDocumentBadRequestException(v **types.BadRequestException, value interface{}) error { 3763 if v == nil { 3764 return fmt.Errorf("unexpected nil of type %T", v) 3765 } 3766 if value == nil { 3767 return nil 3768 } 3769 3770 shape, ok := value.(map[string]interface{}) 3771 if !ok { 3772 return fmt.Errorf("unexpected JSON type %v", value) 3773 } 3774 3775 var sv *types.BadRequestException 3776 if *v == nil { 3777 sv = &types.BadRequestException{} 3778 } else { 3779 sv = *v 3780 } 3781 3782 for key, value := range shape { 3783 switch key { 3784 case "Message": 3785 if value != nil { 3786 jtv, ok := value.(string) 3787 if !ok { 3788 return fmt.Errorf("expected ErrorMsg to be of type string, got %T instead", value) 3789 } 3790 sv.Message = ptr.String(jtv) 3791 } 3792 3793 default: 3794 _, _ = key, value 3795 3796 } 3797 } 3798 *v = sv 3799 return nil 3800} 3801 3802func awsAwsjson11_deserializeDocumentConfigurationEvent(v **types.ConfigurationEvent, value interface{}) error { 3803 if v == nil { 3804 return fmt.Errorf("unexpected nil of type %T", v) 3805 } 3806 if value == nil { 3807 return nil 3808 } 3809 3810 shape, ok := value.(map[string]interface{}) 3811 if !ok { 3812 return fmt.Errorf("unexpected JSON type %v", value) 3813 } 3814 3815 var sv *types.ConfigurationEvent 3816 if *v == nil { 3817 sv = &types.ConfigurationEvent{} 3818 } else { 3819 sv = *v 3820 } 3821 3822 for key, value := range shape { 3823 switch key { 3824 case "EventDetail": 3825 if value != nil { 3826 jtv, ok := value.(string) 3827 if !ok { 3828 return fmt.Errorf("expected ConfigurationEventDetail to be of type string, got %T instead", value) 3829 } 3830 sv.EventDetail = ptr.String(jtv) 3831 } 3832 3833 case "EventResourceName": 3834 if value != nil { 3835 jtv, ok := value.(string) 3836 if !ok { 3837 return fmt.Errorf("expected ConfigurationEventResourceName to be of type string, got %T instead", value) 3838 } 3839 sv.EventResourceName = ptr.String(jtv) 3840 } 3841 3842 case "EventResourceType": 3843 if value != nil { 3844 jtv, ok := value.(string) 3845 if !ok { 3846 return fmt.Errorf("expected ConfigurationEventResourceType to be of type string, got %T instead", value) 3847 } 3848 sv.EventResourceType = types.ConfigurationEventResourceType(jtv) 3849 } 3850 3851 case "EventStatus": 3852 if value != nil { 3853 jtv, ok := value.(string) 3854 if !ok { 3855 return fmt.Errorf("expected ConfigurationEventStatus to be of type string, got %T instead", value) 3856 } 3857 sv.EventStatus = types.ConfigurationEventStatus(jtv) 3858 } 3859 3860 case "EventTime": 3861 if value != nil { 3862 jtv, ok := value.(json.Number) 3863 if !ok { 3864 return fmt.Errorf("expected ConfigurationEventTime to be json.Number, got %T instead", value) 3865 } 3866 f64, err := jtv.Float64() 3867 if err != nil { 3868 return err 3869 } 3870 sv.EventTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 3871 } 3872 3873 case "MonitoredResourceARN": 3874 if value != nil { 3875 jtv, ok := value.(string) 3876 if !ok { 3877 return fmt.Errorf("expected ConfigurationEventMonitoredResourceARN to be of type string, got %T instead", value) 3878 } 3879 sv.MonitoredResourceARN = ptr.String(jtv) 3880 } 3881 3882 default: 3883 _, _ = key, value 3884 3885 } 3886 } 3887 *v = sv 3888 return nil 3889} 3890 3891func awsAwsjson11_deserializeDocumentConfigurationEventList(v *[]types.ConfigurationEvent, value interface{}) error { 3892 if v == nil { 3893 return fmt.Errorf("unexpected nil of type %T", v) 3894 } 3895 if value == nil { 3896 return nil 3897 } 3898 3899 shape, ok := value.([]interface{}) 3900 if !ok { 3901 return fmt.Errorf("unexpected JSON type %v", value) 3902 } 3903 3904 var cv []types.ConfigurationEvent 3905 if *v == nil { 3906 cv = []types.ConfigurationEvent{} 3907 } else { 3908 cv = *v 3909 } 3910 3911 for _, value := range shape { 3912 var col types.ConfigurationEvent 3913 destAddr := &col 3914 if err := awsAwsjson11_deserializeDocumentConfigurationEvent(&destAddr, value); err != nil { 3915 return err 3916 } 3917 col = *destAddr 3918 cv = append(cv, col) 3919 3920 } 3921 *v = cv 3922 return nil 3923} 3924 3925func awsAwsjson11_deserializeDocumentDetectedWorkload(v *map[string]map[string]string, value interface{}) error { 3926 if v == nil { 3927 return fmt.Errorf("unexpected nil of type %T", v) 3928 } 3929 if value == nil { 3930 return nil 3931 } 3932 3933 shape, ok := value.(map[string]interface{}) 3934 if !ok { 3935 return fmt.Errorf("unexpected JSON type %v", value) 3936 } 3937 3938 var mv map[string]map[string]string 3939 if *v == nil { 3940 mv = map[string]map[string]string{} 3941 } else { 3942 mv = *v 3943 } 3944 3945 for key, value := range shape { 3946 var parsedVal map[string]string 3947 mapVar := parsedVal 3948 if err := awsAwsjson11_deserializeDocumentWorkloadMetaData(&mapVar, value); err != nil { 3949 return err 3950 } 3951 parsedVal = mapVar 3952 mv[key] = parsedVal 3953 3954 } 3955 *v = mv 3956 return nil 3957} 3958 3959func awsAwsjson11_deserializeDocumentFeedback(v *map[string]types.FeedbackValue, value interface{}) error { 3960 if v == nil { 3961 return fmt.Errorf("unexpected nil of type %T", v) 3962 } 3963 if value == nil { 3964 return nil 3965 } 3966 3967 shape, ok := value.(map[string]interface{}) 3968 if !ok { 3969 return fmt.Errorf("unexpected JSON type %v", value) 3970 } 3971 3972 var mv map[string]types.FeedbackValue 3973 if *v == nil { 3974 mv = map[string]types.FeedbackValue{} 3975 } else { 3976 mv = *v 3977 } 3978 3979 for key, value := range shape { 3980 var parsedVal types.FeedbackValue 3981 if value != nil { 3982 jtv, ok := value.(string) 3983 if !ok { 3984 return fmt.Errorf("expected FeedbackValue to be of type string, got %T instead", value) 3985 } 3986 parsedVal = types.FeedbackValue(jtv) 3987 } 3988 mv[key] = parsedVal 3989 3990 } 3991 *v = mv 3992 return nil 3993} 3994 3995func awsAwsjson11_deserializeDocumentInternalServerException(v **types.InternalServerException, value interface{}) error { 3996 if v == nil { 3997 return fmt.Errorf("unexpected nil of type %T", v) 3998 } 3999 if value == nil { 4000 return nil 4001 } 4002 4003 shape, ok := value.(map[string]interface{}) 4004 if !ok { 4005 return fmt.Errorf("unexpected JSON type %v", value) 4006 } 4007 4008 var sv *types.InternalServerException 4009 if *v == nil { 4010 sv = &types.InternalServerException{} 4011 } else { 4012 sv = *v 4013 } 4014 4015 for key, value := range shape { 4016 switch key { 4017 case "Message": 4018 if value != nil { 4019 jtv, ok := value.(string) 4020 if !ok { 4021 return fmt.Errorf("expected ErrorMsg to be of type string, got %T instead", value) 4022 } 4023 sv.Message = ptr.String(jtv) 4024 } 4025 4026 default: 4027 _, _ = key, value 4028 4029 } 4030 } 4031 *v = sv 4032 return nil 4033} 4034 4035func awsAwsjson11_deserializeDocumentLogPattern(v **types.LogPattern, value interface{}) error { 4036 if v == nil { 4037 return fmt.Errorf("unexpected nil of type %T", v) 4038 } 4039 if value == nil { 4040 return nil 4041 } 4042 4043 shape, ok := value.(map[string]interface{}) 4044 if !ok { 4045 return fmt.Errorf("unexpected JSON type %v", value) 4046 } 4047 4048 var sv *types.LogPattern 4049 if *v == nil { 4050 sv = &types.LogPattern{} 4051 } else { 4052 sv = *v 4053 } 4054 4055 for key, value := range shape { 4056 switch key { 4057 case "Pattern": 4058 if value != nil { 4059 jtv, ok := value.(string) 4060 if !ok { 4061 return fmt.Errorf("expected LogPatternRegex to be of type string, got %T instead", value) 4062 } 4063 sv.Pattern = ptr.String(jtv) 4064 } 4065 4066 case "PatternName": 4067 if value != nil { 4068 jtv, ok := value.(string) 4069 if !ok { 4070 return fmt.Errorf("expected LogPatternName to be of type string, got %T instead", value) 4071 } 4072 sv.PatternName = ptr.String(jtv) 4073 } 4074 4075 case "PatternSetName": 4076 if value != nil { 4077 jtv, ok := value.(string) 4078 if !ok { 4079 return fmt.Errorf("expected LogPatternSetName to be of type string, got %T instead", value) 4080 } 4081 sv.PatternSetName = ptr.String(jtv) 4082 } 4083 4084 case "Rank": 4085 if value != nil { 4086 jtv, ok := value.(json.Number) 4087 if !ok { 4088 return fmt.Errorf("expected LogPatternRank to be json.Number, got %T instead", value) 4089 } 4090 i64, err := jtv.Int64() 4091 if err != nil { 4092 return err 4093 } 4094 sv.Rank = int32(i64) 4095 } 4096 4097 default: 4098 _, _ = key, value 4099 4100 } 4101 } 4102 *v = sv 4103 return nil 4104} 4105 4106func awsAwsjson11_deserializeDocumentLogPatternList(v *[]types.LogPattern, value interface{}) error { 4107 if v == nil { 4108 return fmt.Errorf("unexpected nil of type %T", v) 4109 } 4110 if value == nil { 4111 return nil 4112 } 4113 4114 shape, ok := value.([]interface{}) 4115 if !ok { 4116 return fmt.Errorf("unexpected JSON type %v", value) 4117 } 4118 4119 var cv []types.LogPattern 4120 if *v == nil { 4121 cv = []types.LogPattern{} 4122 } else { 4123 cv = *v 4124 } 4125 4126 for _, value := range shape { 4127 var col types.LogPattern 4128 destAddr := &col 4129 if err := awsAwsjson11_deserializeDocumentLogPattern(&destAddr, value); err != nil { 4130 return err 4131 } 4132 col = *destAddr 4133 cv = append(cv, col) 4134 4135 } 4136 *v = cv 4137 return nil 4138} 4139 4140func awsAwsjson11_deserializeDocumentLogPatternSetList(v *[]string, value interface{}) error { 4141 if v == nil { 4142 return fmt.Errorf("unexpected nil of type %T", v) 4143 } 4144 if value == nil { 4145 return nil 4146 } 4147 4148 shape, ok := value.([]interface{}) 4149 if !ok { 4150 return fmt.Errorf("unexpected JSON type %v", value) 4151 } 4152 4153 var cv []string 4154 if *v == nil { 4155 cv = []string{} 4156 } else { 4157 cv = *v 4158 } 4159 4160 for _, value := range shape { 4161 var col string 4162 if value != nil { 4163 jtv, ok := value.(string) 4164 if !ok { 4165 return fmt.Errorf("expected LogPatternSetName to be of type string, got %T instead", value) 4166 } 4167 col = jtv 4168 } 4169 cv = append(cv, col) 4170 4171 } 4172 *v = cv 4173 return nil 4174} 4175 4176func awsAwsjson11_deserializeDocumentObservation(v **types.Observation, value interface{}) error { 4177 if v == nil { 4178 return fmt.Errorf("unexpected nil of type %T", v) 4179 } 4180 if value == nil { 4181 return nil 4182 } 4183 4184 shape, ok := value.(map[string]interface{}) 4185 if !ok { 4186 return fmt.Errorf("unexpected JSON type %v", value) 4187 } 4188 4189 var sv *types.Observation 4190 if *v == nil { 4191 sv = &types.Observation{} 4192 } else { 4193 sv = *v 4194 } 4195 4196 for key, value := range shape { 4197 switch key { 4198 case "CloudWatchEventDetailType": 4199 if value != nil { 4200 jtv, ok := value.(string) 4201 if !ok { 4202 return fmt.Errorf("expected CloudWatchEventDetailType to be of type string, got %T instead", value) 4203 } 4204 sv.CloudWatchEventDetailType = ptr.String(jtv) 4205 } 4206 4207 case "CloudWatchEventId": 4208 if value != nil { 4209 jtv, ok := value.(string) 4210 if !ok { 4211 return fmt.Errorf("expected CloudWatchEventId to be of type string, got %T instead", value) 4212 } 4213 sv.CloudWatchEventId = ptr.String(jtv) 4214 } 4215 4216 case "CloudWatchEventSource": 4217 if value != nil { 4218 jtv, ok := value.(string) 4219 if !ok { 4220 return fmt.Errorf("expected CloudWatchEventSource to be of type string, got %T instead", value) 4221 } 4222 sv.CloudWatchEventSource = types.CloudWatchEventSource(jtv) 4223 } 4224 4225 case "CodeDeployApplication": 4226 if value != nil { 4227 jtv, ok := value.(string) 4228 if !ok { 4229 return fmt.Errorf("expected CodeDeployApplication to be of type string, got %T instead", value) 4230 } 4231 sv.CodeDeployApplication = ptr.String(jtv) 4232 } 4233 4234 case "CodeDeployDeploymentGroup": 4235 if value != nil { 4236 jtv, ok := value.(string) 4237 if !ok { 4238 return fmt.Errorf("expected CodeDeployDeploymentGroup to be of type string, got %T instead", value) 4239 } 4240 sv.CodeDeployDeploymentGroup = ptr.String(jtv) 4241 } 4242 4243 case "CodeDeployDeploymentId": 4244 if value != nil { 4245 jtv, ok := value.(string) 4246 if !ok { 4247 return fmt.Errorf("expected CodeDeployDeploymentId to be of type string, got %T instead", value) 4248 } 4249 sv.CodeDeployDeploymentId = ptr.String(jtv) 4250 } 4251 4252 case "CodeDeployInstanceGroupId": 4253 if value != nil { 4254 jtv, ok := value.(string) 4255 if !ok { 4256 return fmt.Errorf("expected CodeDeployInstanceGroupId to be of type string, got %T instead", value) 4257 } 4258 sv.CodeDeployInstanceGroupId = ptr.String(jtv) 4259 } 4260 4261 case "CodeDeployState": 4262 if value != nil { 4263 jtv, ok := value.(string) 4264 if !ok { 4265 return fmt.Errorf("expected CodeDeployState to be of type string, got %T instead", value) 4266 } 4267 sv.CodeDeployState = ptr.String(jtv) 4268 } 4269 4270 case "EbsCause": 4271 if value != nil { 4272 jtv, ok := value.(string) 4273 if !ok { 4274 return fmt.Errorf("expected EbsCause to be of type string, got %T instead", value) 4275 } 4276 sv.EbsCause = ptr.String(jtv) 4277 } 4278 4279 case "EbsEvent": 4280 if value != nil { 4281 jtv, ok := value.(string) 4282 if !ok { 4283 return fmt.Errorf("expected EbsEvent to be of type string, got %T instead", value) 4284 } 4285 sv.EbsEvent = ptr.String(jtv) 4286 } 4287 4288 case "EbsRequestId": 4289 if value != nil { 4290 jtv, ok := value.(string) 4291 if !ok { 4292 return fmt.Errorf("expected EbsRequestId to be of type string, got %T instead", value) 4293 } 4294 sv.EbsRequestId = ptr.String(jtv) 4295 } 4296 4297 case "EbsResult": 4298 if value != nil { 4299 jtv, ok := value.(string) 4300 if !ok { 4301 return fmt.Errorf("expected EbsResult to be of type string, got %T instead", value) 4302 } 4303 sv.EbsResult = ptr.String(jtv) 4304 } 4305 4306 case "Ec2State": 4307 if value != nil { 4308 jtv, ok := value.(string) 4309 if !ok { 4310 return fmt.Errorf("expected Ec2State to be of type string, got %T instead", value) 4311 } 4312 sv.Ec2State = ptr.String(jtv) 4313 } 4314 4315 case "EndTime": 4316 if value != nil { 4317 jtv, ok := value.(json.Number) 4318 if !ok { 4319 return fmt.Errorf("expected EndTime to be json.Number, got %T instead", value) 4320 } 4321 f64, err := jtv.Float64() 4322 if err != nil { 4323 return err 4324 } 4325 sv.EndTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 4326 } 4327 4328 case "HealthEventArn": 4329 if value != nil { 4330 jtv, ok := value.(string) 4331 if !ok { 4332 return fmt.Errorf("expected HealthEventArn to be of type string, got %T instead", value) 4333 } 4334 sv.HealthEventArn = ptr.String(jtv) 4335 } 4336 4337 case "HealthEventDescription": 4338 if value != nil { 4339 jtv, ok := value.(string) 4340 if !ok { 4341 return fmt.Errorf("expected HealthEventDescription to be of type string, got %T instead", value) 4342 } 4343 sv.HealthEventDescription = ptr.String(jtv) 4344 } 4345 4346 case "HealthEventTypeCategory": 4347 if value != nil { 4348 jtv, ok := value.(string) 4349 if !ok { 4350 return fmt.Errorf("expected HealthEventTypeCategory to be of type string, got %T instead", value) 4351 } 4352 sv.HealthEventTypeCategory = ptr.String(jtv) 4353 } 4354 4355 case "HealthEventTypeCode": 4356 if value != nil { 4357 jtv, ok := value.(string) 4358 if !ok { 4359 return fmt.Errorf("expected HealthEventTypeCode to be of type string, got %T instead", value) 4360 } 4361 sv.HealthEventTypeCode = ptr.String(jtv) 4362 } 4363 4364 case "HealthService": 4365 if value != nil { 4366 jtv, ok := value.(string) 4367 if !ok { 4368 return fmt.Errorf("expected HealthService to be of type string, got %T instead", value) 4369 } 4370 sv.HealthService = ptr.String(jtv) 4371 } 4372 4373 case "Id": 4374 if value != nil { 4375 jtv, ok := value.(string) 4376 if !ok { 4377 return fmt.Errorf("expected ObservationId to be of type string, got %T instead", value) 4378 } 4379 sv.Id = ptr.String(jtv) 4380 } 4381 4382 case "LineTime": 4383 if value != nil { 4384 jtv, ok := value.(json.Number) 4385 if !ok { 4386 return fmt.Errorf("expected LineTime to be json.Number, got %T instead", value) 4387 } 4388 f64, err := jtv.Float64() 4389 if err != nil { 4390 return err 4391 } 4392 sv.LineTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 4393 } 4394 4395 case "LogFilter": 4396 if value != nil { 4397 jtv, ok := value.(string) 4398 if !ok { 4399 return fmt.Errorf("expected LogFilter to be of type string, got %T instead", value) 4400 } 4401 sv.LogFilter = types.LogFilter(jtv) 4402 } 4403 4404 case "LogGroup": 4405 if value != nil { 4406 jtv, ok := value.(string) 4407 if !ok { 4408 return fmt.Errorf("expected LogGroup to be of type string, got %T instead", value) 4409 } 4410 sv.LogGroup = ptr.String(jtv) 4411 } 4412 4413 case "LogText": 4414 if value != nil { 4415 jtv, ok := value.(string) 4416 if !ok { 4417 return fmt.Errorf("expected LogText to be of type string, got %T instead", value) 4418 } 4419 sv.LogText = ptr.String(jtv) 4420 } 4421 4422 case "MetricName": 4423 if value != nil { 4424 jtv, ok := value.(string) 4425 if !ok { 4426 return fmt.Errorf("expected MetricName to be of type string, got %T instead", value) 4427 } 4428 sv.MetricName = ptr.String(jtv) 4429 } 4430 4431 case "MetricNamespace": 4432 if value != nil { 4433 jtv, ok := value.(string) 4434 if !ok { 4435 return fmt.Errorf("expected MetricNamespace to be of type string, got %T instead", value) 4436 } 4437 sv.MetricNamespace = ptr.String(jtv) 4438 } 4439 4440 case "RdsEventCategories": 4441 if value != nil { 4442 jtv, ok := value.(string) 4443 if !ok { 4444 return fmt.Errorf("expected RdsEventCategories to be of type string, got %T instead", value) 4445 } 4446 sv.RdsEventCategories = ptr.String(jtv) 4447 } 4448 4449 case "RdsEventMessage": 4450 if value != nil { 4451 jtv, ok := value.(string) 4452 if !ok { 4453 return fmt.Errorf("expected RdsEventMessage to be of type string, got %T instead", value) 4454 } 4455 sv.RdsEventMessage = ptr.String(jtv) 4456 } 4457 4458 case "S3EventName": 4459 if value != nil { 4460 jtv, ok := value.(string) 4461 if !ok { 4462 return fmt.Errorf("expected S3EventName to be of type string, got %T instead", value) 4463 } 4464 sv.S3EventName = ptr.String(jtv) 4465 } 4466 4467 case "SourceARN": 4468 if value != nil { 4469 jtv, ok := value.(string) 4470 if !ok { 4471 return fmt.Errorf("expected SourceARN to be of type string, got %T instead", value) 4472 } 4473 sv.SourceARN = ptr.String(jtv) 4474 } 4475 4476 case "SourceType": 4477 if value != nil { 4478 jtv, ok := value.(string) 4479 if !ok { 4480 return fmt.Errorf("expected SourceType to be of type string, got %T instead", value) 4481 } 4482 sv.SourceType = ptr.String(jtv) 4483 } 4484 4485 case "StartTime": 4486 if value != nil { 4487 jtv, ok := value.(json.Number) 4488 if !ok { 4489 return fmt.Errorf("expected StartTime to be json.Number, got %T instead", value) 4490 } 4491 f64, err := jtv.Float64() 4492 if err != nil { 4493 return err 4494 } 4495 sv.StartTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 4496 } 4497 4498 case "StatesArn": 4499 if value != nil { 4500 jtv, ok := value.(string) 4501 if !ok { 4502 return fmt.Errorf("expected StatesArn to be of type string, got %T instead", value) 4503 } 4504 sv.StatesArn = ptr.String(jtv) 4505 } 4506 4507 case "StatesExecutionArn": 4508 if value != nil { 4509 jtv, ok := value.(string) 4510 if !ok { 4511 return fmt.Errorf("expected StatesExecutionArn to be of type string, got %T instead", value) 4512 } 4513 sv.StatesExecutionArn = ptr.String(jtv) 4514 } 4515 4516 case "StatesInput": 4517 if value != nil { 4518 jtv, ok := value.(string) 4519 if !ok { 4520 return fmt.Errorf("expected StatesInput to be of type string, got %T instead", value) 4521 } 4522 sv.StatesInput = ptr.String(jtv) 4523 } 4524 4525 case "StatesStatus": 4526 if value != nil { 4527 jtv, ok := value.(string) 4528 if !ok { 4529 return fmt.Errorf("expected StatesStatus to be of type string, got %T instead", value) 4530 } 4531 sv.StatesStatus = ptr.String(jtv) 4532 } 4533 4534 case "Unit": 4535 if value != nil { 4536 jtv, ok := value.(string) 4537 if !ok { 4538 return fmt.Errorf("expected Unit to be of type string, got %T instead", value) 4539 } 4540 sv.Unit = ptr.String(jtv) 4541 } 4542 4543 case "Value": 4544 if value != nil { 4545 jtv, ok := value.(json.Number) 4546 if !ok { 4547 return fmt.Errorf("expected Value to be json.Number, got %T instead", value) 4548 } 4549 f64, err := jtv.Float64() 4550 if err != nil { 4551 return err 4552 } 4553 sv.Value = ptr.Float64(f64) 4554 } 4555 4556 case "XRayErrorPercent": 4557 if value != nil { 4558 jtv, ok := value.(json.Number) 4559 if !ok { 4560 return fmt.Errorf("expected XRayErrorPercent to be json.Number, got %T instead", value) 4561 } 4562 i64, err := jtv.Int64() 4563 if err != nil { 4564 return err 4565 } 4566 sv.XRayErrorPercent = ptr.Int32(int32(i64)) 4567 } 4568 4569 case "XRayFaultPercent": 4570 if value != nil { 4571 jtv, ok := value.(json.Number) 4572 if !ok { 4573 return fmt.Errorf("expected XRayFaultPercent to be json.Number, got %T instead", value) 4574 } 4575 i64, err := jtv.Int64() 4576 if err != nil { 4577 return err 4578 } 4579 sv.XRayFaultPercent = ptr.Int32(int32(i64)) 4580 } 4581 4582 case "XRayNodeName": 4583 if value != nil { 4584 jtv, ok := value.(string) 4585 if !ok { 4586 return fmt.Errorf("expected XRayNodeName to be of type string, got %T instead", value) 4587 } 4588 sv.XRayNodeName = ptr.String(jtv) 4589 } 4590 4591 case "XRayNodeType": 4592 if value != nil { 4593 jtv, ok := value.(string) 4594 if !ok { 4595 return fmt.Errorf("expected XRayNodeType to be of type string, got %T instead", value) 4596 } 4597 sv.XRayNodeType = ptr.String(jtv) 4598 } 4599 4600 case "XRayRequestAverageLatency": 4601 if value != nil { 4602 jtv, ok := value.(json.Number) 4603 if !ok { 4604 return fmt.Errorf("expected XRayRequestAverageLatency to be json.Number, got %T instead", value) 4605 } 4606 i64, err := jtv.Int64() 4607 if err != nil { 4608 return err 4609 } 4610 sv.XRayRequestAverageLatency = ptr.Int64(i64) 4611 } 4612 4613 case "XRayRequestCount": 4614 if value != nil { 4615 jtv, ok := value.(json.Number) 4616 if !ok { 4617 return fmt.Errorf("expected XRayRequestCount to be json.Number, got %T instead", value) 4618 } 4619 i64, err := jtv.Int64() 4620 if err != nil { 4621 return err 4622 } 4623 sv.XRayRequestCount = ptr.Int32(int32(i64)) 4624 } 4625 4626 case "XRayThrottlePercent": 4627 if value != nil { 4628 jtv, ok := value.(json.Number) 4629 if !ok { 4630 return fmt.Errorf("expected XRayThrottlePercent to be json.Number, got %T instead", value) 4631 } 4632 i64, err := jtv.Int64() 4633 if err != nil { 4634 return err 4635 } 4636 sv.XRayThrottlePercent = ptr.Int32(int32(i64)) 4637 } 4638 4639 default: 4640 _, _ = key, value 4641 4642 } 4643 } 4644 *v = sv 4645 return nil 4646} 4647 4648func awsAwsjson11_deserializeDocumentObservationList(v *[]types.Observation, value interface{}) error { 4649 if v == nil { 4650 return fmt.Errorf("unexpected nil of type %T", v) 4651 } 4652 if value == nil { 4653 return nil 4654 } 4655 4656 shape, ok := value.([]interface{}) 4657 if !ok { 4658 return fmt.Errorf("unexpected JSON type %v", value) 4659 } 4660 4661 var cv []types.Observation 4662 if *v == nil { 4663 cv = []types.Observation{} 4664 } else { 4665 cv = *v 4666 } 4667 4668 for _, value := range shape { 4669 var col types.Observation 4670 destAddr := &col 4671 if err := awsAwsjson11_deserializeDocumentObservation(&destAddr, value); err != nil { 4672 return err 4673 } 4674 col = *destAddr 4675 cv = append(cv, col) 4676 4677 } 4678 *v = cv 4679 return nil 4680} 4681 4682func awsAwsjson11_deserializeDocumentProblem(v **types.Problem, value interface{}) error { 4683 if v == nil { 4684 return fmt.Errorf("unexpected nil of type %T", v) 4685 } 4686 if value == nil { 4687 return nil 4688 } 4689 4690 shape, ok := value.(map[string]interface{}) 4691 if !ok { 4692 return fmt.Errorf("unexpected JSON type %v", value) 4693 } 4694 4695 var sv *types.Problem 4696 if *v == nil { 4697 sv = &types.Problem{} 4698 } else { 4699 sv = *v 4700 } 4701 4702 for key, value := range shape { 4703 switch key { 4704 case "AffectedResource": 4705 if value != nil { 4706 jtv, ok := value.(string) 4707 if !ok { 4708 return fmt.Errorf("expected AffectedResource to be of type string, got %T instead", value) 4709 } 4710 sv.AffectedResource = ptr.String(jtv) 4711 } 4712 4713 case "EndTime": 4714 if value != nil { 4715 jtv, ok := value.(json.Number) 4716 if !ok { 4717 return fmt.Errorf("expected EndTime to be json.Number, got %T instead", value) 4718 } 4719 f64, err := jtv.Float64() 4720 if err != nil { 4721 return err 4722 } 4723 sv.EndTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 4724 } 4725 4726 case "Feedback": 4727 if err := awsAwsjson11_deserializeDocumentFeedback(&sv.Feedback, value); err != nil { 4728 return err 4729 } 4730 4731 case "Id": 4732 if value != nil { 4733 jtv, ok := value.(string) 4734 if !ok { 4735 return fmt.Errorf("expected ProblemId to be of type string, got %T instead", value) 4736 } 4737 sv.Id = ptr.String(jtv) 4738 } 4739 4740 case "Insights": 4741 if value != nil { 4742 jtv, ok := value.(string) 4743 if !ok { 4744 return fmt.Errorf("expected Insights to be of type string, got %T instead", value) 4745 } 4746 sv.Insights = ptr.String(jtv) 4747 } 4748 4749 case "ResourceGroupName": 4750 if value != nil { 4751 jtv, ok := value.(string) 4752 if !ok { 4753 return fmt.Errorf("expected ResourceGroupName to be of type string, got %T instead", value) 4754 } 4755 sv.ResourceGroupName = ptr.String(jtv) 4756 } 4757 4758 case "SeverityLevel": 4759 if value != nil { 4760 jtv, ok := value.(string) 4761 if !ok { 4762 return fmt.Errorf("expected SeverityLevel to be of type string, got %T instead", value) 4763 } 4764 sv.SeverityLevel = types.SeverityLevel(jtv) 4765 } 4766 4767 case "StartTime": 4768 if value != nil { 4769 jtv, ok := value.(json.Number) 4770 if !ok { 4771 return fmt.Errorf("expected StartTime to be json.Number, got %T instead", value) 4772 } 4773 f64, err := jtv.Float64() 4774 if err != nil { 4775 return err 4776 } 4777 sv.StartTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 4778 } 4779 4780 case "Status": 4781 if value != nil { 4782 jtv, ok := value.(string) 4783 if !ok { 4784 return fmt.Errorf("expected Status to be of type string, got %T instead", value) 4785 } 4786 sv.Status = types.Status(jtv) 4787 } 4788 4789 case "Title": 4790 if value != nil { 4791 jtv, ok := value.(string) 4792 if !ok { 4793 return fmt.Errorf("expected Title to be of type string, got %T instead", value) 4794 } 4795 sv.Title = ptr.String(jtv) 4796 } 4797 4798 default: 4799 _, _ = key, value 4800 4801 } 4802 } 4803 *v = sv 4804 return nil 4805} 4806 4807func awsAwsjson11_deserializeDocumentProblemList(v *[]types.Problem, value interface{}) error { 4808 if v == nil { 4809 return fmt.Errorf("unexpected nil of type %T", v) 4810 } 4811 if value == nil { 4812 return nil 4813 } 4814 4815 shape, ok := value.([]interface{}) 4816 if !ok { 4817 return fmt.Errorf("unexpected JSON type %v", value) 4818 } 4819 4820 var cv []types.Problem 4821 if *v == nil { 4822 cv = []types.Problem{} 4823 } else { 4824 cv = *v 4825 } 4826 4827 for _, value := range shape { 4828 var col types.Problem 4829 destAddr := &col 4830 if err := awsAwsjson11_deserializeDocumentProblem(&destAddr, value); err != nil { 4831 return err 4832 } 4833 col = *destAddr 4834 cv = append(cv, col) 4835 4836 } 4837 *v = cv 4838 return nil 4839} 4840 4841func awsAwsjson11_deserializeDocumentRelatedObservations(v **types.RelatedObservations, value interface{}) error { 4842 if v == nil { 4843 return fmt.Errorf("unexpected nil of type %T", v) 4844 } 4845 if value == nil { 4846 return nil 4847 } 4848 4849 shape, ok := value.(map[string]interface{}) 4850 if !ok { 4851 return fmt.Errorf("unexpected JSON type %v", value) 4852 } 4853 4854 var sv *types.RelatedObservations 4855 if *v == nil { 4856 sv = &types.RelatedObservations{} 4857 } else { 4858 sv = *v 4859 } 4860 4861 for key, value := range shape { 4862 switch key { 4863 case "ObservationList": 4864 if err := awsAwsjson11_deserializeDocumentObservationList(&sv.ObservationList, value); err != nil { 4865 return err 4866 } 4867 4868 default: 4869 _, _ = key, value 4870 4871 } 4872 } 4873 *v = sv 4874 return nil 4875} 4876 4877func awsAwsjson11_deserializeDocumentResourceInUseException(v **types.ResourceInUseException, value interface{}) error { 4878 if v == nil { 4879 return fmt.Errorf("unexpected nil of type %T", v) 4880 } 4881 if value == nil { 4882 return nil 4883 } 4884 4885 shape, ok := value.(map[string]interface{}) 4886 if !ok { 4887 return fmt.Errorf("unexpected JSON type %v", value) 4888 } 4889 4890 var sv *types.ResourceInUseException 4891 if *v == nil { 4892 sv = &types.ResourceInUseException{} 4893 } else { 4894 sv = *v 4895 } 4896 4897 for key, value := range shape { 4898 switch key { 4899 case "Message": 4900 if value != nil { 4901 jtv, ok := value.(string) 4902 if !ok { 4903 return fmt.Errorf("expected ErrorMsg to be of type string, got %T instead", value) 4904 } 4905 sv.Message = ptr.String(jtv) 4906 } 4907 4908 default: 4909 _, _ = key, value 4910 4911 } 4912 } 4913 *v = sv 4914 return nil 4915} 4916 4917func awsAwsjson11_deserializeDocumentResourceList(v *[]string, value interface{}) error { 4918 if v == nil { 4919 return fmt.Errorf("unexpected nil of type %T", v) 4920 } 4921 if value == nil { 4922 return nil 4923 } 4924 4925 shape, ok := value.([]interface{}) 4926 if !ok { 4927 return fmt.Errorf("unexpected JSON type %v", value) 4928 } 4929 4930 var cv []string 4931 if *v == nil { 4932 cv = []string{} 4933 } else { 4934 cv = *v 4935 } 4936 4937 for _, value := range shape { 4938 var col string 4939 if value != nil { 4940 jtv, ok := value.(string) 4941 if !ok { 4942 return fmt.Errorf("expected ResourceARN to be of type string, got %T instead", value) 4943 } 4944 col = jtv 4945 } 4946 cv = append(cv, col) 4947 4948 } 4949 *v = cv 4950 return nil 4951} 4952 4953func awsAwsjson11_deserializeDocumentResourceNotFoundException(v **types.ResourceNotFoundException, value interface{}) error { 4954 if v == nil { 4955 return fmt.Errorf("unexpected nil of type %T", v) 4956 } 4957 if value == nil { 4958 return nil 4959 } 4960 4961 shape, ok := value.(map[string]interface{}) 4962 if !ok { 4963 return fmt.Errorf("unexpected JSON type %v", value) 4964 } 4965 4966 var sv *types.ResourceNotFoundException 4967 if *v == nil { 4968 sv = &types.ResourceNotFoundException{} 4969 } else { 4970 sv = *v 4971 } 4972 4973 for key, value := range shape { 4974 switch key { 4975 case "Message": 4976 if value != nil { 4977 jtv, ok := value.(string) 4978 if !ok { 4979 return fmt.Errorf("expected ErrorMsg to be of type string, got %T instead", value) 4980 } 4981 sv.Message = ptr.String(jtv) 4982 } 4983 4984 default: 4985 _, _ = key, value 4986 4987 } 4988 } 4989 *v = sv 4990 return nil 4991} 4992 4993func awsAwsjson11_deserializeDocumentTag(v **types.Tag, value interface{}) error { 4994 if v == nil { 4995 return fmt.Errorf("unexpected nil of type %T", v) 4996 } 4997 if value == nil { 4998 return nil 4999 } 5000 5001 shape, ok := value.(map[string]interface{}) 5002 if !ok { 5003 return fmt.Errorf("unexpected JSON type %v", value) 5004 } 5005 5006 var sv *types.Tag 5007 if *v == nil { 5008 sv = &types.Tag{} 5009 } else { 5010 sv = *v 5011 } 5012 5013 for key, value := range shape { 5014 switch key { 5015 case "Key": 5016 if value != nil { 5017 jtv, ok := value.(string) 5018 if !ok { 5019 return fmt.Errorf("expected TagKey to be of type string, got %T instead", value) 5020 } 5021 sv.Key = ptr.String(jtv) 5022 } 5023 5024 case "Value": 5025 if value != nil { 5026 jtv, ok := value.(string) 5027 if !ok { 5028 return fmt.Errorf("expected TagValue to be of type string, got %T instead", value) 5029 } 5030 sv.Value = ptr.String(jtv) 5031 } 5032 5033 default: 5034 _, _ = key, value 5035 5036 } 5037 } 5038 *v = sv 5039 return nil 5040} 5041 5042func awsAwsjson11_deserializeDocumentTagList(v *[]types.Tag, value interface{}) error { 5043 if v == nil { 5044 return fmt.Errorf("unexpected nil of type %T", v) 5045 } 5046 if value == nil { 5047 return nil 5048 } 5049 5050 shape, ok := value.([]interface{}) 5051 if !ok { 5052 return fmt.Errorf("unexpected JSON type %v", value) 5053 } 5054 5055 var cv []types.Tag 5056 if *v == nil { 5057 cv = []types.Tag{} 5058 } else { 5059 cv = *v 5060 } 5061 5062 for _, value := range shape { 5063 var col types.Tag 5064 destAddr := &col 5065 if err := awsAwsjson11_deserializeDocumentTag(&destAddr, value); err != nil { 5066 return err 5067 } 5068 col = *destAddr 5069 cv = append(cv, col) 5070 5071 } 5072 *v = cv 5073 return nil 5074} 5075 5076func awsAwsjson11_deserializeDocumentTagsAlreadyExistException(v **types.TagsAlreadyExistException, value interface{}) error { 5077 if v == nil { 5078 return fmt.Errorf("unexpected nil of type %T", v) 5079 } 5080 if value == nil { 5081 return nil 5082 } 5083 5084 shape, ok := value.(map[string]interface{}) 5085 if !ok { 5086 return fmt.Errorf("unexpected JSON type %v", value) 5087 } 5088 5089 var sv *types.TagsAlreadyExistException 5090 if *v == nil { 5091 sv = &types.TagsAlreadyExistException{} 5092 } else { 5093 sv = *v 5094 } 5095 5096 for key, value := range shape { 5097 switch key { 5098 case "Message": 5099 if value != nil { 5100 jtv, ok := value.(string) 5101 if !ok { 5102 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 5103 } 5104 sv.Message = ptr.String(jtv) 5105 } 5106 5107 default: 5108 _, _ = key, value 5109 5110 } 5111 } 5112 *v = sv 5113 return nil 5114} 5115 5116func awsAwsjson11_deserializeDocumentTooManyTagsException(v **types.TooManyTagsException, value interface{}) error { 5117 if v == nil { 5118 return fmt.Errorf("unexpected nil of type %T", v) 5119 } 5120 if value == nil { 5121 return nil 5122 } 5123 5124 shape, ok := value.(map[string]interface{}) 5125 if !ok { 5126 return fmt.Errorf("unexpected JSON type %v", value) 5127 } 5128 5129 var sv *types.TooManyTagsException 5130 if *v == nil { 5131 sv = &types.TooManyTagsException{} 5132 } else { 5133 sv = *v 5134 } 5135 5136 for key, value := range shape { 5137 switch key { 5138 case "Message": 5139 if value != nil { 5140 jtv, ok := value.(string) 5141 if !ok { 5142 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 5143 } 5144 sv.Message = ptr.String(jtv) 5145 } 5146 5147 case "ResourceName": 5148 if value != nil { 5149 jtv, ok := value.(string) 5150 if !ok { 5151 return fmt.Errorf("expected AmazonResourceName to be of type string, got %T instead", value) 5152 } 5153 sv.ResourceName = ptr.String(jtv) 5154 } 5155 5156 default: 5157 _, _ = key, value 5158 5159 } 5160 } 5161 *v = sv 5162 return nil 5163} 5164 5165func awsAwsjson11_deserializeDocumentValidationException(v **types.ValidationException, value interface{}) error { 5166 if v == nil { 5167 return fmt.Errorf("unexpected nil of type %T", v) 5168 } 5169 if value == nil { 5170 return nil 5171 } 5172 5173 shape, ok := value.(map[string]interface{}) 5174 if !ok { 5175 return fmt.Errorf("unexpected JSON type %v", value) 5176 } 5177 5178 var sv *types.ValidationException 5179 if *v == nil { 5180 sv = &types.ValidationException{} 5181 } else { 5182 sv = *v 5183 } 5184 5185 for key, value := range shape { 5186 switch key { 5187 case "Message": 5188 if value != nil { 5189 jtv, ok := value.(string) 5190 if !ok { 5191 return fmt.Errorf("expected ErrorMsg to be of type string, got %T instead", value) 5192 } 5193 sv.Message = ptr.String(jtv) 5194 } 5195 5196 default: 5197 _, _ = key, value 5198 5199 } 5200 } 5201 *v = sv 5202 return nil 5203} 5204 5205func awsAwsjson11_deserializeDocumentWorkloadMetaData(v *map[string]string, value interface{}) error { 5206 if v == nil { 5207 return fmt.Errorf("unexpected nil of type %T", v) 5208 } 5209 if value == nil { 5210 return nil 5211 } 5212 5213 shape, ok := value.(map[string]interface{}) 5214 if !ok { 5215 return fmt.Errorf("unexpected JSON type %v", value) 5216 } 5217 5218 var mv map[string]string 5219 if *v == nil { 5220 mv = map[string]string{} 5221 } else { 5222 mv = *v 5223 } 5224 5225 for key, value := range shape { 5226 var parsedVal string 5227 if value != nil { 5228 jtv, ok := value.(string) 5229 if !ok { 5230 return fmt.Errorf("expected MetaDataValue to be of type string, got %T instead", value) 5231 } 5232 parsedVal = jtv 5233 } 5234 mv[key] = parsedVal 5235 5236 } 5237 *v = mv 5238 return nil 5239} 5240 5241func awsAwsjson11_deserializeOpDocumentCreateApplicationOutput(v **CreateApplicationOutput, value interface{}) error { 5242 if v == nil { 5243 return fmt.Errorf("unexpected nil of type %T", v) 5244 } 5245 if value == nil { 5246 return nil 5247 } 5248 5249 shape, ok := value.(map[string]interface{}) 5250 if !ok { 5251 return fmt.Errorf("unexpected JSON type %v", value) 5252 } 5253 5254 var sv *CreateApplicationOutput 5255 if *v == nil { 5256 sv = &CreateApplicationOutput{} 5257 } else { 5258 sv = *v 5259 } 5260 5261 for key, value := range shape { 5262 switch key { 5263 case "ApplicationInfo": 5264 if err := awsAwsjson11_deserializeDocumentApplicationInfo(&sv.ApplicationInfo, value); err != nil { 5265 return err 5266 } 5267 5268 default: 5269 _, _ = key, value 5270 5271 } 5272 } 5273 *v = sv 5274 return nil 5275} 5276 5277func awsAwsjson11_deserializeOpDocumentCreateComponentOutput(v **CreateComponentOutput, value interface{}) error { 5278 if v == nil { 5279 return fmt.Errorf("unexpected nil of type %T", v) 5280 } 5281 if value == nil { 5282 return nil 5283 } 5284 5285 shape, ok := value.(map[string]interface{}) 5286 if !ok { 5287 return fmt.Errorf("unexpected JSON type %v", value) 5288 } 5289 5290 var sv *CreateComponentOutput 5291 if *v == nil { 5292 sv = &CreateComponentOutput{} 5293 } else { 5294 sv = *v 5295 } 5296 5297 for key, value := range shape { 5298 switch key { 5299 default: 5300 _, _ = key, value 5301 5302 } 5303 } 5304 *v = sv 5305 return nil 5306} 5307 5308func awsAwsjson11_deserializeOpDocumentCreateLogPatternOutput(v **CreateLogPatternOutput, value interface{}) error { 5309 if v == nil { 5310 return fmt.Errorf("unexpected nil of type %T", v) 5311 } 5312 if value == nil { 5313 return nil 5314 } 5315 5316 shape, ok := value.(map[string]interface{}) 5317 if !ok { 5318 return fmt.Errorf("unexpected JSON type %v", value) 5319 } 5320 5321 var sv *CreateLogPatternOutput 5322 if *v == nil { 5323 sv = &CreateLogPatternOutput{} 5324 } else { 5325 sv = *v 5326 } 5327 5328 for key, value := range shape { 5329 switch key { 5330 case "LogPattern": 5331 if err := awsAwsjson11_deserializeDocumentLogPattern(&sv.LogPattern, value); err != nil { 5332 return err 5333 } 5334 5335 case "ResourceGroupName": 5336 if value != nil { 5337 jtv, ok := value.(string) 5338 if !ok { 5339 return fmt.Errorf("expected ResourceGroupName to be of type string, got %T instead", value) 5340 } 5341 sv.ResourceGroupName = ptr.String(jtv) 5342 } 5343 5344 default: 5345 _, _ = key, value 5346 5347 } 5348 } 5349 *v = sv 5350 return nil 5351} 5352 5353func awsAwsjson11_deserializeOpDocumentDeleteApplicationOutput(v **DeleteApplicationOutput, value interface{}) error { 5354 if v == nil { 5355 return fmt.Errorf("unexpected nil of type %T", v) 5356 } 5357 if value == nil { 5358 return nil 5359 } 5360 5361 shape, ok := value.(map[string]interface{}) 5362 if !ok { 5363 return fmt.Errorf("unexpected JSON type %v", value) 5364 } 5365 5366 var sv *DeleteApplicationOutput 5367 if *v == nil { 5368 sv = &DeleteApplicationOutput{} 5369 } else { 5370 sv = *v 5371 } 5372 5373 for key, value := range shape { 5374 switch key { 5375 default: 5376 _, _ = key, value 5377 5378 } 5379 } 5380 *v = sv 5381 return nil 5382} 5383 5384func awsAwsjson11_deserializeOpDocumentDeleteComponentOutput(v **DeleteComponentOutput, value interface{}) error { 5385 if v == nil { 5386 return fmt.Errorf("unexpected nil of type %T", v) 5387 } 5388 if value == nil { 5389 return nil 5390 } 5391 5392 shape, ok := value.(map[string]interface{}) 5393 if !ok { 5394 return fmt.Errorf("unexpected JSON type %v", value) 5395 } 5396 5397 var sv *DeleteComponentOutput 5398 if *v == nil { 5399 sv = &DeleteComponentOutput{} 5400 } else { 5401 sv = *v 5402 } 5403 5404 for key, value := range shape { 5405 switch key { 5406 default: 5407 _, _ = key, value 5408 5409 } 5410 } 5411 *v = sv 5412 return nil 5413} 5414 5415func awsAwsjson11_deserializeOpDocumentDeleteLogPatternOutput(v **DeleteLogPatternOutput, value interface{}) error { 5416 if v == nil { 5417 return fmt.Errorf("unexpected nil of type %T", v) 5418 } 5419 if value == nil { 5420 return nil 5421 } 5422 5423 shape, ok := value.(map[string]interface{}) 5424 if !ok { 5425 return fmt.Errorf("unexpected JSON type %v", value) 5426 } 5427 5428 var sv *DeleteLogPatternOutput 5429 if *v == nil { 5430 sv = &DeleteLogPatternOutput{} 5431 } else { 5432 sv = *v 5433 } 5434 5435 for key, value := range shape { 5436 switch key { 5437 default: 5438 _, _ = key, value 5439 5440 } 5441 } 5442 *v = sv 5443 return nil 5444} 5445 5446func awsAwsjson11_deserializeOpDocumentDescribeApplicationOutput(v **DescribeApplicationOutput, value interface{}) error { 5447 if v == nil { 5448 return fmt.Errorf("unexpected nil of type %T", v) 5449 } 5450 if value == nil { 5451 return nil 5452 } 5453 5454 shape, ok := value.(map[string]interface{}) 5455 if !ok { 5456 return fmt.Errorf("unexpected JSON type %v", value) 5457 } 5458 5459 var sv *DescribeApplicationOutput 5460 if *v == nil { 5461 sv = &DescribeApplicationOutput{} 5462 } else { 5463 sv = *v 5464 } 5465 5466 for key, value := range shape { 5467 switch key { 5468 case "ApplicationInfo": 5469 if err := awsAwsjson11_deserializeDocumentApplicationInfo(&sv.ApplicationInfo, value); err != nil { 5470 return err 5471 } 5472 5473 default: 5474 _, _ = key, value 5475 5476 } 5477 } 5478 *v = sv 5479 return nil 5480} 5481 5482func awsAwsjson11_deserializeOpDocumentDescribeComponentConfigurationOutput(v **DescribeComponentConfigurationOutput, value interface{}) error { 5483 if v == nil { 5484 return fmt.Errorf("unexpected nil of type %T", v) 5485 } 5486 if value == nil { 5487 return nil 5488 } 5489 5490 shape, ok := value.(map[string]interface{}) 5491 if !ok { 5492 return fmt.Errorf("unexpected JSON type %v", value) 5493 } 5494 5495 var sv *DescribeComponentConfigurationOutput 5496 if *v == nil { 5497 sv = &DescribeComponentConfigurationOutput{} 5498 } else { 5499 sv = *v 5500 } 5501 5502 for key, value := range shape { 5503 switch key { 5504 case "ComponentConfiguration": 5505 if value != nil { 5506 jtv, ok := value.(string) 5507 if !ok { 5508 return fmt.Errorf("expected ComponentConfiguration to be of type string, got %T instead", value) 5509 } 5510 sv.ComponentConfiguration = ptr.String(jtv) 5511 } 5512 5513 case "Monitor": 5514 if value != nil { 5515 jtv, ok := value.(bool) 5516 if !ok { 5517 return fmt.Errorf("expected Monitor to be of type *bool, got %T instead", value) 5518 } 5519 sv.Monitor = ptr.Bool(jtv) 5520 } 5521 5522 case "Tier": 5523 if value != nil { 5524 jtv, ok := value.(string) 5525 if !ok { 5526 return fmt.Errorf("expected Tier to be of type string, got %T instead", value) 5527 } 5528 sv.Tier = types.Tier(jtv) 5529 } 5530 5531 default: 5532 _, _ = key, value 5533 5534 } 5535 } 5536 *v = sv 5537 return nil 5538} 5539 5540func awsAwsjson11_deserializeOpDocumentDescribeComponentConfigurationRecommendationOutput(v **DescribeComponentConfigurationRecommendationOutput, value interface{}) error { 5541 if v == nil { 5542 return fmt.Errorf("unexpected nil of type %T", v) 5543 } 5544 if value == nil { 5545 return nil 5546 } 5547 5548 shape, ok := value.(map[string]interface{}) 5549 if !ok { 5550 return fmt.Errorf("unexpected JSON type %v", value) 5551 } 5552 5553 var sv *DescribeComponentConfigurationRecommendationOutput 5554 if *v == nil { 5555 sv = &DescribeComponentConfigurationRecommendationOutput{} 5556 } else { 5557 sv = *v 5558 } 5559 5560 for key, value := range shape { 5561 switch key { 5562 case "ComponentConfiguration": 5563 if value != nil { 5564 jtv, ok := value.(string) 5565 if !ok { 5566 return fmt.Errorf("expected ComponentConfiguration to be of type string, got %T instead", value) 5567 } 5568 sv.ComponentConfiguration = ptr.String(jtv) 5569 } 5570 5571 default: 5572 _, _ = key, value 5573 5574 } 5575 } 5576 *v = sv 5577 return nil 5578} 5579 5580func awsAwsjson11_deserializeOpDocumentDescribeComponentOutput(v **DescribeComponentOutput, value interface{}) error { 5581 if v == nil { 5582 return fmt.Errorf("unexpected nil of type %T", v) 5583 } 5584 if value == nil { 5585 return nil 5586 } 5587 5588 shape, ok := value.(map[string]interface{}) 5589 if !ok { 5590 return fmt.Errorf("unexpected JSON type %v", value) 5591 } 5592 5593 var sv *DescribeComponentOutput 5594 if *v == nil { 5595 sv = &DescribeComponentOutput{} 5596 } else { 5597 sv = *v 5598 } 5599 5600 for key, value := range shape { 5601 switch key { 5602 case "ApplicationComponent": 5603 if err := awsAwsjson11_deserializeDocumentApplicationComponent(&sv.ApplicationComponent, value); err != nil { 5604 return err 5605 } 5606 5607 case "ResourceList": 5608 if err := awsAwsjson11_deserializeDocumentResourceList(&sv.ResourceList, value); err != nil { 5609 return err 5610 } 5611 5612 default: 5613 _, _ = key, value 5614 5615 } 5616 } 5617 *v = sv 5618 return nil 5619} 5620 5621func awsAwsjson11_deserializeOpDocumentDescribeLogPatternOutput(v **DescribeLogPatternOutput, value interface{}) error { 5622 if v == nil { 5623 return fmt.Errorf("unexpected nil of type %T", v) 5624 } 5625 if value == nil { 5626 return nil 5627 } 5628 5629 shape, ok := value.(map[string]interface{}) 5630 if !ok { 5631 return fmt.Errorf("unexpected JSON type %v", value) 5632 } 5633 5634 var sv *DescribeLogPatternOutput 5635 if *v == nil { 5636 sv = &DescribeLogPatternOutput{} 5637 } else { 5638 sv = *v 5639 } 5640 5641 for key, value := range shape { 5642 switch key { 5643 case "LogPattern": 5644 if err := awsAwsjson11_deserializeDocumentLogPattern(&sv.LogPattern, value); err != nil { 5645 return err 5646 } 5647 5648 case "ResourceGroupName": 5649 if value != nil { 5650 jtv, ok := value.(string) 5651 if !ok { 5652 return fmt.Errorf("expected ResourceGroupName to be of type string, got %T instead", value) 5653 } 5654 sv.ResourceGroupName = ptr.String(jtv) 5655 } 5656 5657 default: 5658 _, _ = key, value 5659 5660 } 5661 } 5662 *v = sv 5663 return nil 5664} 5665 5666func awsAwsjson11_deserializeOpDocumentDescribeObservationOutput(v **DescribeObservationOutput, value interface{}) error { 5667 if v == nil { 5668 return fmt.Errorf("unexpected nil of type %T", v) 5669 } 5670 if value == nil { 5671 return nil 5672 } 5673 5674 shape, ok := value.(map[string]interface{}) 5675 if !ok { 5676 return fmt.Errorf("unexpected JSON type %v", value) 5677 } 5678 5679 var sv *DescribeObservationOutput 5680 if *v == nil { 5681 sv = &DescribeObservationOutput{} 5682 } else { 5683 sv = *v 5684 } 5685 5686 for key, value := range shape { 5687 switch key { 5688 case "Observation": 5689 if err := awsAwsjson11_deserializeDocumentObservation(&sv.Observation, value); err != nil { 5690 return err 5691 } 5692 5693 default: 5694 _, _ = key, value 5695 5696 } 5697 } 5698 *v = sv 5699 return nil 5700} 5701 5702func awsAwsjson11_deserializeOpDocumentDescribeProblemObservationsOutput(v **DescribeProblemObservationsOutput, value interface{}) error { 5703 if v == nil { 5704 return fmt.Errorf("unexpected nil of type %T", v) 5705 } 5706 if value == nil { 5707 return nil 5708 } 5709 5710 shape, ok := value.(map[string]interface{}) 5711 if !ok { 5712 return fmt.Errorf("unexpected JSON type %v", value) 5713 } 5714 5715 var sv *DescribeProblemObservationsOutput 5716 if *v == nil { 5717 sv = &DescribeProblemObservationsOutput{} 5718 } else { 5719 sv = *v 5720 } 5721 5722 for key, value := range shape { 5723 switch key { 5724 case "RelatedObservations": 5725 if err := awsAwsjson11_deserializeDocumentRelatedObservations(&sv.RelatedObservations, value); err != nil { 5726 return err 5727 } 5728 5729 default: 5730 _, _ = key, value 5731 5732 } 5733 } 5734 *v = sv 5735 return nil 5736} 5737 5738func awsAwsjson11_deserializeOpDocumentDescribeProblemOutput(v **DescribeProblemOutput, value interface{}) error { 5739 if v == nil { 5740 return fmt.Errorf("unexpected nil of type %T", v) 5741 } 5742 if value == nil { 5743 return nil 5744 } 5745 5746 shape, ok := value.(map[string]interface{}) 5747 if !ok { 5748 return fmt.Errorf("unexpected JSON type %v", value) 5749 } 5750 5751 var sv *DescribeProblemOutput 5752 if *v == nil { 5753 sv = &DescribeProblemOutput{} 5754 } else { 5755 sv = *v 5756 } 5757 5758 for key, value := range shape { 5759 switch key { 5760 case "Problem": 5761 if err := awsAwsjson11_deserializeDocumentProblem(&sv.Problem, value); err != nil { 5762 return err 5763 } 5764 5765 default: 5766 _, _ = key, value 5767 5768 } 5769 } 5770 *v = sv 5771 return nil 5772} 5773 5774func awsAwsjson11_deserializeOpDocumentListApplicationsOutput(v **ListApplicationsOutput, value interface{}) error { 5775 if v == nil { 5776 return fmt.Errorf("unexpected nil of type %T", v) 5777 } 5778 if value == nil { 5779 return nil 5780 } 5781 5782 shape, ok := value.(map[string]interface{}) 5783 if !ok { 5784 return fmt.Errorf("unexpected JSON type %v", value) 5785 } 5786 5787 var sv *ListApplicationsOutput 5788 if *v == nil { 5789 sv = &ListApplicationsOutput{} 5790 } else { 5791 sv = *v 5792 } 5793 5794 for key, value := range shape { 5795 switch key { 5796 case "ApplicationInfoList": 5797 if err := awsAwsjson11_deserializeDocumentApplicationInfoList(&sv.ApplicationInfoList, value); err != nil { 5798 return err 5799 } 5800 5801 case "NextToken": 5802 if value != nil { 5803 jtv, ok := value.(string) 5804 if !ok { 5805 return fmt.Errorf("expected PaginationToken to be of type string, got %T instead", value) 5806 } 5807 sv.NextToken = ptr.String(jtv) 5808 } 5809 5810 default: 5811 _, _ = key, value 5812 5813 } 5814 } 5815 *v = sv 5816 return nil 5817} 5818 5819func awsAwsjson11_deserializeOpDocumentListComponentsOutput(v **ListComponentsOutput, value interface{}) error { 5820 if v == nil { 5821 return fmt.Errorf("unexpected nil of type %T", v) 5822 } 5823 if value == nil { 5824 return nil 5825 } 5826 5827 shape, ok := value.(map[string]interface{}) 5828 if !ok { 5829 return fmt.Errorf("unexpected JSON type %v", value) 5830 } 5831 5832 var sv *ListComponentsOutput 5833 if *v == nil { 5834 sv = &ListComponentsOutput{} 5835 } else { 5836 sv = *v 5837 } 5838 5839 for key, value := range shape { 5840 switch key { 5841 case "ApplicationComponentList": 5842 if err := awsAwsjson11_deserializeDocumentApplicationComponentList(&sv.ApplicationComponentList, value); err != nil { 5843 return err 5844 } 5845 5846 case "NextToken": 5847 if value != nil { 5848 jtv, ok := value.(string) 5849 if !ok { 5850 return fmt.Errorf("expected PaginationToken to be of type string, got %T instead", value) 5851 } 5852 sv.NextToken = ptr.String(jtv) 5853 } 5854 5855 default: 5856 _, _ = key, value 5857 5858 } 5859 } 5860 *v = sv 5861 return nil 5862} 5863 5864func awsAwsjson11_deserializeOpDocumentListConfigurationHistoryOutput(v **ListConfigurationHistoryOutput, value interface{}) error { 5865 if v == nil { 5866 return fmt.Errorf("unexpected nil of type %T", v) 5867 } 5868 if value == nil { 5869 return nil 5870 } 5871 5872 shape, ok := value.(map[string]interface{}) 5873 if !ok { 5874 return fmt.Errorf("unexpected JSON type %v", value) 5875 } 5876 5877 var sv *ListConfigurationHistoryOutput 5878 if *v == nil { 5879 sv = &ListConfigurationHistoryOutput{} 5880 } else { 5881 sv = *v 5882 } 5883 5884 for key, value := range shape { 5885 switch key { 5886 case "EventList": 5887 if err := awsAwsjson11_deserializeDocumentConfigurationEventList(&sv.EventList, value); err != nil { 5888 return err 5889 } 5890 5891 case "NextToken": 5892 if value != nil { 5893 jtv, ok := value.(string) 5894 if !ok { 5895 return fmt.Errorf("expected PaginationToken to be of type string, got %T instead", value) 5896 } 5897 sv.NextToken = ptr.String(jtv) 5898 } 5899 5900 default: 5901 _, _ = key, value 5902 5903 } 5904 } 5905 *v = sv 5906 return nil 5907} 5908 5909func awsAwsjson11_deserializeOpDocumentListLogPatternSetsOutput(v **ListLogPatternSetsOutput, value interface{}) error { 5910 if v == nil { 5911 return fmt.Errorf("unexpected nil of type %T", v) 5912 } 5913 if value == nil { 5914 return nil 5915 } 5916 5917 shape, ok := value.(map[string]interface{}) 5918 if !ok { 5919 return fmt.Errorf("unexpected JSON type %v", value) 5920 } 5921 5922 var sv *ListLogPatternSetsOutput 5923 if *v == nil { 5924 sv = &ListLogPatternSetsOutput{} 5925 } else { 5926 sv = *v 5927 } 5928 5929 for key, value := range shape { 5930 switch key { 5931 case "LogPatternSets": 5932 if err := awsAwsjson11_deserializeDocumentLogPatternSetList(&sv.LogPatternSets, value); err != nil { 5933 return err 5934 } 5935 5936 case "NextToken": 5937 if value != nil { 5938 jtv, ok := value.(string) 5939 if !ok { 5940 return fmt.Errorf("expected PaginationToken to be of type string, got %T instead", value) 5941 } 5942 sv.NextToken = ptr.String(jtv) 5943 } 5944 5945 case "ResourceGroupName": 5946 if value != nil { 5947 jtv, ok := value.(string) 5948 if !ok { 5949 return fmt.Errorf("expected ResourceGroupName to be of type string, got %T instead", value) 5950 } 5951 sv.ResourceGroupName = ptr.String(jtv) 5952 } 5953 5954 default: 5955 _, _ = key, value 5956 5957 } 5958 } 5959 *v = sv 5960 return nil 5961} 5962 5963func awsAwsjson11_deserializeOpDocumentListLogPatternsOutput(v **ListLogPatternsOutput, value interface{}) error { 5964 if v == nil { 5965 return fmt.Errorf("unexpected nil of type %T", v) 5966 } 5967 if value == nil { 5968 return nil 5969 } 5970 5971 shape, ok := value.(map[string]interface{}) 5972 if !ok { 5973 return fmt.Errorf("unexpected JSON type %v", value) 5974 } 5975 5976 var sv *ListLogPatternsOutput 5977 if *v == nil { 5978 sv = &ListLogPatternsOutput{} 5979 } else { 5980 sv = *v 5981 } 5982 5983 for key, value := range shape { 5984 switch key { 5985 case "LogPatterns": 5986 if err := awsAwsjson11_deserializeDocumentLogPatternList(&sv.LogPatterns, value); err != nil { 5987 return err 5988 } 5989 5990 case "NextToken": 5991 if value != nil { 5992 jtv, ok := value.(string) 5993 if !ok { 5994 return fmt.Errorf("expected PaginationToken to be of type string, got %T instead", value) 5995 } 5996 sv.NextToken = ptr.String(jtv) 5997 } 5998 5999 case "ResourceGroupName": 6000 if value != nil { 6001 jtv, ok := value.(string) 6002 if !ok { 6003 return fmt.Errorf("expected ResourceGroupName to be of type string, got %T instead", value) 6004 } 6005 sv.ResourceGroupName = ptr.String(jtv) 6006 } 6007 6008 default: 6009 _, _ = key, value 6010 6011 } 6012 } 6013 *v = sv 6014 return nil 6015} 6016 6017func awsAwsjson11_deserializeOpDocumentListProblemsOutput(v **ListProblemsOutput, value interface{}) error { 6018 if v == nil { 6019 return fmt.Errorf("unexpected nil of type %T", v) 6020 } 6021 if value == nil { 6022 return nil 6023 } 6024 6025 shape, ok := value.(map[string]interface{}) 6026 if !ok { 6027 return fmt.Errorf("unexpected JSON type %v", value) 6028 } 6029 6030 var sv *ListProblemsOutput 6031 if *v == nil { 6032 sv = &ListProblemsOutput{} 6033 } else { 6034 sv = *v 6035 } 6036 6037 for key, value := range shape { 6038 switch key { 6039 case "NextToken": 6040 if value != nil { 6041 jtv, ok := value.(string) 6042 if !ok { 6043 return fmt.Errorf("expected PaginationToken to be of type string, got %T instead", value) 6044 } 6045 sv.NextToken = ptr.String(jtv) 6046 } 6047 6048 case "ProblemList": 6049 if err := awsAwsjson11_deserializeDocumentProblemList(&sv.ProblemList, value); err != nil { 6050 return err 6051 } 6052 6053 default: 6054 _, _ = key, value 6055 6056 } 6057 } 6058 *v = sv 6059 return nil 6060} 6061 6062func awsAwsjson11_deserializeOpDocumentListTagsForResourceOutput(v **ListTagsForResourceOutput, value interface{}) error { 6063 if v == nil { 6064 return fmt.Errorf("unexpected nil of type %T", v) 6065 } 6066 if value == nil { 6067 return nil 6068 } 6069 6070 shape, ok := value.(map[string]interface{}) 6071 if !ok { 6072 return fmt.Errorf("unexpected JSON type %v", value) 6073 } 6074 6075 var sv *ListTagsForResourceOutput 6076 if *v == nil { 6077 sv = &ListTagsForResourceOutput{} 6078 } else { 6079 sv = *v 6080 } 6081 6082 for key, value := range shape { 6083 switch key { 6084 case "Tags": 6085 if err := awsAwsjson11_deserializeDocumentTagList(&sv.Tags, value); err != nil { 6086 return err 6087 } 6088 6089 default: 6090 _, _ = key, value 6091 6092 } 6093 } 6094 *v = sv 6095 return nil 6096} 6097 6098func awsAwsjson11_deserializeOpDocumentTagResourceOutput(v **TagResourceOutput, value interface{}) error { 6099 if v == nil { 6100 return fmt.Errorf("unexpected nil of type %T", v) 6101 } 6102 if value == nil { 6103 return nil 6104 } 6105 6106 shape, ok := value.(map[string]interface{}) 6107 if !ok { 6108 return fmt.Errorf("unexpected JSON type %v", value) 6109 } 6110 6111 var sv *TagResourceOutput 6112 if *v == nil { 6113 sv = &TagResourceOutput{} 6114 } else { 6115 sv = *v 6116 } 6117 6118 for key, value := range shape { 6119 switch key { 6120 default: 6121 _, _ = key, value 6122 6123 } 6124 } 6125 *v = sv 6126 return nil 6127} 6128 6129func awsAwsjson11_deserializeOpDocumentUntagResourceOutput(v **UntagResourceOutput, value interface{}) error { 6130 if v == nil { 6131 return fmt.Errorf("unexpected nil of type %T", v) 6132 } 6133 if value == nil { 6134 return nil 6135 } 6136 6137 shape, ok := value.(map[string]interface{}) 6138 if !ok { 6139 return fmt.Errorf("unexpected JSON type %v", value) 6140 } 6141 6142 var sv *UntagResourceOutput 6143 if *v == nil { 6144 sv = &UntagResourceOutput{} 6145 } else { 6146 sv = *v 6147 } 6148 6149 for key, value := range shape { 6150 switch key { 6151 default: 6152 _, _ = key, value 6153 6154 } 6155 } 6156 *v = sv 6157 return nil 6158} 6159 6160func awsAwsjson11_deserializeOpDocumentUpdateApplicationOutput(v **UpdateApplicationOutput, value interface{}) error { 6161 if v == nil { 6162 return fmt.Errorf("unexpected nil of type %T", v) 6163 } 6164 if value == nil { 6165 return nil 6166 } 6167 6168 shape, ok := value.(map[string]interface{}) 6169 if !ok { 6170 return fmt.Errorf("unexpected JSON type %v", value) 6171 } 6172 6173 var sv *UpdateApplicationOutput 6174 if *v == nil { 6175 sv = &UpdateApplicationOutput{} 6176 } else { 6177 sv = *v 6178 } 6179 6180 for key, value := range shape { 6181 switch key { 6182 case "ApplicationInfo": 6183 if err := awsAwsjson11_deserializeDocumentApplicationInfo(&sv.ApplicationInfo, value); err != nil { 6184 return err 6185 } 6186 6187 default: 6188 _, _ = key, value 6189 6190 } 6191 } 6192 *v = sv 6193 return nil 6194} 6195 6196func awsAwsjson11_deserializeOpDocumentUpdateComponentConfigurationOutput(v **UpdateComponentConfigurationOutput, value interface{}) error { 6197 if v == nil { 6198 return fmt.Errorf("unexpected nil of type %T", v) 6199 } 6200 if value == nil { 6201 return nil 6202 } 6203 6204 shape, ok := value.(map[string]interface{}) 6205 if !ok { 6206 return fmt.Errorf("unexpected JSON type %v", value) 6207 } 6208 6209 var sv *UpdateComponentConfigurationOutput 6210 if *v == nil { 6211 sv = &UpdateComponentConfigurationOutput{} 6212 } else { 6213 sv = *v 6214 } 6215 6216 for key, value := range shape { 6217 switch key { 6218 default: 6219 _, _ = key, value 6220 6221 } 6222 } 6223 *v = sv 6224 return nil 6225} 6226 6227func awsAwsjson11_deserializeOpDocumentUpdateComponentOutput(v **UpdateComponentOutput, value interface{}) error { 6228 if v == nil { 6229 return fmt.Errorf("unexpected nil of type %T", v) 6230 } 6231 if value == nil { 6232 return nil 6233 } 6234 6235 shape, ok := value.(map[string]interface{}) 6236 if !ok { 6237 return fmt.Errorf("unexpected JSON type %v", value) 6238 } 6239 6240 var sv *UpdateComponentOutput 6241 if *v == nil { 6242 sv = &UpdateComponentOutput{} 6243 } else { 6244 sv = *v 6245 } 6246 6247 for key, value := range shape { 6248 switch key { 6249 default: 6250 _, _ = key, value 6251 6252 } 6253 } 6254 *v = sv 6255 return nil 6256} 6257 6258func awsAwsjson11_deserializeOpDocumentUpdateLogPatternOutput(v **UpdateLogPatternOutput, value interface{}) error { 6259 if v == nil { 6260 return fmt.Errorf("unexpected nil of type %T", v) 6261 } 6262 if value == nil { 6263 return nil 6264 } 6265 6266 shape, ok := value.(map[string]interface{}) 6267 if !ok { 6268 return fmt.Errorf("unexpected JSON type %v", value) 6269 } 6270 6271 var sv *UpdateLogPatternOutput 6272 if *v == nil { 6273 sv = &UpdateLogPatternOutput{} 6274 } else { 6275 sv = *v 6276 } 6277 6278 for key, value := range shape { 6279 switch key { 6280 case "LogPattern": 6281 if err := awsAwsjson11_deserializeDocumentLogPattern(&sv.LogPattern, value); err != nil { 6282 return err 6283 } 6284 6285 case "ResourceGroupName": 6286 if value != nil { 6287 jtv, ok := value.(string) 6288 if !ok { 6289 return fmt.Errorf("expected ResourceGroupName to be of type string, got %T instead", value) 6290 } 6291 sv.ResourceGroupName = ptr.String(jtv) 6292 } 6293 6294 default: 6295 _, _ = key, value 6296 6297 } 6298 } 6299 *v = sv 6300 return nil 6301} 6302