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