1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package health 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/health/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 "io/ioutil" 20 "strings" 21) 22 23type awsAwsjson11_deserializeOpDescribeAffectedAccountsForOrganization struct { 24} 25 26func (*awsAwsjson11_deserializeOpDescribeAffectedAccountsForOrganization) ID() string { 27 return "OperationDeserializer" 28} 29 30func (m *awsAwsjson11_deserializeOpDescribeAffectedAccountsForOrganization) 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_deserializeOpErrorDescribeAffectedAccountsForOrganization(response, &metadata) 45 } 46 output := &DescribeAffectedAccountsForOrganizationOutput{} 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_deserializeOpDocumentDescribeAffectedAccountsForOrganizationOutput(&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_deserializeOpErrorDescribeAffectedAccountsForOrganization(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("InvalidPaginationToken", errorCode): 122 return awsAwsjson11_deserializeErrorInvalidPaginationToken(response, errorBody) 123 124 default: 125 genericError := &smithy.GenericAPIError{ 126 Code: errorCode, 127 Message: errorMessage, 128 } 129 return genericError 130 131 } 132} 133 134type awsAwsjson11_deserializeOpDescribeAffectedEntities struct { 135} 136 137func (*awsAwsjson11_deserializeOpDescribeAffectedEntities) ID() string { 138 return "OperationDeserializer" 139} 140 141func (m *awsAwsjson11_deserializeOpDescribeAffectedEntities) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 142 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 143) { 144 out, metadata, err = next.HandleDeserialize(ctx, in) 145 if err != nil { 146 return out, metadata, err 147 } 148 149 response, ok := out.RawResponse.(*smithyhttp.Response) 150 if !ok { 151 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 152 } 153 154 if response.StatusCode < 200 || response.StatusCode >= 300 { 155 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeAffectedEntities(response, &metadata) 156 } 157 output := &DescribeAffectedEntitiesOutput{} 158 out.Result = output 159 160 var buff [1024]byte 161 ringBuffer := smithyio.NewRingBuffer(buff[:]) 162 163 body := io.TeeReader(response.Body, ringBuffer) 164 decoder := json.NewDecoder(body) 165 decoder.UseNumber() 166 var shape interface{} 167 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 168 var snapshot bytes.Buffer 169 io.Copy(&snapshot, ringBuffer) 170 err = &smithy.DeserializationError{ 171 Err: fmt.Errorf("failed to decode response body, %w", err), 172 Snapshot: snapshot.Bytes(), 173 } 174 return out, metadata, err 175 } 176 177 err = awsAwsjson11_deserializeOpDocumentDescribeAffectedEntitiesOutput(&output, shape) 178 if err != nil { 179 var snapshot bytes.Buffer 180 io.Copy(&snapshot, ringBuffer) 181 err = &smithy.DeserializationError{ 182 Err: fmt.Errorf("failed to decode response body, %w", err), 183 Snapshot: snapshot.Bytes(), 184 } 185 return out, metadata, err 186 } 187 188 return out, metadata, err 189} 190 191func awsAwsjson11_deserializeOpErrorDescribeAffectedEntities(response *smithyhttp.Response, metadata *middleware.Metadata) error { 192 var errorBuffer bytes.Buffer 193 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 194 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 195 } 196 errorBody := bytes.NewReader(errorBuffer.Bytes()) 197 198 errorCode := "UnknownError" 199 errorMessage := errorCode 200 201 code := response.Header.Get("X-Amzn-ErrorType") 202 if len(code) != 0 { 203 errorCode = restjson.SanitizeErrorCode(code) 204 } 205 206 var buff [1024]byte 207 ringBuffer := smithyio.NewRingBuffer(buff[:]) 208 209 body := io.TeeReader(errorBody, ringBuffer) 210 decoder := json.NewDecoder(body) 211 decoder.UseNumber() 212 code, message, err := restjson.GetErrorInfo(decoder) 213 if err != nil { 214 var snapshot bytes.Buffer 215 io.Copy(&snapshot, ringBuffer) 216 err = &smithy.DeserializationError{ 217 Err: fmt.Errorf("failed to decode response body, %w", err), 218 Snapshot: snapshot.Bytes(), 219 } 220 return err 221 } 222 223 errorBody.Seek(0, io.SeekStart) 224 if len(code) != 0 { 225 errorCode = restjson.SanitizeErrorCode(code) 226 } 227 if len(message) != 0 { 228 errorMessage = message 229 } 230 231 switch { 232 case strings.EqualFold("InvalidPaginationToken", errorCode): 233 return awsAwsjson11_deserializeErrorInvalidPaginationToken(response, errorBody) 234 235 case strings.EqualFold("UnsupportedLocale", errorCode): 236 return awsAwsjson11_deserializeErrorUnsupportedLocale(response, errorBody) 237 238 default: 239 genericError := &smithy.GenericAPIError{ 240 Code: errorCode, 241 Message: errorMessage, 242 } 243 return genericError 244 245 } 246} 247 248type awsAwsjson11_deserializeOpDescribeAffectedEntitiesForOrganization struct { 249} 250 251func (*awsAwsjson11_deserializeOpDescribeAffectedEntitiesForOrganization) ID() string { 252 return "OperationDeserializer" 253} 254 255func (m *awsAwsjson11_deserializeOpDescribeAffectedEntitiesForOrganization) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 256 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 257) { 258 out, metadata, err = next.HandleDeserialize(ctx, in) 259 if err != nil { 260 return out, metadata, err 261 } 262 263 response, ok := out.RawResponse.(*smithyhttp.Response) 264 if !ok { 265 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 266 } 267 268 if response.StatusCode < 200 || response.StatusCode >= 300 { 269 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeAffectedEntitiesForOrganization(response, &metadata) 270 } 271 output := &DescribeAffectedEntitiesForOrganizationOutput{} 272 out.Result = output 273 274 var buff [1024]byte 275 ringBuffer := smithyio.NewRingBuffer(buff[:]) 276 277 body := io.TeeReader(response.Body, ringBuffer) 278 decoder := json.NewDecoder(body) 279 decoder.UseNumber() 280 var shape interface{} 281 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 282 var snapshot bytes.Buffer 283 io.Copy(&snapshot, ringBuffer) 284 err = &smithy.DeserializationError{ 285 Err: fmt.Errorf("failed to decode response body, %w", err), 286 Snapshot: snapshot.Bytes(), 287 } 288 return out, metadata, err 289 } 290 291 err = awsAwsjson11_deserializeOpDocumentDescribeAffectedEntitiesForOrganizationOutput(&output, shape) 292 if err != nil { 293 var snapshot bytes.Buffer 294 io.Copy(&snapshot, ringBuffer) 295 err = &smithy.DeserializationError{ 296 Err: fmt.Errorf("failed to decode response body, %w", err), 297 Snapshot: snapshot.Bytes(), 298 } 299 return out, metadata, err 300 } 301 302 return out, metadata, err 303} 304 305func awsAwsjson11_deserializeOpErrorDescribeAffectedEntitiesForOrganization(response *smithyhttp.Response, metadata *middleware.Metadata) error { 306 var errorBuffer bytes.Buffer 307 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 308 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 309 } 310 errorBody := bytes.NewReader(errorBuffer.Bytes()) 311 312 errorCode := "UnknownError" 313 errorMessage := errorCode 314 315 code := response.Header.Get("X-Amzn-ErrorType") 316 if len(code) != 0 { 317 errorCode = restjson.SanitizeErrorCode(code) 318 } 319 320 var buff [1024]byte 321 ringBuffer := smithyio.NewRingBuffer(buff[:]) 322 323 body := io.TeeReader(errorBody, ringBuffer) 324 decoder := json.NewDecoder(body) 325 decoder.UseNumber() 326 code, message, err := restjson.GetErrorInfo(decoder) 327 if err != nil { 328 var snapshot bytes.Buffer 329 io.Copy(&snapshot, ringBuffer) 330 err = &smithy.DeserializationError{ 331 Err: fmt.Errorf("failed to decode response body, %w", err), 332 Snapshot: snapshot.Bytes(), 333 } 334 return err 335 } 336 337 errorBody.Seek(0, io.SeekStart) 338 if len(code) != 0 { 339 errorCode = restjson.SanitizeErrorCode(code) 340 } 341 if len(message) != 0 { 342 errorMessage = message 343 } 344 345 switch { 346 case strings.EqualFold("InvalidPaginationToken", errorCode): 347 return awsAwsjson11_deserializeErrorInvalidPaginationToken(response, errorBody) 348 349 case strings.EqualFold("UnsupportedLocale", errorCode): 350 return awsAwsjson11_deserializeErrorUnsupportedLocale(response, errorBody) 351 352 default: 353 genericError := &smithy.GenericAPIError{ 354 Code: errorCode, 355 Message: errorMessage, 356 } 357 return genericError 358 359 } 360} 361 362type awsAwsjson11_deserializeOpDescribeEntityAggregates struct { 363} 364 365func (*awsAwsjson11_deserializeOpDescribeEntityAggregates) ID() string { 366 return "OperationDeserializer" 367} 368 369func (m *awsAwsjson11_deserializeOpDescribeEntityAggregates) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 370 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 371) { 372 out, metadata, err = next.HandleDeserialize(ctx, in) 373 if err != nil { 374 return out, metadata, err 375 } 376 377 response, ok := out.RawResponse.(*smithyhttp.Response) 378 if !ok { 379 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 380 } 381 382 if response.StatusCode < 200 || response.StatusCode >= 300 { 383 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeEntityAggregates(response, &metadata) 384 } 385 output := &DescribeEntityAggregatesOutput{} 386 out.Result = output 387 388 var buff [1024]byte 389 ringBuffer := smithyio.NewRingBuffer(buff[:]) 390 391 body := io.TeeReader(response.Body, ringBuffer) 392 decoder := json.NewDecoder(body) 393 decoder.UseNumber() 394 var shape interface{} 395 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 396 var snapshot bytes.Buffer 397 io.Copy(&snapshot, ringBuffer) 398 err = &smithy.DeserializationError{ 399 Err: fmt.Errorf("failed to decode response body, %w", err), 400 Snapshot: snapshot.Bytes(), 401 } 402 return out, metadata, err 403 } 404 405 err = awsAwsjson11_deserializeOpDocumentDescribeEntityAggregatesOutput(&output, shape) 406 if err != nil { 407 var snapshot bytes.Buffer 408 io.Copy(&snapshot, ringBuffer) 409 err = &smithy.DeserializationError{ 410 Err: fmt.Errorf("failed to decode response body, %w", err), 411 Snapshot: snapshot.Bytes(), 412 } 413 return out, metadata, err 414 } 415 416 return out, metadata, err 417} 418 419func awsAwsjson11_deserializeOpErrorDescribeEntityAggregates(response *smithyhttp.Response, metadata *middleware.Metadata) error { 420 var errorBuffer bytes.Buffer 421 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 422 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 423 } 424 errorBody := bytes.NewReader(errorBuffer.Bytes()) 425 426 errorCode := "UnknownError" 427 errorMessage := errorCode 428 429 code := response.Header.Get("X-Amzn-ErrorType") 430 if len(code) != 0 { 431 errorCode = restjson.SanitizeErrorCode(code) 432 } 433 434 var buff [1024]byte 435 ringBuffer := smithyio.NewRingBuffer(buff[:]) 436 437 body := io.TeeReader(errorBody, ringBuffer) 438 decoder := json.NewDecoder(body) 439 decoder.UseNumber() 440 code, message, err := restjson.GetErrorInfo(decoder) 441 if err != nil { 442 var snapshot bytes.Buffer 443 io.Copy(&snapshot, ringBuffer) 444 err = &smithy.DeserializationError{ 445 Err: fmt.Errorf("failed to decode response body, %w", err), 446 Snapshot: snapshot.Bytes(), 447 } 448 return err 449 } 450 451 errorBody.Seek(0, io.SeekStart) 452 if len(code) != 0 { 453 errorCode = restjson.SanitizeErrorCode(code) 454 } 455 if len(message) != 0 { 456 errorMessage = message 457 } 458 459 switch { 460 default: 461 genericError := &smithy.GenericAPIError{ 462 Code: errorCode, 463 Message: errorMessage, 464 } 465 return genericError 466 467 } 468} 469 470type awsAwsjson11_deserializeOpDescribeEventAggregates struct { 471} 472 473func (*awsAwsjson11_deserializeOpDescribeEventAggregates) ID() string { 474 return "OperationDeserializer" 475} 476 477func (m *awsAwsjson11_deserializeOpDescribeEventAggregates) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 478 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 479) { 480 out, metadata, err = next.HandleDeserialize(ctx, in) 481 if err != nil { 482 return out, metadata, err 483 } 484 485 response, ok := out.RawResponse.(*smithyhttp.Response) 486 if !ok { 487 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 488 } 489 490 if response.StatusCode < 200 || response.StatusCode >= 300 { 491 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeEventAggregates(response, &metadata) 492 } 493 output := &DescribeEventAggregatesOutput{} 494 out.Result = output 495 496 var buff [1024]byte 497 ringBuffer := smithyio.NewRingBuffer(buff[:]) 498 499 body := io.TeeReader(response.Body, ringBuffer) 500 decoder := json.NewDecoder(body) 501 decoder.UseNumber() 502 var shape interface{} 503 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 504 var snapshot bytes.Buffer 505 io.Copy(&snapshot, ringBuffer) 506 err = &smithy.DeserializationError{ 507 Err: fmt.Errorf("failed to decode response body, %w", err), 508 Snapshot: snapshot.Bytes(), 509 } 510 return out, metadata, err 511 } 512 513 err = awsAwsjson11_deserializeOpDocumentDescribeEventAggregatesOutput(&output, shape) 514 if err != nil { 515 var snapshot bytes.Buffer 516 io.Copy(&snapshot, ringBuffer) 517 err = &smithy.DeserializationError{ 518 Err: fmt.Errorf("failed to decode response body, %w", err), 519 Snapshot: snapshot.Bytes(), 520 } 521 return out, metadata, err 522 } 523 524 return out, metadata, err 525} 526 527func awsAwsjson11_deserializeOpErrorDescribeEventAggregates(response *smithyhttp.Response, metadata *middleware.Metadata) error { 528 var errorBuffer bytes.Buffer 529 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 530 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 531 } 532 errorBody := bytes.NewReader(errorBuffer.Bytes()) 533 534 errorCode := "UnknownError" 535 errorMessage := errorCode 536 537 code := response.Header.Get("X-Amzn-ErrorType") 538 if len(code) != 0 { 539 errorCode = restjson.SanitizeErrorCode(code) 540 } 541 542 var buff [1024]byte 543 ringBuffer := smithyio.NewRingBuffer(buff[:]) 544 545 body := io.TeeReader(errorBody, ringBuffer) 546 decoder := json.NewDecoder(body) 547 decoder.UseNumber() 548 code, message, err := restjson.GetErrorInfo(decoder) 549 if err != nil { 550 var snapshot bytes.Buffer 551 io.Copy(&snapshot, ringBuffer) 552 err = &smithy.DeserializationError{ 553 Err: fmt.Errorf("failed to decode response body, %w", err), 554 Snapshot: snapshot.Bytes(), 555 } 556 return err 557 } 558 559 errorBody.Seek(0, io.SeekStart) 560 if len(code) != 0 { 561 errorCode = restjson.SanitizeErrorCode(code) 562 } 563 if len(message) != 0 { 564 errorMessage = message 565 } 566 567 switch { 568 case strings.EqualFold("InvalidPaginationToken", errorCode): 569 return awsAwsjson11_deserializeErrorInvalidPaginationToken(response, errorBody) 570 571 default: 572 genericError := &smithy.GenericAPIError{ 573 Code: errorCode, 574 Message: errorMessage, 575 } 576 return genericError 577 578 } 579} 580 581type awsAwsjson11_deserializeOpDescribeEventDetails struct { 582} 583 584func (*awsAwsjson11_deserializeOpDescribeEventDetails) ID() string { 585 return "OperationDeserializer" 586} 587 588func (m *awsAwsjson11_deserializeOpDescribeEventDetails) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 589 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 590) { 591 out, metadata, err = next.HandleDeserialize(ctx, in) 592 if err != nil { 593 return out, metadata, err 594 } 595 596 response, ok := out.RawResponse.(*smithyhttp.Response) 597 if !ok { 598 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 599 } 600 601 if response.StatusCode < 200 || response.StatusCode >= 300 { 602 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeEventDetails(response, &metadata) 603 } 604 output := &DescribeEventDetailsOutput{} 605 out.Result = output 606 607 var buff [1024]byte 608 ringBuffer := smithyio.NewRingBuffer(buff[:]) 609 610 body := io.TeeReader(response.Body, ringBuffer) 611 decoder := json.NewDecoder(body) 612 decoder.UseNumber() 613 var shape interface{} 614 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 615 var snapshot bytes.Buffer 616 io.Copy(&snapshot, ringBuffer) 617 err = &smithy.DeserializationError{ 618 Err: fmt.Errorf("failed to decode response body, %w", err), 619 Snapshot: snapshot.Bytes(), 620 } 621 return out, metadata, err 622 } 623 624 err = awsAwsjson11_deserializeOpDocumentDescribeEventDetailsOutput(&output, shape) 625 if err != nil { 626 var snapshot bytes.Buffer 627 io.Copy(&snapshot, ringBuffer) 628 err = &smithy.DeserializationError{ 629 Err: fmt.Errorf("failed to decode response body, %w", err), 630 Snapshot: snapshot.Bytes(), 631 } 632 return out, metadata, err 633 } 634 635 return out, metadata, err 636} 637 638func awsAwsjson11_deserializeOpErrorDescribeEventDetails(response *smithyhttp.Response, metadata *middleware.Metadata) error { 639 var errorBuffer bytes.Buffer 640 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 641 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 642 } 643 errorBody := bytes.NewReader(errorBuffer.Bytes()) 644 645 errorCode := "UnknownError" 646 errorMessage := errorCode 647 648 code := response.Header.Get("X-Amzn-ErrorType") 649 if len(code) != 0 { 650 errorCode = restjson.SanitizeErrorCode(code) 651 } 652 653 var buff [1024]byte 654 ringBuffer := smithyio.NewRingBuffer(buff[:]) 655 656 body := io.TeeReader(errorBody, ringBuffer) 657 decoder := json.NewDecoder(body) 658 decoder.UseNumber() 659 code, message, err := restjson.GetErrorInfo(decoder) 660 if err != nil { 661 var snapshot bytes.Buffer 662 io.Copy(&snapshot, ringBuffer) 663 err = &smithy.DeserializationError{ 664 Err: fmt.Errorf("failed to decode response body, %w", err), 665 Snapshot: snapshot.Bytes(), 666 } 667 return err 668 } 669 670 errorBody.Seek(0, io.SeekStart) 671 if len(code) != 0 { 672 errorCode = restjson.SanitizeErrorCode(code) 673 } 674 if len(message) != 0 { 675 errorMessage = message 676 } 677 678 switch { 679 case strings.EqualFold("UnsupportedLocale", errorCode): 680 return awsAwsjson11_deserializeErrorUnsupportedLocale(response, errorBody) 681 682 default: 683 genericError := &smithy.GenericAPIError{ 684 Code: errorCode, 685 Message: errorMessage, 686 } 687 return genericError 688 689 } 690} 691 692type awsAwsjson11_deserializeOpDescribeEventDetailsForOrganization struct { 693} 694 695func (*awsAwsjson11_deserializeOpDescribeEventDetailsForOrganization) ID() string { 696 return "OperationDeserializer" 697} 698 699func (m *awsAwsjson11_deserializeOpDescribeEventDetailsForOrganization) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 700 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 701) { 702 out, metadata, err = next.HandleDeserialize(ctx, in) 703 if err != nil { 704 return out, metadata, err 705 } 706 707 response, ok := out.RawResponse.(*smithyhttp.Response) 708 if !ok { 709 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 710 } 711 712 if response.StatusCode < 200 || response.StatusCode >= 300 { 713 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeEventDetailsForOrganization(response, &metadata) 714 } 715 output := &DescribeEventDetailsForOrganizationOutput{} 716 out.Result = output 717 718 var buff [1024]byte 719 ringBuffer := smithyio.NewRingBuffer(buff[:]) 720 721 body := io.TeeReader(response.Body, ringBuffer) 722 decoder := json.NewDecoder(body) 723 decoder.UseNumber() 724 var shape interface{} 725 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 726 var snapshot bytes.Buffer 727 io.Copy(&snapshot, ringBuffer) 728 err = &smithy.DeserializationError{ 729 Err: fmt.Errorf("failed to decode response body, %w", err), 730 Snapshot: snapshot.Bytes(), 731 } 732 return out, metadata, err 733 } 734 735 err = awsAwsjson11_deserializeOpDocumentDescribeEventDetailsForOrganizationOutput(&output, shape) 736 if err != nil { 737 var snapshot bytes.Buffer 738 io.Copy(&snapshot, ringBuffer) 739 err = &smithy.DeserializationError{ 740 Err: fmt.Errorf("failed to decode response body, %w", err), 741 Snapshot: snapshot.Bytes(), 742 } 743 return out, metadata, err 744 } 745 746 return out, metadata, err 747} 748 749func awsAwsjson11_deserializeOpErrorDescribeEventDetailsForOrganization(response *smithyhttp.Response, metadata *middleware.Metadata) error { 750 var errorBuffer bytes.Buffer 751 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 752 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 753 } 754 errorBody := bytes.NewReader(errorBuffer.Bytes()) 755 756 errorCode := "UnknownError" 757 errorMessage := errorCode 758 759 code := response.Header.Get("X-Amzn-ErrorType") 760 if len(code) != 0 { 761 errorCode = restjson.SanitizeErrorCode(code) 762 } 763 764 var buff [1024]byte 765 ringBuffer := smithyio.NewRingBuffer(buff[:]) 766 767 body := io.TeeReader(errorBody, ringBuffer) 768 decoder := json.NewDecoder(body) 769 decoder.UseNumber() 770 code, message, err := restjson.GetErrorInfo(decoder) 771 if err != nil { 772 var snapshot bytes.Buffer 773 io.Copy(&snapshot, ringBuffer) 774 err = &smithy.DeserializationError{ 775 Err: fmt.Errorf("failed to decode response body, %w", err), 776 Snapshot: snapshot.Bytes(), 777 } 778 return err 779 } 780 781 errorBody.Seek(0, io.SeekStart) 782 if len(code) != 0 { 783 errorCode = restjson.SanitizeErrorCode(code) 784 } 785 if len(message) != 0 { 786 errorMessage = message 787 } 788 789 switch { 790 case strings.EqualFold("UnsupportedLocale", errorCode): 791 return awsAwsjson11_deserializeErrorUnsupportedLocale(response, errorBody) 792 793 default: 794 genericError := &smithy.GenericAPIError{ 795 Code: errorCode, 796 Message: errorMessage, 797 } 798 return genericError 799 800 } 801} 802 803type awsAwsjson11_deserializeOpDescribeEvents struct { 804} 805 806func (*awsAwsjson11_deserializeOpDescribeEvents) ID() string { 807 return "OperationDeserializer" 808} 809 810func (m *awsAwsjson11_deserializeOpDescribeEvents) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 811 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 812) { 813 out, metadata, err = next.HandleDeserialize(ctx, in) 814 if err != nil { 815 return out, metadata, err 816 } 817 818 response, ok := out.RawResponse.(*smithyhttp.Response) 819 if !ok { 820 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 821 } 822 823 if response.StatusCode < 200 || response.StatusCode >= 300 { 824 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeEvents(response, &metadata) 825 } 826 output := &DescribeEventsOutput{} 827 out.Result = output 828 829 var buff [1024]byte 830 ringBuffer := smithyio.NewRingBuffer(buff[:]) 831 832 body := io.TeeReader(response.Body, ringBuffer) 833 decoder := json.NewDecoder(body) 834 decoder.UseNumber() 835 var shape interface{} 836 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 837 var snapshot bytes.Buffer 838 io.Copy(&snapshot, ringBuffer) 839 err = &smithy.DeserializationError{ 840 Err: fmt.Errorf("failed to decode response body, %w", err), 841 Snapshot: snapshot.Bytes(), 842 } 843 return out, metadata, err 844 } 845 846 err = awsAwsjson11_deserializeOpDocumentDescribeEventsOutput(&output, shape) 847 if err != nil { 848 var snapshot bytes.Buffer 849 io.Copy(&snapshot, ringBuffer) 850 err = &smithy.DeserializationError{ 851 Err: fmt.Errorf("failed to decode response body, %w", err), 852 Snapshot: snapshot.Bytes(), 853 } 854 return out, metadata, err 855 } 856 857 return out, metadata, err 858} 859 860func awsAwsjson11_deserializeOpErrorDescribeEvents(response *smithyhttp.Response, metadata *middleware.Metadata) error { 861 var errorBuffer bytes.Buffer 862 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 863 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 864 } 865 errorBody := bytes.NewReader(errorBuffer.Bytes()) 866 867 errorCode := "UnknownError" 868 errorMessage := errorCode 869 870 code := response.Header.Get("X-Amzn-ErrorType") 871 if len(code) != 0 { 872 errorCode = restjson.SanitizeErrorCode(code) 873 } 874 875 var buff [1024]byte 876 ringBuffer := smithyio.NewRingBuffer(buff[:]) 877 878 body := io.TeeReader(errorBody, ringBuffer) 879 decoder := json.NewDecoder(body) 880 decoder.UseNumber() 881 code, message, err := restjson.GetErrorInfo(decoder) 882 if err != nil { 883 var snapshot bytes.Buffer 884 io.Copy(&snapshot, ringBuffer) 885 err = &smithy.DeserializationError{ 886 Err: fmt.Errorf("failed to decode response body, %w", err), 887 Snapshot: snapshot.Bytes(), 888 } 889 return err 890 } 891 892 errorBody.Seek(0, io.SeekStart) 893 if len(code) != 0 { 894 errorCode = restjson.SanitizeErrorCode(code) 895 } 896 if len(message) != 0 { 897 errorMessage = message 898 } 899 900 switch { 901 case strings.EqualFold("InvalidPaginationToken", errorCode): 902 return awsAwsjson11_deserializeErrorInvalidPaginationToken(response, errorBody) 903 904 case strings.EqualFold("UnsupportedLocale", errorCode): 905 return awsAwsjson11_deserializeErrorUnsupportedLocale(response, errorBody) 906 907 default: 908 genericError := &smithy.GenericAPIError{ 909 Code: errorCode, 910 Message: errorMessage, 911 } 912 return genericError 913 914 } 915} 916 917type awsAwsjson11_deserializeOpDescribeEventsForOrganization struct { 918} 919 920func (*awsAwsjson11_deserializeOpDescribeEventsForOrganization) ID() string { 921 return "OperationDeserializer" 922} 923 924func (m *awsAwsjson11_deserializeOpDescribeEventsForOrganization) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 925 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 926) { 927 out, metadata, err = next.HandleDeserialize(ctx, in) 928 if err != nil { 929 return out, metadata, err 930 } 931 932 response, ok := out.RawResponse.(*smithyhttp.Response) 933 if !ok { 934 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 935 } 936 937 if response.StatusCode < 200 || response.StatusCode >= 300 { 938 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeEventsForOrganization(response, &metadata) 939 } 940 output := &DescribeEventsForOrganizationOutput{} 941 out.Result = output 942 943 var buff [1024]byte 944 ringBuffer := smithyio.NewRingBuffer(buff[:]) 945 946 body := io.TeeReader(response.Body, ringBuffer) 947 decoder := json.NewDecoder(body) 948 decoder.UseNumber() 949 var shape interface{} 950 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 951 var snapshot bytes.Buffer 952 io.Copy(&snapshot, ringBuffer) 953 err = &smithy.DeserializationError{ 954 Err: fmt.Errorf("failed to decode response body, %w", err), 955 Snapshot: snapshot.Bytes(), 956 } 957 return out, metadata, err 958 } 959 960 err = awsAwsjson11_deserializeOpDocumentDescribeEventsForOrganizationOutput(&output, shape) 961 if err != nil { 962 var snapshot bytes.Buffer 963 io.Copy(&snapshot, ringBuffer) 964 err = &smithy.DeserializationError{ 965 Err: fmt.Errorf("failed to decode response body, %w", err), 966 Snapshot: snapshot.Bytes(), 967 } 968 return out, metadata, err 969 } 970 971 return out, metadata, err 972} 973 974func awsAwsjson11_deserializeOpErrorDescribeEventsForOrganization(response *smithyhttp.Response, metadata *middleware.Metadata) error { 975 var errorBuffer bytes.Buffer 976 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 977 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 978 } 979 errorBody := bytes.NewReader(errorBuffer.Bytes()) 980 981 errorCode := "UnknownError" 982 errorMessage := errorCode 983 984 code := response.Header.Get("X-Amzn-ErrorType") 985 if len(code) != 0 { 986 errorCode = restjson.SanitizeErrorCode(code) 987 } 988 989 var buff [1024]byte 990 ringBuffer := smithyio.NewRingBuffer(buff[:]) 991 992 body := io.TeeReader(errorBody, ringBuffer) 993 decoder := json.NewDecoder(body) 994 decoder.UseNumber() 995 code, message, err := restjson.GetErrorInfo(decoder) 996 if err != nil { 997 var snapshot bytes.Buffer 998 io.Copy(&snapshot, ringBuffer) 999 err = &smithy.DeserializationError{ 1000 Err: fmt.Errorf("failed to decode response body, %w", err), 1001 Snapshot: snapshot.Bytes(), 1002 } 1003 return err 1004 } 1005 1006 errorBody.Seek(0, io.SeekStart) 1007 if len(code) != 0 { 1008 errorCode = restjson.SanitizeErrorCode(code) 1009 } 1010 if len(message) != 0 { 1011 errorMessage = message 1012 } 1013 1014 switch { 1015 case strings.EqualFold("InvalidPaginationToken", errorCode): 1016 return awsAwsjson11_deserializeErrorInvalidPaginationToken(response, errorBody) 1017 1018 case strings.EqualFold("UnsupportedLocale", errorCode): 1019 return awsAwsjson11_deserializeErrorUnsupportedLocale(response, errorBody) 1020 1021 default: 1022 genericError := &smithy.GenericAPIError{ 1023 Code: errorCode, 1024 Message: errorMessage, 1025 } 1026 return genericError 1027 1028 } 1029} 1030 1031type awsAwsjson11_deserializeOpDescribeEventTypes struct { 1032} 1033 1034func (*awsAwsjson11_deserializeOpDescribeEventTypes) ID() string { 1035 return "OperationDeserializer" 1036} 1037 1038func (m *awsAwsjson11_deserializeOpDescribeEventTypes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1039 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1040) { 1041 out, metadata, err = next.HandleDeserialize(ctx, in) 1042 if err != nil { 1043 return out, metadata, err 1044 } 1045 1046 response, ok := out.RawResponse.(*smithyhttp.Response) 1047 if !ok { 1048 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1049 } 1050 1051 if response.StatusCode < 200 || response.StatusCode >= 300 { 1052 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeEventTypes(response, &metadata) 1053 } 1054 output := &DescribeEventTypesOutput{} 1055 out.Result = output 1056 1057 var buff [1024]byte 1058 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1059 1060 body := io.TeeReader(response.Body, ringBuffer) 1061 decoder := json.NewDecoder(body) 1062 decoder.UseNumber() 1063 var shape interface{} 1064 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1065 var snapshot bytes.Buffer 1066 io.Copy(&snapshot, ringBuffer) 1067 err = &smithy.DeserializationError{ 1068 Err: fmt.Errorf("failed to decode response body, %w", err), 1069 Snapshot: snapshot.Bytes(), 1070 } 1071 return out, metadata, err 1072 } 1073 1074 err = awsAwsjson11_deserializeOpDocumentDescribeEventTypesOutput(&output, shape) 1075 if err != nil { 1076 var snapshot bytes.Buffer 1077 io.Copy(&snapshot, ringBuffer) 1078 err = &smithy.DeserializationError{ 1079 Err: fmt.Errorf("failed to decode response body, %w", err), 1080 Snapshot: snapshot.Bytes(), 1081 } 1082 return out, metadata, err 1083 } 1084 1085 return out, metadata, err 1086} 1087 1088func awsAwsjson11_deserializeOpErrorDescribeEventTypes(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1089 var errorBuffer bytes.Buffer 1090 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1091 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1092 } 1093 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1094 1095 errorCode := "UnknownError" 1096 errorMessage := errorCode 1097 1098 code := response.Header.Get("X-Amzn-ErrorType") 1099 if len(code) != 0 { 1100 errorCode = restjson.SanitizeErrorCode(code) 1101 } 1102 1103 var buff [1024]byte 1104 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1105 1106 body := io.TeeReader(errorBody, ringBuffer) 1107 decoder := json.NewDecoder(body) 1108 decoder.UseNumber() 1109 code, message, err := restjson.GetErrorInfo(decoder) 1110 if err != nil { 1111 var snapshot bytes.Buffer 1112 io.Copy(&snapshot, ringBuffer) 1113 err = &smithy.DeserializationError{ 1114 Err: fmt.Errorf("failed to decode response body, %w", err), 1115 Snapshot: snapshot.Bytes(), 1116 } 1117 return err 1118 } 1119 1120 errorBody.Seek(0, io.SeekStart) 1121 if len(code) != 0 { 1122 errorCode = restjson.SanitizeErrorCode(code) 1123 } 1124 if len(message) != 0 { 1125 errorMessage = message 1126 } 1127 1128 switch { 1129 case strings.EqualFold("InvalidPaginationToken", errorCode): 1130 return awsAwsjson11_deserializeErrorInvalidPaginationToken(response, errorBody) 1131 1132 case strings.EqualFold("UnsupportedLocale", errorCode): 1133 return awsAwsjson11_deserializeErrorUnsupportedLocale(response, errorBody) 1134 1135 default: 1136 genericError := &smithy.GenericAPIError{ 1137 Code: errorCode, 1138 Message: errorMessage, 1139 } 1140 return genericError 1141 1142 } 1143} 1144 1145type awsAwsjson11_deserializeOpDescribeHealthServiceStatusForOrganization struct { 1146} 1147 1148func (*awsAwsjson11_deserializeOpDescribeHealthServiceStatusForOrganization) ID() string { 1149 return "OperationDeserializer" 1150} 1151 1152func (m *awsAwsjson11_deserializeOpDescribeHealthServiceStatusForOrganization) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1153 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1154) { 1155 out, metadata, err = next.HandleDeserialize(ctx, in) 1156 if err != nil { 1157 return out, metadata, err 1158 } 1159 1160 response, ok := out.RawResponse.(*smithyhttp.Response) 1161 if !ok { 1162 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1163 } 1164 1165 if response.StatusCode < 200 || response.StatusCode >= 300 { 1166 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeHealthServiceStatusForOrganization(response, &metadata) 1167 } 1168 output := &DescribeHealthServiceStatusForOrganizationOutput{} 1169 out.Result = output 1170 1171 var buff [1024]byte 1172 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1173 1174 body := io.TeeReader(response.Body, ringBuffer) 1175 decoder := json.NewDecoder(body) 1176 decoder.UseNumber() 1177 var shape interface{} 1178 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1179 var snapshot bytes.Buffer 1180 io.Copy(&snapshot, ringBuffer) 1181 err = &smithy.DeserializationError{ 1182 Err: fmt.Errorf("failed to decode response body, %w", err), 1183 Snapshot: snapshot.Bytes(), 1184 } 1185 return out, metadata, err 1186 } 1187 1188 err = awsAwsjson11_deserializeOpDocumentDescribeHealthServiceStatusForOrganizationOutput(&output, shape) 1189 if err != nil { 1190 var snapshot bytes.Buffer 1191 io.Copy(&snapshot, ringBuffer) 1192 err = &smithy.DeserializationError{ 1193 Err: fmt.Errorf("failed to decode response body, %w", err), 1194 Snapshot: snapshot.Bytes(), 1195 } 1196 return out, metadata, err 1197 } 1198 1199 return out, metadata, err 1200} 1201 1202func awsAwsjson11_deserializeOpErrorDescribeHealthServiceStatusForOrganization(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1203 var errorBuffer bytes.Buffer 1204 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1205 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1206 } 1207 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1208 1209 errorCode := "UnknownError" 1210 errorMessage := errorCode 1211 1212 code := response.Header.Get("X-Amzn-ErrorType") 1213 if len(code) != 0 { 1214 errorCode = restjson.SanitizeErrorCode(code) 1215 } 1216 1217 var buff [1024]byte 1218 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1219 1220 body := io.TeeReader(errorBody, ringBuffer) 1221 decoder := json.NewDecoder(body) 1222 decoder.UseNumber() 1223 code, message, err := restjson.GetErrorInfo(decoder) 1224 if err != nil { 1225 var snapshot bytes.Buffer 1226 io.Copy(&snapshot, ringBuffer) 1227 err = &smithy.DeserializationError{ 1228 Err: fmt.Errorf("failed to decode response body, %w", err), 1229 Snapshot: snapshot.Bytes(), 1230 } 1231 return err 1232 } 1233 1234 errorBody.Seek(0, io.SeekStart) 1235 if len(code) != 0 { 1236 errorCode = restjson.SanitizeErrorCode(code) 1237 } 1238 if len(message) != 0 { 1239 errorMessage = message 1240 } 1241 1242 switch { 1243 default: 1244 genericError := &smithy.GenericAPIError{ 1245 Code: errorCode, 1246 Message: errorMessage, 1247 } 1248 return genericError 1249 1250 } 1251} 1252 1253type awsAwsjson11_deserializeOpDisableHealthServiceAccessForOrganization struct { 1254} 1255 1256func (*awsAwsjson11_deserializeOpDisableHealthServiceAccessForOrganization) ID() string { 1257 return "OperationDeserializer" 1258} 1259 1260func (m *awsAwsjson11_deserializeOpDisableHealthServiceAccessForOrganization) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1261 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1262) { 1263 out, metadata, err = next.HandleDeserialize(ctx, in) 1264 if err != nil { 1265 return out, metadata, err 1266 } 1267 1268 response, ok := out.RawResponse.(*smithyhttp.Response) 1269 if !ok { 1270 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1271 } 1272 1273 if response.StatusCode < 200 || response.StatusCode >= 300 { 1274 return out, metadata, awsAwsjson11_deserializeOpErrorDisableHealthServiceAccessForOrganization(response, &metadata) 1275 } 1276 output := &DisableHealthServiceAccessForOrganizationOutput{} 1277 out.Result = output 1278 1279 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 1280 return out, metadata, &smithy.DeserializationError{ 1281 Err: fmt.Errorf("failed to discard response body, %w", err), 1282 } 1283 } 1284 1285 return out, metadata, err 1286} 1287 1288func awsAwsjson11_deserializeOpErrorDisableHealthServiceAccessForOrganization(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1289 var errorBuffer bytes.Buffer 1290 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1291 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1292 } 1293 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1294 1295 errorCode := "UnknownError" 1296 errorMessage := errorCode 1297 1298 code := response.Header.Get("X-Amzn-ErrorType") 1299 if len(code) != 0 { 1300 errorCode = restjson.SanitizeErrorCode(code) 1301 } 1302 1303 var buff [1024]byte 1304 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1305 1306 body := io.TeeReader(errorBody, ringBuffer) 1307 decoder := json.NewDecoder(body) 1308 decoder.UseNumber() 1309 code, message, err := restjson.GetErrorInfo(decoder) 1310 if err != nil { 1311 var snapshot bytes.Buffer 1312 io.Copy(&snapshot, ringBuffer) 1313 err = &smithy.DeserializationError{ 1314 Err: fmt.Errorf("failed to decode response body, %w", err), 1315 Snapshot: snapshot.Bytes(), 1316 } 1317 return err 1318 } 1319 1320 errorBody.Seek(0, io.SeekStart) 1321 if len(code) != 0 { 1322 errorCode = restjson.SanitizeErrorCode(code) 1323 } 1324 if len(message) != 0 { 1325 errorMessage = message 1326 } 1327 1328 switch { 1329 case strings.EqualFold("ConcurrentModificationException", errorCode): 1330 return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody) 1331 1332 default: 1333 genericError := &smithy.GenericAPIError{ 1334 Code: errorCode, 1335 Message: errorMessage, 1336 } 1337 return genericError 1338 1339 } 1340} 1341 1342type awsAwsjson11_deserializeOpEnableHealthServiceAccessForOrganization struct { 1343} 1344 1345func (*awsAwsjson11_deserializeOpEnableHealthServiceAccessForOrganization) ID() string { 1346 return "OperationDeserializer" 1347} 1348 1349func (m *awsAwsjson11_deserializeOpEnableHealthServiceAccessForOrganization) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1350 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1351) { 1352 out, metadata, err = next.HandleDeserialize(ctx, in) 1353 if err != nil { 1354 return out, metadata, err 1355 } 1356 1357 response, ok := out.RawResponse.(*smithyhttp.Response) 1358 if !ok { 1359 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1360 } 1361 1362 if response.StatusCode < 200 || response.StatusCode >= 300 { 1363 return out, metadata, awsAwsjson11_deserializeOpErrorEnableHealthServiceAccessForOrganization(response, &metadata) 1364 } 1365 output := &EnableHealthServiceAccessForOrganizationOutput{} 1366 out.Result = output 1367 1368 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 1369 return out, metadata, &smithy.DeserializationError{ 1370 Err: fmt.Errorf("failed to discard response body, %w", err), 1371 } 1372 } 1373 1374 return out, metadata, err 1375} 1376 1377func awsAwsjson11_deserializeOpErrorEnableHealthServiceAccessForOrganization(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1378 var errorBuffer bytes.Buffer 1379 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1380 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1381 } 1382 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1383 1384 errorCode := "UnknownError" 1385 errorMessage := errorCode 1386 1387 code := response.Header.Get("X-Amzn-ErrorType") 1388 if len(code) != 0 { 1389 errorCode = restjson.SanitizeErrorCode(code) 1390 } 1391 1392 var buff [1024]byte 1393 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1394 1395 body := io.TeeReader(errorBody, ringBuffer) 1396 decoder := json.NewDecoder(body) 1397 decoder.UseNumber() 1398 code, message, err := restjson.GetErrorInfo(decoder) 1399 if err != nil { 1400 var snapshot bytes.Buffer 1401 io.Copy(&snapshot, ringBuffer) 1402 err = &smithy.DeserializationError{ 1403 Err: fmt.Errorf("failed to decode response body, %w", err), 1404 Snapshot: snapshot.Bytes(), 1405 } 1406 return err 1407 } 1408 1409 errorBody.Seek(0, io.SeekStart) 1410 if len(code) != 0 { 1411 errorCode = restjson.SanitizeErrorCode(code) 1412 } 1413 if len(message) != 0 { 1414 errorMessage = message 1415 } 1416 1417 switch { 1418 case strings.EqualFold("ConcurrentModificationException", errorCode): 1419 return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody) 1420 1421 default: 1422 genericError := &smithy.GenericAPIError{ 1423 Code: errorCode, 1424 Message: errorMessage, 1425 } 1426 return genericError 1427 1428 } 1429} 1430 1431func awsAwsjson11_deserializeErrorConcurrentModificationException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 1432 var buff [1024]byte 1433 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1434 1435 body := io.TeeReader(errorBody, ringBuffer) 1436 decoder := json.NewDecoder(body) 1437 decoder.UseNumber() 1438 var shape interface{} 1439 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1440 var snapshot bytes.Buffer 1441 io.Copy(&snapshot, ringBuffer) 1442 err = &smithy.DeserializationError{ 1443 Err: fmt.Errorf("failed to decode response body, %w", err), 1444 Snapshot: snapshot.Bytes(), 1445 } 1446 return err 1447 } 1448 1449 output := &types.ConcurrentModificationException{} 1450 err := awsAwsjson11_deserializeDocumentConcurrentModificationException(&output, shape) 1451 1452 if err != nil { 1453 var snapshot bytes.Buffer 1454 io.Copy(&snapshot, ringBuffer) 1455 err = &smithy.DeserializationError{ 1456 Err: fmt.Errorf("failed to decode response body, %w", err), 1457 Snapshot: snapshot.Bytes(), 1458 } 1459 return err 1460 } 1461 1462 errorBody.Seek(0, io.SeekStart) 1463 return output 1464} 1465 1466func awsAwsjson11_deserializeErrorInvalidPaginationToken(response *smithyhttp.Response, errorBody *bytes.Reader) error { 1467 var buff [1024]byte 1468 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1469 1470 body := io.TeeReader(errorBody, ringBuffer) 1471 decoder := json.NewDecoder(body) 1472 decoder.UseNumber() 1473 var shape interface{} 1474 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1475 var snapshot bytes.Buffer 1476 io.Copy(&snapshot, ringBuffer) 1477 err = &smithy.DeserializationError{ 1478 Err: fmt.Errorf("failed to decode response body, %w", err), 1479 Snapshot: snapshot.Bytes(), 1480 } 1481 return err 1482 } 1483 1484 output := &types.InvalidPaginationToken{} 1485 err := awsAwsjson11_deserializeDocumentInvalidPaginationToken(&output, shape) 1486 1487 if err != nil { 1488 var snapshot bytes.Buffer 1489 io.Copy(&snapshot, ringBuffer) 1490 err = &smithy.DeserializationError{ 1491 Err: fmt.Errorf("failed to decode response body, %w", err), 1492 Snapshot: snapshot.Bytes(), 1493 } 1494 return err 1495 } 1496 1497 errorBody.Seek(0, io.SeekStart) 1498 return output 1499} 1500 1501func awsAwsjson11_deserializeErrorUnsupportedLocale(response *smithyhttp.Response, errorBody *bytes.Reader) error { 1502 var buff [1024]byte 1503 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1504 1505 body := io.TeeReader(errorBody, ringBuffer) 1506 decoder := json.NewDecoder(body) 1507 decoder.UseNumber() 1508 var shape interface{} 1509 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1510 var snapshot bytes.Buffer 1511 io.Copy(&snapshot, ringBuffer) 1512 err = &smithy.DeserializationError{ 1513 Err: fmt.Errorf("failed to decode response body, %w", err), 1514 Snapshot: snapshot.Bytes(), 1515 } 1516 return err 1517 } 1518 1519 output := &types.UnsupportedLocale{} 1520 err := awsAwsjson11_deserializeDocumentUnsupportedLocale(&output, shape) 1521 1522 if err != nil { 1523 var snapshot bytes.Buffer 1524 io.Copy(&snapshot, ringBuffer) 1525 err = &smithy.DeserializationError{ 1526 Err: fmt.Errorf("failed to decode response body, %w", err), 1527 Snapshot: snapshot.Bytes(), 1528 } 1529 return err 1530 } 1531 1532 errorBody.Seek(0, io.SeekStart) 1533 return output 1534} 1535 1536func awsAwsjson11_deserializeDocumentAffectedAccountsList(v *[]string, value interface{}) error { 1537 if v == nil { 1538 return fmt.Errorf("unexpected nil of type %T", v) 1539 } 1540 if value == nil { 1541 return nil 1542 } 1543 1544 shape, ok := value.([]interface{}) 1545 if !ok { 1546 return fmt.Errorf("unexpected JSON type %v", value) 1547 } 1548 1549 var cv []string 1550 if *v == nil { 1551 cv = []string{} 1552 } else { 1553 cv = *v 1554 } 1555 1556 for _, value := range shape { 1557 var col string 1558 if value != nil { 1559 jtv, ok := value.(string) 1560 if !ok { 1561 return fmt.Errorf("expected accountId to be of type string, got %T instead", value) 1562 } 1563 col = jtv 1564 } 1565 cv = append(cv, col) 1566 1567 } 1568 *v = cv 1569 return nil 1570} 1571 1572func awsAwsjson11_deserializeDocumentAffectedEntity(v **types.AffectedEntity, value interface{}) error { 1573 if v == nil { 1574 return fmt.Errorf("unexpected nil of type %T", v) 1575 } 1576 if value == nil { 1577 return nil 1578 } 1579 1580 shape, ok := value.(map[string]interface{}) 1581 if !ok { 1582 return fmt.Errorf("unexpected JSON type %v", value) 1583 } 1584 1585 var sv *types.AffectedEntity 1586 if *v == nil { 1587 sv = &types.AffectedEntity{} 1588 } else { 1589 sv = *v 1590 } 1591 1592 for key, value := range shape { 1593 switch key { 1594 case "awsAccountId": 1595 if value != nil { 1596 jtv, ok := value.(string) 1597 if !ok { 1598 return fmt.Errorf("expected accountId to be of type string, got %T instead", value) 1599 } 1600 sv.AwsAccountId = ptr.String(jtv) 1601 } 1602 1603 case "entityArn": 1604 if value != nil { 1605 jtv, ok := value.(string) 1606 if !ok { 1607 return fmt.Errorf("expected entityArn to be of type string, got %T instead", value) 1608 } 1609 sv.EntityArn = ptr.String(jtv) 1610 } 1611 1612 case "entityUrl": 1613 if value != nil { 1614 jtv, ok := value.(string) 1615 if !ok { 1616 return fmt.Errorf("expected entityUrl to be of type string, got %T instead", value) 1617 } 1618 sv.EntityUrl = ptr.String(jtv) 1619 } 1620 1621 case "entityValue": 1622 if value != nil { 1623 jtv, ok := value.(string) 1624 if !ok { 1625 return fmt.Errorf("expected entityValue to be of type string, got %T instead", value) 1626 } 1627 sv.EntityValue = ptr.String(jtv) 1628 } 1629 1630 case "eventArn": 1631 if value != nil { 1632 jtv, ok := value.(string) 1633 if !ok { 1634 return fmt.Errorf("expected eventArn to be of type string, got %T instead", value) 1635 } 1636 sv.EventArn = ptr.String(jtv) 1637 } 1638 1639 case "lastUpdatedTime": 1640 if value != nil { 1641 switch jtv := value.(type) { 1642 case json.Number: 1643 f64, err := jtv.Float64() 1644 if err != nil { 1645 return err 1646 } 1647 sv.LastUpdatedTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 1648 1649 default: 1650 return fmt.Errorf("expected timestamp to be a JSON Number, got %T instead", value) 1651 1652 } 1653 } 1654 1655 case "statusCode": 1656 if value != nil { 1657 jtv, ok := value.(string) 1658 if !ok { 1659 return fmt.Errorf("expected entityStatusCode to be of type string, got %T instead", value) 1660 } 1661 sv.StatusCode = types.EntityStatusCode(jtv) 1662 } 1663 1664 case "tags": 1665 if err := awsAwsjson11_deserializeDocumentTagSet(&sv.Tags, value); err != nil { 1666 return err 1667 } 1668 1669 default: 1670 _, _ = key, value 1671 1672 } 1673 } 1674 *v = sv 1675 return nil 1676} 1677 1678func awsAwsjson11_deserializeDocumentConcurrentModificationException(v **types.ConcurrentModificationException, value interface{}) error { 1679 if v == nil { 1680 return fmt.Errorf("unexpected nil of type %T", v) 1681 } 1682 if value == nil { 1683 return nil 1684 } 1685 1686 shape, ok := value.(map[string]interface{}) 1687 if !ok { 1688 return fmt.Errorf("unexpected JSON type %v", value) 1689 } 1690 1691 var sv *types.ConcurrentModificationException 1692 if *v == nil { 1693 sv = &types.ConcurrentModificationException{} 1694 } else { 1695 sv = *v 1696 } 1697 1698 for key, value := range shape { 1699 switch key { 1700 case "message": 1701 if value != nil { 1702 jtv, ok := value.(string) 1703 if !ok { 1704 return fmt.Errorf("expected string to be of type string, got %T instead", value) 1705 } 1706 sv.Message = ptr.String(jtv) 1707 } 1708 1709 default: 1710 _, _ = key, value 1711 1712 } 1713 } 1714 *v = sv 1715 return nil 1716} 1717 1718func awsAwsjson11_deserializeDocumentDescribeAffectedEntitiesForOrganizationFailedSet(v *[]types.OrganizationAffectedEntitiesErrorItem, value interface{}) error { 1719 if v == nil { 1720 return fmt.Errorf("unexpected nil of type %T", v) 1721 } 1722 if value == nil { 1723 return nil 1724 } 1725 1726 shape, ok := value.([]interface{}) 1727 if !ok { 1728 return fmt.Errorf("unexpected JSON type %v", value) 1729 } 1730 1731 var cv []types.OrganizationAffectedEntitiesErrorItem 1732 if *v == nil { 1733 cv = []types.OrganizationAffectedEntitiesErrorItem{} 1734 } else { 1735 cv = *v 1736 } 1737 1738 for _, value := range shape { 1739 var col types.OrganizationAffectedEntitiesErrorItem 1740 destAddr := &col 1741 if err := awsAwsjson11_deserializeDocumentOrganizationAffectedEntitiesErrorItem(&destAddr, value); err != nil { 1742 return err 1743 } 1744 col = *destAddr 1745 cv = append(cv, col) 1746 1747 } 1748 *v = cv 1749 return nil 1750} 1751 1752func awsAwsjson11_deserializeDocumentDescribeEventDetailsFailedSet(v *[]types.EventDetailsErrorItem, value interface{}) error { 1753 if v == nil { 1754 return fmt.Errorf("unexpected nil of type %T", v) 1755 } 1756 if value == nil { 1757 return nil 1758 } 1759 1760 shape, ok := value.([]interface{}) 1761 if !ok { 1762 return fmt.Errorf("unexpected JSON type %v", value) 1763 } 1764 1765 var cv []types.EventDetailsErrorItem 1766 if *v == nil { 1767 cv = []types.EventDetailsErrorItem{} 1768 } else { 1769 cv = *v 1770 } 1771 1772 for _, value := range shape { 1773 var col types.EventDetailsErrorItem 1774 destAddr := &col 1775 if err := awsAwsjson11_deserializeDocumentEventDetailsErrorItem(&destAddr, value); err != nil { 1776 return err 1777 } 1778 col = *destAddr 1779 cv = append(cv, col) 1780 1781 } 1782 *v = cv 1783 return nil 1784} 1785 1786func awsAwsjson11_deserializeDocumentDescribeEventDetailsForOrganizationFailedSet(v *[]types.OrganizationEventDetailsErrorItem, value interface{}) error { 1787 if v == nil { 1788 return fmt.Errorf("unexpected nil of type %T", v) 1789 } 1790 if value == nil { 1791 return nil 1792 } 1793 1794 shape, ok := value.([]interface{}) 1795 if !ok { 1796 return fmt.Errorf("unexpected JSON type %v", value) 1797 } 1798 1799 var cv []types.OrganizationEventDetailsErrorItem 1800 if *v == nil { 1801 cv = []types.OrganizationEventDetailsErrorItem{} 1802 } else { 1803 cv = *v 1804 } 1805 1806 for _, value := range shape { 1807 var col types.OrganizationEventDetailsErrorItem 1808 destAddr := &col 1809 if err := awsAwsjson11_deserializeDocumentOrganizationEventDetailsErrorItem(&destAddr, value); err != nil { 1810 return err 1811 } 1812 col = *destAddr 1813 cv = append(cv, col) 1814 1815 } 1816 *v = cv 1817 return nil 1818} 1819 1820func awsAwsjson11_deserializeDocumentDescribeEventDetailsForOrganizationSuccessfulSet(v *[]types.OrganizationEventDetails, value interface{}) error { 1821 if v == nil { 1822 return fmt.Errorf("unexpected nil of type %T", v) 1823 } 1824 if value == nil { 1825 return nil 1826 } 1827 1828 shape, ok := value.([]interface{}) 1829 if !ok { 1830 return fmt.Errorf("unexpected JSON type %v", value) 1831 } 1832 1833 var cv []types.OrganizationEventDetails 1834 if *v == nil { 1835 cv = []types.OrganizationEventDetails{} 1836 } else { 1837 cv = *v 1838 } 1839 1840 for _, value := range shape { 1841 var col types.OrganizationEventDetails 1842 destAddr := &col 1843 if err := awsAwsjson11_deserializeDocumentOrganizationEventDetails(&destAddr, value); err != nil { 1844 return err 1845 } 1846 col = *destAddr 1847 cv = append(cv, col) 1848 1849 } 1850 *v = cv 1851 return nil 1852} 1853 1854func awsAwsjson11_deserializeDocumentDescribeEventDetailsSuccessfulSet(v *[]types.EventDetails, value interface{}) error { 1855 if v == nil { 1856 return fmt.Errorf("unexpected nil of type %T", v) 1857 } 1858 if value == nil { 1859 return nil 1860 } 1861 1862 shape, ok := value.([]interface{}) 1863 if !ok { 1864 return fmt.Errorf("unexpected JSON type %v", value) 1865 } 1866 1867 var cv []types.EventDetails 1868 if *v == nil { 1869 cv = []types.EventDetails{} 1870 } else { 1871 cv = *v 1872 } 1873 1874 for _, value := range shape { 1875 var col types.EventDetails 1876 destAddr := &col 1877 if err := awsAwsjson11_deserializeDocumentEventDetails(&destAddr, value); err != nil { 1878 return err 1879 } 1880 col = *destAddr 1881 cv = append(cv, col) 1882 1883 } 1884 *v = cv 1885 return nil 1886} 1887 1888func awsAwsjson11_deserializeDocumentEntityAggregate(v **types.EntityAggregate, value interface{}) error { 1889 if v == nil { 1890 return fmt.Errorf("unexpected nil of type %T", v) 1891 } 1892 if value == nil { 1893 return nil 1894 } 1895 1896 shape, ok := value.(map[string]interface{}) 1897 if !ok { 1898 return fmt.Errorf("unexpected JSON type %v", value) 1899 } 1900 1901 var sv *types.EntityAggregate 1902 if *v == nil { 1903 sv = &types.EntityAggregate{} 1904 } else { 1905 sv = *v 1906 } 1907 1908 for key, value := range shape { 1909 switch key { 1910 case "count": 1911 if value != nil { 1912 jtv, ok := value.(json.Number) 1913 if !ok { 1914 return fmt.Errorf("expected count to be json.Number, got %T instead", value) 1915 } 1916 i64, err := jtv.Int64() 1917 if err != nil { 1918 return err 1919 } 1920 sv.Count = int32(i64) 1921 } 1922 1923 case "eventArn": 1924 if value != nil { 1925 jtv, ok := value.(string) 1926 if !ok { 1927 return fmt.Errorf("expected eventArn to be of type string, got %T instead", value) 1928 } 1929 sv.EventArn = ptr.String(jtv) 1930 } 1931 1932 default: 1933 _, _ = key, value 1934 1935 } 1936 } 1937 *v = sv 1938 return nil 1939} 1940 1941func awsAwsjson11_deserializeDocumentEntityAggregateList(v *[]types.EntityAggregate, value interface{}) error { 1942 if v == nil { 1943 return fmt.Errorf("unexpected nil of type %T", v) 1944 } 1945 if value == nil { 1946 return nil 1947 } 1948 1949 shape, ok := value.([]interface{}) 1950 if !ok { 1951 return fmt.Errorf("unexpected JSON type %v", value) 1952 } 1953 1954 var cv []types.EntityAggregate 1955 if *v == nil { 1956 cv = []types.EntityAggregate{} 1957 } else { 1958 cv = *v 1959 } 1960 1961 for _, value := range shape { 1962 var col types.EntityAggregate 1963 destAddr := &col 1964 if err := awsAwsjson11_deserializeDocumentEntityAggregate(&destAddr, value); err != nil { 1965 return err 1966 } 1967 col = *destAddr 1968 cv = append(cv, col) 1969 1970 } 1971 *v = cv 1972 return nil 1973} 1974 1975func awsAwsjson11_deserializeDocumentEntityList(v *[]types.AffectedEntity, value interface{}) error { 1976 if v == nil { 1977 return fmt.Errorf("unexpected nil of type %T", v) 1978 } 1979 if value == nil { 1980 return nil 1981 } 1982 1983 shape, ok := value.([]interface{}) 1984 if !ok { 1985 return fmt.Errorf("unexpected JSON type %v", value) 1986 } 1987 1988 var cv []types.AffectedEntity 1989 if *v == nil { 1990 cv = []types.AffectedEntity{} 1991 } else { 1992 cv = *v 1993 } 1994 1995 for _, value := range shape { 1996 var col types.AffectedEntity 1997 destAddr := &col 1998 if err := awsAwsjson11_deserializeDocumentAffectedEntity(&destAddr, value); err != nil { 1999 return err 2000 } 2001 col = *destAddr 2002 cv = append(cv, col) 2003 2004 } 2005 *v = cv 2006 return nil 2007} 2008 2009func awsAwsjson11_deserializeDocumentEvent(v **types.Event, value interface{}) error { 2010 if v == nil { 2011 return fmt.Errorf("unexpected nil of type %T", v) 2012 } 2013 if value == nil { 2014 return nil 2015 } 2016 2017 shape, ok := value.(map[string]interface{}) 2018 if !ok { 2019 return fmt.Errorf("unexpected JSON type %v", value) 2020 } 2021 2022 var sv *types.Event 2023 if *v == nil { 2024 sv = &types.Event{} 2025 } else { 2026 sv = *v 2027 } 2028 2029 for key, value := range shape { 2030 switch key { 2031 case "arn": 2032 if value != nil { 2033 jtv, ok := value.(string) 2034 if !ok { 2035 return fmt.Errorf("expected eventArn to be of type string, got %T instead", value) 2036 } 2037 sv.Arn = ptr.String(jtv) 2038 } 2039 2040 case "availabilityZone": 2041 if value != nil { 2042 jtv, ok := value.(string) 2043 if !ok { 2044 return fmt.Errorf("expected availabilityZone to be of type string, got %T instead", value) 2045 } 2046 sv.AvailabilityZone = ptr.String(jtv) 2047 } 2048 2049 case "endTime": 2050 if value != nil { 2051 switch jtv := value.(type) { 2052 case json.Number: 2053 f64, err := jtv.Float64() 2054 if err != nil { 2055 return err 2056 } 2057 sv.EndTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 2058 2059 default: 2060 return fmt.Errorf("expected timestamp to be a JSON Number, got %T instead", value) 2061 2062 } 2063 } 2064 2065 case "eventScopeCode": 2066 if value != nil { 2067 jtv, ok := value.(string) 2068 if !ok { 2069 return fmt.Errorf("expected eventScopeCode to be of type string, got %T instead", value) 2070 } 2071 sv.EventScopeCode = types.EventScopeCode(jtv) 2072 } 2073 2074 case "eventTypeCategory": 2075 if value != nil { 2076 jtv, ok := value.(string) 2077 if !ok { 2078 return fmt.Errorf("expected eventTypeCategory to be of type string, got %T instead", value) 2079 } 2080 sv.EventTypeCategory = types.EventTypeCategory(jtv) 2081 } 2082 2083 case "eventTypeCode": 2084 if value != nil { 2085 jtv, ok := value.(string) 2086 if !ok { 2087 return fmt.Errorf("expected eventTypeCode to be of type string, got %T instead", value) 2088 } 2089 sv.EventTypeCode = ptr.String(jtv) 2090 } 2091 2092 case "lastUpdatedTime": 2093 if value != nil { 2094 switch jtv := value.(type) { 2095 case json.Number: 2096 f64, err := jtv.Float64() 2097 if err != nil { 2098 return err 2099 } 2100 sv.LastUpdatedTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 2101 2102 default: 2103 return fmt.Errorf("expected timestamp to be a JSON Number, got %T instead", value) 2104 2105 } 2106 } 2107 2108 case "region": 2109 if value != nil { 2110 jtv, ok := value.(string) 2111 if !ok { 2112 return fmt.Errorf("expected region to be of type string, got %T instead", value) 2113 } 2114 sv.Region = ptr.String(jtv) 2115 } 2116 2117 case "service": 2118 if value != nil { 2119 jtv, ok := value.(string) 2120 if !ok { 2121 return fmt.Errorf("expected service to be of type string, got %T instead", value) 2122 } 2123 sv.Service = ptr.String(jtv) 2124 } 2125 2126 case "startTime": 2127 if value != nil { 2128 switch jtv := value.(type) { 2129 case json.Number: 2130 f64, err := jtv.Float64() 2131 if err != nil { 2132 return err 2133 } 2134 sv.StartTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 2135 2136 default: 2137 return fmt.Errorf("expected timestamp to be a JSON Number, got %T instead", value) 2138 2139 } 2140 } 2141 2142 case "statusCode": 2143 if value != nil { 2144 jtv, ok := value.(string) 2145 if !ok { 2146 return fmt.Errorf("expected eventStatusCode to be of type string, got %T instead", value) 2147 } 2148 sv.StatusCode = types.EventStatusCode(jtv) 2149 } 2150 2151 default: 2152 _, _ = key, value 2153 2154 } 2155 } 2156 *v = sv 2157 return nil 2158} 2159 2160func awsAwsjson11_deserializeDocumentEventAggregate(v **types.EventAggregate, value interface{}) error { 2161 if v == nil { 2162 return fmt.Errorf("unexpected nil of type %T", v) 2163 } 2164 if value == nil { 2165 return nil 2166 } 2167 2168 shape, ok := value.(map[string]interface{}) 2169 if !ok { 2170 return fmt.Errorf("unexpected JSON type %v", value) 2171 } 2172 2173 var sv *types.EventAggregate 2174 if *v == nil { 2175 sv = &types.EventAggregate{} 2176 } else { 2177 sv = *v 2178 } 2179 2180 for key, value := range shape { 2181 switch key { 2182 case "aggregateValue": 2183 if value != nil { 2184 jtv, ok := value.(string) 2185 if !ok { 2186 return fmt.Errorf("expected aggregateValue to be of type string, got %T instead", value) 2187 } 2188 sv.AggregateValue = ptr.String(jtv) 2189 } 2190 2191 case "count": 2192 if value != nil { 2193 jtv, ok := value.(json.Number) 2194 if !ok { 2195 return fmt.Errorf("expected count to be json.Number, got %T instead", value) 2196 } 2197 i64, err := jtv.Int64() 2198 if err != nil { 2199 return err 2200 } 2201 sv.Count = int32(i64) 2202 } 2203 2204 default: 2205 _, _ = key, value 2206 2207 } 2208 } 2209 *v = sv 2210 return nil 2211} 2212 2213func awsAwsjson11_deserializeDocumentEventAggregateList(v *[]types.EventAggregate, value interface{}) error { 2214 if v == nil { 2215 return fmt.Errorf("unexpected nil of type %T", v) 2216 } 2217 if value == nil { 2218 return nil 2219 } 2220 2221 shape, ok := value.([]interface{}) 2222 if !ok { 2223 return fmt.Errorf("unexpected JSON type %v", value) 2224 } 2225 2226 var cv []types.EventAggregate 2227 if *v == nil { 2228 cv = []types.EventAggregate{} 2229 } else { 2230 cv = *v 2231 } 2232 2233 for _, value := range shape { 2234 var col types.EventAggregate 2235 destAddr := &col 2236 if err := awsAwsjson11_deserializeDocumentEventAggregate(&destAddr, value); err != nil { 2237 return err 2238 } 2239 col = *destAddr 2240 cv = append(cv, col) 2241 2242 } 2243 *v = cv 2244 return nil 2245} 2246 2247func awsAwsjson11_deserializeDocumentEventDescription(v **types.EventDescription, value interface{}) error { 2248 if v == nil { 2249 return fmt.Errorf("unexpected nil of type %T", v) 2250 } 2251 if value == nil { 2252 return nil 2253 } 2254 2255 shape, ok := value.(map[string]interface{}) 2256 if !ok { 2257 return fmt.Errorf("unexpected JSON type %v", value) 2258 } 2259 2260 var sv *types.EventDescription 2261 if *v == nil { 2262 sv = &types.EventDescription{} 2263 } else { 2264 sv = *v 2265 } 2266 2267 for key, value := range shape { 2268 switch key { 2269 case "latestDescription": 2270 if value != nil { 2271 jtv, ok := value.(string) 2272 if !ok { 2273 return fmt.Errorf("expected EventDescription2 to be of type string, got %T instead", value) 2274 } 2275 sv.LatestDescription = ptr.String(jtv) 2276 } 2277 2278 default: 2279 _, _ = key, value 2280 2281 } 2282 } 2283 *v = sv 2284 return nil 2285} 2286 2287func awsAwsjson11_deserializeDocumentEventDetails(v **types.EventDetails, value interface{}) error { 2288 if v == nil { 2289 return fmt.Errorf("unexpected nil of type %T", v) 2290 } 2291 if value == nil { 2292 return nil 2293 } 2294 2295 shape, ok := value.(map[string]interface{}) 2296 if !ok { 2297 return fmt.Errorf("unexpected JSON type %v", value) 2298 } 2299 2300 var sv *types.EventDetails 2301 if *v == nil { 2302 sv = &types.EventDetails{} 2303 } else { 2304 sv = *v 2305 } 2306 2307 for key, value := range shape { 2308 switch key { 2309 case "event": 2310 if err := awsAwsjson11_deserializeDocumentEvent(&sv.Event, value); err != nil { 2311 return err 2312 } 2313 2314 case "eventDescription": 2315 if err := awsAwsjson11_deserializeDocumentEventDescription(&sv.EventDescription, value); err != nil { 2316 return err 2317 } 2318 2319 case "eventMetadata": 2320 if err := awsAwsjson11_deserializeDocumentEventMetadata(&sv.EventMetadata, value); err != nil { 2321 return err 2322 } 2323 2324 default: 2325 _, _ = key, value 2326 2327 } 2328 } 2329 *v = sv 2330 return nil 2331} 2332 2333func awsAwsjson11_deserializeDocumentEventDetailsErrorItem(v **types.EventDetailsErrorItem, value interface{}) error { 2334 if v == nil { 2335 return fmt.Errorf("unexpected nil of type %T", v) 2336 } 2337 if value == nil { 2338 return nil 2339 } 2340 2341 shape, ok := value.(map[string]interface{}) 2342 if !ok { 2343 return fmt.Errorf("unexpected JSON type %v", value) 2344 } 2345 2346 var sv *types.EventDetailsErrorItem 2347 if *v == nil { 2348 sv = &types.EventDetailsErrorItem{} 2349 } else { 2350 sv = *v 2351 } 2352 2353 for key, value := range shape { 2354 switch key { 2355 case "errorMessage": 2356 if value != nil { 2357 jtv, ok := value.(string) 2358 if !ok { 2359 return fmt.Errorf("expected string to be of type string, got %T instead", value) 2360 } 2361 sv.ErrorMessage = ptr.String(jtv) 2362 } 2363 2364 case "errorName": 2365 if value != nil { 2366 jtv, ok := value.(string) 2367 if !ok { 2368 return fmt.Errorf("expected string to be of type string, got %T instead", value) 2369 } 2370 sv.ErrorName = ptr.String(jtv) 2371 } 2372 2373 case "eventArn": 2374 if value != nil { 2375 jtv, ok := value.(string) 2376 if !ok { 2377 return fmt.Errorf("expected eventArn to be of type string, got %T instead", value) 2378 } 2379 sv.EventArn = ptr.String(jtv) 2380 } 2381 2382 default: 2383 _, _ = key, value 2384 2385 } 2386 } 2387 *v = sv 2388 return nil 2389} 2390 2391func awsAwsjson11_deserializeDocumentEventList(v *[]types.Event, value interface{}) error { 2392 if v == nil { 2393 return fmt.Errorf("unexpected nil of type %T", v) 2394 } 2395 if value == nil { 2396 return nil 2397 } 2398 2399 shape, ok := value.([]interface{}) 2400 if !ok { 2401 return fmt.Errorf("unexpected JSON type %v", value) 2402 } 2403 2404 var cv []types.Event 2405 if *v == nil { 2406 cv = []types.Event{} 2407 } else { 2408 cv = *v 2409 } 2410 2411 for _, value := range shape { 2412 var col types.Event 2413 destAddr := &col 2414 if err := awsAwsjson11_deserializeDocumentEvent(&destAddr, value); err != nil { 2415 return err 2416 } 2417 col = *destAddr 2418 cv = append(cv, col) 2419 2420 } 2421 *v = cv 2422 return nil 2423} 2424 2425func awsAwsjson11_deserializeDocumentEventMetadata(v *map[string]string, value interface{}) error { 2426 if v == nil { 2427 return fmt.Errorf("unexpected nil of type %T", v) 2428 } 2429 if value == nil { 2430 return nil 2431 } 2432 2433 shape, ok := value.(map[string]interface{}) 2434 if !ok { 2435 return fmt.Errorf("unexpected JSON type %v", value) 2436 } 2437 2438 var mv map[string]string 2439 if *v == nil { 2440 mv = map[string]string{} 2441 } else { 2442 mv = *v 2443 } 2444 2445 for key, value := range shape { 2446 var parsedVal string 2447 if value != nil { 2448 jtv, ok := value.(string) 2449 if !ok { 2450 return fmt.Errorf("expected metadataValue to be of type string, got %T instead", value) 2451 } 2452 parsedVal = jtv 2453 } 2454 mv[key] = parsedVal 2455 2456 } 2457 *v = mv 2458 return nil 2459} 2460 2461func awsAwsjson11_deserializeDocumentEventType(v **types.EventType, value interface{}) error { 2462 if v == nil { 2463 return fmt.Errorf("unexpected nil of type %T", v) 2464 } 2465 if value == nil { 2466 return nil 2467 } 2468 2469 shape, ok := value.(map[string]interface{}) 2470 if !ok { 2471 return fmt.Errorf("unexpected JSON type %v", value) 2472 } 2473 2474 var sv *types.EventType 2475 if *v == nil { 2476 sv = &types.EventType{} 2477 } else { 2478 sv = *v 2479 } 2480 2481 for key, value := range shape { 2482 switch key { 2483 case "category": 2484 if value != nil { 2485 jtv, ok := value.(string) 2486 if !ok { 2487 return fmt.Errorf("expected eventTypeCategory to be of type string, got %T instead", value) 2488 } 2489 sv.Category = types.EventTypeCategory(jtv) 2490 } 2491 2492 case "code": 2493 if value != nil { 2494 jtv, ok := value.(string) 2495 if !ok { 2496 return fmt.Errorf("expected eventTypeCode to be of type string, got %T instead", value) 2497 } 2498 sv.Code = ptr.String(jtv) 2499 } 2500 2501 case "service": 2502 if value != nil { 2503 jtv, ok := value.(string) 2504 if !ok { 2505 return fmt.Errorf("expected service to be of type string, got %T instead", value) 2506 } 2507 sv.Service = ptr.String(jtv) 2508 } 2509 2510 default: 2511 _, _ = key, value 2512 2513 } 2514 } 2515 *v = sv 2516 return nil 2517} 2518 2519func awsAwsjson11_deserializeDocumentEventTypeList(v *[]types.EventType, value interface{}) error { 2520 if v == nil { 2521 return fmt.Errorf("unexpected nil of type %T", v) 2522 } 2523 if value == nil { 2524 return nil 2525 } 2526 2527 shape, ok := value.([]interface{}) 2528 if !ok { 2529 return fmt.Errorf("unexpected JSON type %v", value) 2530 } 2531 2532 var cv []types.EventType 2533 if *v == nil { 2534 cv = []types.EventType{} 2535 } else { 2536 cv = *v 2537 } 2538 2539 for _, value := range shape { 2540 var col types.EventType 2541 destAddr := &col 2542 if err := awsAwsjson11_deserializeDocumentEventType(&destAddr, value); err != nil { 2543 return err 2544 } 2545 col = *destAddr 2546 cv = append(cv, col) 2547 2548 } 2549 *v = cv 2550 return nil 2551} 2552 2553func awsAwsjson11_deserializeDocumentInvalidPaginationToken(v **types.InvalidPaginationToken, value interface{}) error { 2554 if v == nil { 2555 return fmt.Errorf("unexpected nil of type %T", v) 2556 } 2557 if value == nil { 2558 return nil 2559 } 2560 2561 shape, ok := value.(map[string]interface{}) 2562 if !ok { 2563 return fmt.Errorf("unexpected JSON type %v", value) 2564 } 2565 2566 var sv *types.InvalidPaginationToken 2567 if *v == nil { 2568 sv = &types.InvalidPaginationToken{} 2569 } else { 2570 sv = *v 2571 } 2572 2573 for key, value := range shape { 2574 switch key { 2575 case "message": 2576 if value != nil { 2577 jtv, ok := value.(string) 2578 if !ok { 2579 return fmt.Errorf("expected string to be of type string, got %T instead", value) 2580 } 2581 sv.Message = ptr.String(jtv) 2582 } 2583 2584 default: 2585 _, _ = key, value 2586 2587 } 2588 } 2589 *v = sv 2590 return nil 2591} 2592 2593func awsAwsjson11_deserializeDocumentOrganizationAffectedEntitiesErrorItem(v **types.OrganizationAffectedEntitiesErrorItem, value interface{}) error { 2594 if v == nil { 2595 return fmt.Errorf("unexpected nil of type %T", v) 2596 } 2597 if value == nil { 2598 return nil 2599 } 2600 2601 shape, ok := value.(map[string]interface{}) 2602 if !ok { 2603 return fmt.Errorf("unexpected JSON type %v", value) 2604 } 2605 2606 var sv *types.OrganizationAffectedEntitiesErrorItem 2607 if *v == nil { 2608 sv = &types.OrganizationAffectedEntitiesErrorItem{} 2609 } else { 2610 sv = *v 2611 } 2612 2613 for key, value := range shape { 2614 switch key { 2615 case "awsAccountId": 2616 if value != nil { 2617 jtv, ok := value.(string) 2618 if !ok { 2619 return fmt.Errorf("expected accountId to be of type string, got %T instead", value) 2620 } 2621 sv.AwsAccountId = ptr.String(jtv) 2622 } 2623 2624 case "errorMessage": 2625 if value != nil { 2626 jtv, ok := value.(string) 2627 if !ok { 2628 return fmt.Errorf("expected string to be of type string, got %T instead", value) 2629 } 2630 sv.ErrorMessage = ptr.String(jtv) 2631 } 2632 2633 case "errorName": 2634 if value != nil { 2635 jtv, ok := value.(string) 2636 if !ok { 2637 return fmt.Errorf("expected string to be of type string, got %T instead", value) 2638 } 2639 sv.ErrorName = ptr.String(jtv) 2640 } 2641 2642 case "eventArn": 2643 if value != nil { 2644 jtv, ok := value.(string) 2645 if !ok { 2646 return fmt.Errorf("expected eventArn to be of type string, got %T instead", value) 2647 } 2648 sv.EventArn = ptr.String(jtv) 2649 } 2650 2651 default: 2652 _, _ = key, value 2653 2654 } 2655 } 2656 *v = sv 2657 return nil 2658} 2659 2660func awsAwsjson11_deserializeDocumentOrganizationEvent(v **types.OrganizationEvent, value interface{}) error { 2661 if v == nil { 2662 return fmt.Errorf("unexpected nil of type %T", v) 2663 } 2664 if value == nil { 2665 return nil 2666 } 2667 2668 shape, ok := value.(map[string]interface{}) 2669 if !ok { 2670 return fmt.Errorf("unexpected JSON type %v", value) 2671 } 2672 2673 var sv *types.OrganizationEvent 2674 if *v == nil { 2675 sv = &types.OrganizationEvent{} 2676 } else { 2677 sv = *v 2678 } 2679 2680 for key, value := range shape { 2681 switch key { 2682 case "arn": 2683 if value != nil { 2684 jtv, ok := value.(string) 2685 if !ok { 2686 return fmt.Errorf("expected eventArn to be of type string, got %T instead", value) 2687 } 2688 sv.Arn = ptr.String(jtv) 2689 } 2690 2691 case "endTime": 2692 if value != nil { 2693 switch jtv := value.(type) { 2694 case json.Number: 2695 f64, err := jtv.Float64() 2696 if err != nil { 2697 return err 2698 } 2699 sv.EndTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 2700 2701 default: 2702 return fmt.Errorf("expected timestamp to be a JSON Number, got %T instead", value) 2703 2704 } 2705 } 2706 2707 case "eventScopeCode": 2708 if value != nil { 2709 jtv, ok := value.(string) 2710 if !ok { 2711 return fmt.Errorf("expected eventScopeCode to be of type string, got %T instead", value) 2712 } 2713 sv.EventScopeCode = types.EventScopeCode(jtv) 2714 } 2715 2716 case "eventTypeCategory": 2717 if value != nil { 2718 jtv, ok := value.(string) 2719 if !ok { 2720 return fmt.Errorf("expected eventTypeCategory to be of type string, got %T instead", value) 2721 } 2722 sv.EventTypeCategory = types.EventTypeCategory(jtv) 2723 } 2724 2725 case "eventTypeCode": 2726 if value != nil { 2727 jtv, ok := value.(string) 2728 if !ok { 2729 return fmt.Errorf("expected eventTypeCode to be of type string, got %T instead", value) 2730 } 2731 sv.EventTypeCode = ptr.String(jtv) 2732 } 2733 2734 case "lastUpdatedTime": 2735 if value != nil { 2736 switch jtv := value.(type) { 2737 case json.Number: 2738 f64, err := jtv.Float64() 2739 if err != nil { 2740 return err 2741 } 2742 sv.LastUpdatedTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 2743 2744 default: 2745 return fmt.Errorf("expected timestamp to be a JSON Number, got %T instead", value) 2746 2747 } 2748 } 2749 2750 case "region": 2751 if value != nil { 2752 jtv, ok := value.(string) 2753 if !ok { 2754 return fmt.Errorf("expected region to be of type string, got %T instead", value) 2755 } 2756 sv.Region = ptr.String(jtv) 2757 } 2758 2759 case "service": 2760 if value != nil { 2761 jtv, ok := value.(string) 2762 if !ok { 2763 return fmt.Errorf("expected service to be of type string, got %T instead", value) 2764 } 2765 sv.Service = ptr.String(jtv) 2766 } 2767 2768 case "startTime": 2769 if value != nil { 2770 switch jtv := value.(type) { 2771 case json.Number: 2772 f64, err := jtv.Float64() 2773 if err != nil { 2774 return err 2775 } 2776 sv.StartTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 2777 2778 default: 2779 return fmt.Errorf("expected timestamp to be a JSON Number, got %T instead", value) 2780 2781 } 2782 } 2783 2784 case "statusCode": 2785 if value != nil { 2786 jtv, ok := value.(string) 2787 if !ok { 2788 return fmt.Errorf("expected eventStatusCode to be of type string, got %T instead", value) 2789 } 2790 sv.StatusCode = types.EventStatusCode(jtv) 2791 } 2792 2793 default: 2794 _, _ = key, value 2795 2796 } 2797 } 2798 *v = sv 2799 return nil 2800} 2801 2802func awsAwsjson11_deserializeDocumentOrganizationEventDetails(v **types.OrganizationEventDetails, value interface{}) error { 2803 if v == nil { 2804 return fmt.Errorf("unexpected nil of type %T", v) 2805 } 2806 if value == nil { 2807 return nil 2808 } 2809 2810 shape, ok := value.(map[string]interface{}) 2811 if !ok { 2812 return fmt.Errorf("unexpected JSON type %v", value) 2813 } 2814 2815 var sv *types.OrganizationEventDetails 2816 if *v == nil { 2817 sv = &types.OrganizationEventDetails{} 2818 } else { 2819 sv = *v 2820 } 2821 2822 for key, value := range shape { 2823 switch key { 2824 case "awsAccountId": 2825 if value != nil { 2826 jtv, ok := value.(string) 2827 if !ok { 2828 return fmt.Errorf("expected accountId to be of type string, got %T instead", value) 2829 } 2830 sv.AwsAccountId = ptr.String(jtv) 2831 } 2832 2833 case "event": 2834 if err := awsAwsjson11_deserializeDocumentEvent(&sv.Event, value); err != nil { 2835 return err 2836 } 2837 2838 case "eventDescription": 2839 if err := awsAwsjson11_deserializeDocumentEventDescription(&sv.EventDescription, value); err != nil { 2840 return err 2841 } 2842 2843 case "eventMetadata": 2844 if err := awsAwsjson11_deserializeDocumentEventMetadata(&sv.EventMetadata, value); err != nil { 2845 return err 2846 } 2847 2848 default: 2849 _, _ = key, value 2850 2851 } 2852 } 2853 *v = sv 2854 return nil 2855} 2856 2857func awsAwsjson11_deserializeDocumentOrganizationEventDetailsErrorItem(v **types.OrganizationEventDetailsErrorItem, value interface{}) error { 2858 if v == nil { 2859 return fmt.Errorf("unexpected nil of type %T", v) 2860 } 2861 if value == nil { 2862 return nil 2863 } 2864 2865 shape, ok := value.(map[string]interface{}) 2866 if !ok { 2867 return fmt.Errorf("unexpected JSON type %v", value) 2868 } 2869 2870 var sv *types.OrganizationEventDetailsErrorItem 2871 if *v == nil { 2872 sv = &types.OrganizationEventDetailsErrorItem{} 2873 } else { 2874 sv = *v 2875 } 2876 2877 for key, value := range shape { 2878 switch key { 2879 case "awsAccountId": 2880 if value != nil { 2881 jtv, ok := value.(string) 2882 if !ok { 2883 return fmt.Errorf("expected accountId to be of type string, got %T instead", value) 2884 } 2885 sv.AwsAccountId = ptr.String(jtv) 2886 } 2887 2888 case "errorMessage": 2889 if value != nil { 2890 jtv, ok := value.(string) 2891 if !ok { 2892 return fmt.Errorf("expected string to be of type string, got %T instead", value) 2893 } 2894 sv.ErrorMessage = ptr.String(jtv) 2895 } 2896 2897 case "errorName": 2898 if value != nil { 2899 jtv, ok := value.(string) 2900 if !ok { 2901 return fmt.Errorf("expected string to be of type string, got %T instead", value) 2902 } 2903 sv.ErrorName = ptr.String(jtv) 2904 } 2905 2906 case "eventArn": 2907 if value != nil { 2908 jtv, ok := value.(string) 2909 if !ok { 2910 return fmt.Errorf("expected eventArn to be of type string, got %T instead", value) 2911 } 2912 sv.EventArn = ptr.String(jtv) 2913 } 2914 2915 default: 2916 _, _ = key, value 2917 2918 } 2919 } 2920 *v = sv 2921 return nil 2922} 2923 2924func awsAwsjson11_deserializeDocumentOrganizationEventList(v *[]types.OrganizationEvent, value interface{}) error { 2925 if v == nil { 2926 return fmt.Errorf("unexpected nil of type %T", v) 2927 } 2928 if value == nil { 2929 return nil 2930 } 2931 2932 shape, ok := value.([]interface{}) 2933 if !ok { 2934 return fmt.Errorf("unexpected JSON type %v", value) 2935 } 2936 2937 var cv []types.OrganizationEvent 2938 if *v == nil { 2939 cv = []types.OrganizationEvent{} 2940 } else { 2941 cv = *v 2942 } 2943 2944 for _, value := range shape { 2945 var col types.OrganizationEvent 2946 destAddr := &col 2947 if err := awsAwsjson11_deserializeDocumentOrganizationEvent(&destAddr, value); err != nil { 2948 return err 2949 } 2950 col = *destAddr 2951 cv = append(cv, col) 2952 2953 } 2954 *v = cv 2955 return nil 2956} 2957 2958func awsAwsjson11_deserializeDocumentTagSet(v *map[string]string, value interface{}) error { 2959 if v == nil { 2960 return fmt.Errorf("unexpected nil of type %T", v) 2961 } 2962 if value == nil { 2963 return nil 2964 } 2965 2966 shape, ok := value.(map[string]interface{}) 2967 if !ok { 2968 return fmt.Errorf("unexpected JSON type %v", value) 2969 } 2970 2971 var mv map[string]string 2972 if *v == nil { 2973 mv = map[string]string{} 2974 } else { 2975 mv = *v 2976 } 2977 2978 for key, value := range shape { 2979 var parsedVal string 2980 if value != nil { 2981 jtv, ok := value.(string) 2982 if !ok { 2983 return fmt.Errorf("expected tagValue to be of type string, got %T instead", value) 2984 } 2985 parsedVal = jtv 2986 } 2987 mv[key] = parsedVal 2988 2989 } 2990 *v = mv 2991 return nil 2992} 2993 2994func awsAwsjson11_deserializeDocumentUnsupportedLocale(v **types.UnsupportedLocale, value interface{}) error { 2995 if v == nil { 2996 return fmt.Errorf("unexpected nil of type %T", v) 2997 } 2998 if value == nil { 2999 return nil 3000 } 3001 3002 shape, ok := value.(map[string]interface{}) 3003 if !ok { 3004 return fmt.Errorf("unexpected JSON type %v", value) 3005 } 3006 3007 var sv *types.UnsupportedLocale 3008 if *v == nil { 3009 sv = &types.UnsupportedLocale{} 3010 } else { 3011 sv = *v 3012 } 3013 3014 for key, value := range shape { 3015 switch key { 3016 case "message": 3017 if value != nil { 3018 jtv, ok := value.(string) 3019 if !ok { 3020 return fmt.Errorf("expected string to be of type string, got %T instead", value) 3021 } 3022 sv.Message = ptr.String(jtv) 3023 } 3024 3025 default: 3026 _, _ = key, value 3027 3028 } 3029 } 3030 *v = sv 3031 return nil 3032} 3033 3034func awsAwsjson11_deserializeOpDocumentDescribeAffectedAccountsForOrganizationOutput(v **DescribeAffectedAccountsForOrganizationOutput, value interface{}) error { 3035 if v == nil { 3036 return fmt.Errorf("unexpected nil of type %T", v) 3037 } 3038 if value == nil { 3039 return nil 3040 } 3041 3042 shape, ok := value.(map[string]interface{}) 3043 if !ok { 3044 return fmt.Errorf("unexpected JSON type %v", value) 3045 } 3046 3047 var sv *DescribeAffectedAccountsForOrganizationOutput 3048 if *v == nil { 3049 sv = &DescribeAffectedAccountsForOrganizationOutput{} 3050 } else { 3051 sv = *v 3052 } 3053 3054 for key, value := range shape { 3055 switch key { 3056 case "affectedAccounts": 3057 if err := awsAwsjson11_deserializeDocumentAffectedAccountsList(&sv.AffectedAccounts, value); err != nil { 3058 return err 3059 } 3060 3061 case "eventScopeCode": 3062 if value != nil { 3063 jtv, ok := value.(string) 3064 if !ok { 3065 return fmt.Errorf("expected eventScopeCode to be of type string, got %T instead", value) 3066 } 3067 sv.EventScopeCode = types.EventScopeCode(jtv) 3068 } 3069 3070 case "nextToken": 3071 if value != nil { 3072 jtv, ok := value.(string) 3073 if !ok { 3074 return fmt.Errorf("expected nextToken to be of type string, got %T instead", value) 3075 } 3076 sv.NextToken = ptr.String(jtv) 3077 } 3078 3079 default: 3080 _, _ = key, value 3081 3082 } 3083 } 3084 *v = sv 3085 return nil 3086} 3087 3088func awsAwsjson11_deserializeOpDocumentDescribeAffectedEntitiesForOrganizationOutput(v **DescribeAffectedEntitiesForOrganizationOutput, value interface{}) error { 3089 if v == nil { 3090 return fmt.Errorf("unexpected nil of type %T", v) 3091 } 3092 if value == nil { 3093 return nil 3094 } 3095 3096 shape, ok := value.(map[string]interface{}) 3097 if !ok { 3098 return fmt.Errorf("unexpected JSON type %v", value) 3099 } 3100 3101 var sv *DescribeAffectedEntitiesForOrganizationOutput 3102 if *v == nil { 3103 sv = &DescribeAffectedEntitiesForOrganizationOutput{} 3104 } else { 3105 sv = *v 3106 } 3107 3108 for key, value := range shape { 3109 switch key { 3110 case "entities": 3111 if err := awsAwsjson11_deserializeDocumentEntityList(&sv.Entities, value); err != nil { 3112 return err 3113 } 3114 3115 case "failedSet": 3116 if err := awsAwsjson11_deserializeDocumentDescribeAffectedEntitiesForOrganizationFailedSet(&sv.FailedSet, value); err != nil { 3117 return err 3118 } 3119 3120 case "nextToken": 3121 if value != nil { 3122 jtv, ok := value.(string) 3123 if !ok { 3124 return fmt.Errorf("expected nextToken to be of type string, got %T instead", value) 3125 } 3126 sv.NextToken = ptr.String(jtv) 3127 } 3128 3129 default: 3130 _, _ = key, value 3131 3132 } 3133 } 3134 *v = sv 3135 return nil 3136} 3137 3138func awsAwsjson11_deserializeOpDocumentDescribeAffectedEntitiesOutput(v **DescribeAffectedEntitiesOutput, value interface{}) error { 3139 if v == nil { 3140 return fmt.Errorf("unexpected nil of type %T", v) 3141 } 3142 if value == nil { 3143 return nil 3144 } 3145 3146 shape, ok := value.(map[string]interface{}) 3147 if !ok { 3148 return fmt.Errorf("unexpected JSON type %v", value) 3149 } 3150 3151 var sv *DescribeAffectedEntitiesOutput 3152 if *v == nil { 3153 sv = &DescribeAffectedEntitiesOutput{} 3154 } else { 3155 sv = *v 3156 } 3157 3158 for key, value := range shape { 3159 switch key { 3160 case "entities": 3161 if err := awsAwsjson11_deserializeDocumentEntityList(&sv.Entities, value); err != nil { 3162 return err 3163 } 3164 3165 case "nextToken": 3166 if value != nil { 3167 jtv, ok := value.(string) 3168 if !ok { 3169 return fmt.Errorf("expected nextToken to be of type string, got %T instead", value) 3170 } 3171 sv.NextToken = ptr.String(jtv) 3172 } 3173 3174 default: 3175 _, _ = key, value 3176 3177 } 3178 } 3179 *v = sv 3180 return nil 3181} 3182 3183func awsAwsjson11_deserializeOpDocumentDescribeEntityAggregatesOutput(v **DescribeEntityAggregatesOutput, value interface{}) error { 3184 if v == nil { 3185 return fmt.Errorf("unexpected nil of type %T", v) 3186 } 3187 if value == nil { 3188 return nil 3189 } 3190 3191 shape, ok := value.(map[string]interface{}) 3192 if !ok { 3193 return fmt.Errorf("unexpected JSON type %v", value) 3194 } 3195 3196 var sv *DescribeEntityAggregatesOutput 3197 if *v == nil { 3198 sv = &DescribeEntityAggregatesOutput{} 3199 } else { 3200 sv = *v 3201 } 3202 3203 for key, value := range shape { 3204 switch key { 3205 case "entityAggregates": 3206 if err := awsAwsjson11_deserializeDocumentEntityAggregateList(&sv.EntityAggregates, value); err != nil { 3207 return err 3208 } 3209 3210 default: 3211 _, _ = key, value 3212 3213 } 3214 } 3215 *v = sv 3216 return nil 3217} 3218 3219func awsAwsjson11_deserializeOpDocumentDescribeEventAggregatesOutput(v **DescribeEventAggregatesOutput, value interface{}) error { 3220 if v == nil { 3221 return fmt.Errorf("unexpected nil of type %T", v) 3222 } 3223 if value == nil { 3224 return nil 3225 } 3226 3227 shape, ok := value.(map[string]interface{}) 3228 if !ok { 3229 return fmt.Errorf("unexpected JSON type %v", value) 3230 } 3231 3232 var sv *DescribeEventAggregatesOutput 3233 if *v == nil { 3234 sv = &DescribeEventAggregatesOutput{} 3235 } else { 3236 sv = *v 3237 } 3238 3239 for key, value := range shape { 3240 switch key { 3241 case "eventAggregates": 3242 if err := awsAwsjson11_deserializeDocumentEventAggregateList(&sv.EventAggregates, value); err != nil { 3243 return err 3244 } 3245 3246 case "nextToken": 3247 if value != nil { 3248 jtv, ok := value.(string) 3249 if !ok { 3250 return fmt.Errorf("expected nextToken to be of type string, got %T instead", value) 3251 } 3252 sv.NextToken = ptr.String(jtv) 3253 } 3254 3255 default: 3256 _, _ = key, value 3257 3258 } 3259 } 3260 *v = sv 3261 return nil 3262} 3263 3264func awsAwsjson11_deserializeOpDocumentDescribeEventDetailsForOrganizationOutput(v **DescribeEventDetailsForOrganizationOutput, value interface{}) error { 3265 if v == nil { 3266 return fmt.Errorf("unexpected nil of type %T", v) 3267 } 3268 if value == nil { 3269 return nil 3270 } 3271 3272 shape, ok := value.(map[string]interface{}) 3273 if !ok { 3274 return fmt.Errorf("unexpected JSON type %v", value) 3275 } 3276 3277 var sv *DescribeEventDetailsForOrganizationOutput 3278 if *v == nil { 3279 sv = &DescribeEventDetailsForOrganizationOutput{} 3280 } else { 3281 sv = *v 3282 } 3283 3284 for key, value := range shape { 3285 switch key { 3286 case "failedSet": 3287 if err := awsAwsjson11_deserializeDocumentDescribeEventDetailsForOrganizationFailedSet(&sv.FailedSet, value); err != nil { 3288 return err 3289 } 3290 3291 case "successfulSet": 3292 if err := awsAwsjson11_deserializeDocumentDescribeEventDetailsForOrganizationSuccessfulSet(&sv.SuccessfulSet, value); err != nil { 3293 return err 3294 } 3295 3296 default: 3297 _, _ = key, value 3298 3299 } 3300 } 3301 *v = sv 3302 return nil 3303} 3304 3305func awsAwsjson11_deserializeOpDocumentDescribeEventDetailsOutput(v **DescribeEventDetailsOutput, value interface{}) error { 3306 if v == nil { 3307 return fmt.Errorf("unexpected nil of type %T", v) 3308 } 3309 if value == nil { 3310 return nil 3311 } 3312 3313 shape, ok := value.(map[string]interface{}) 3314 if !ok { 3315 return fmt.Errorf("unexpected JSON type %v", value) 3316 } 3317 3318 var sv *DescribeEventDetailsOutput 3319 if *v == nil { 3320 sv = &DescribeEventDetailsOutput{} 3321 } else { 3322 sv = *v 3323 } 3324 3325 for key, value := range shape { 3326 switch key { 3327 case "failedSet": 3328 if err := awsAwsjson11_deserializeDocumentDescribeEventDetailsFailedSet(&sv.FailedSet, value); err != nil { 3329 return err 3330 } 3331 3332 case "successfulSet": 3333 if err := awsAwsjson11_deserializeDocumentDescribeEventDetailsSuccessfulSet(&sv.SuccessfulSet, value); err != nil { 3334 return err 3335 } 3336 3337 default: 3338 _, _ = key, value 3339 3340 } 3341 } 3342 *v = sv 3343 return nil 3344} 3345 3346func awsAwsjson11_deserializeOpDocumentDescribeEventsForOrganizationOutput(v **DescribeEventsForOrganizationOutput, value interface{}) error { 3347 if v == nil { 3348 return fmt.Errorf("unexpected nil of type %T", v) 3349 } 3350 if value == nil { 3351 return nil 3352 } 3353 3354 shape, ok := value.(map[string]interface{}) 3355 if !ok { 3356 return fmt.Errorf("unexpected JSON type %v", value) 3357 } 3358 3359 var sv *DescribeEventsForOrganizationOutput 3360 if *v == nil { 3361 sv = &DescribeEventsForOrganizationOutput{} 3362 } else { 3363 sv = *v 3364 } 3365 3366 for key, value := range shape { 3367 switch key { 3368 case "events": 3369 if err := awsAwsjson11_deserializeDocumentOrganizationEventList(&sv.Events, value); err != nil { 3370 return err 3371 } 3372 3373 case "nextToken": 3374 if value != nil { 3375 jtv, ok := value.(string) 3376 if !ok { 3377 return fmt.Errorf("expected nextToken to be of type string, got %T instead", value) 3378 } 3379 sv.NextToken = ptr.String(jtv) 3380 } 3381 3382 default: 3383 _, _ = key, value 3384 3385 } 3386 } 3387 *v = sv 3388 return nil 3389} 3390 3391func awsAwsjson11_deserializeOpDocumentDescribeEventsOutput(v **DescribeEventsOutput, value interface{}) error { 3392 if v == nil { 3393 return fmt.Errorf("unexpected nil of type %T", v) 3394 } 3395 if value == nil { 3396 return nil 3397 } 3398 3399 shape, ok := value.(map[string]interface{}) 3400 if !ok { 3401 return fmt.Errorf("unexpected JSON type %v", value) 3402 } 3403 3404 var sv *DescribeEventsOutput 3405 if *v == nil { 3406 sv = &DescribeEventsOutput{} 3407 } else { 3408 sv = *v 3409 } 3410 3411 for key, value := range shape { 3412 switch key { 3413 case "events": 3414 if err := awsAwsjson11_deserializeDocumentEventList(&sv.Events, value); err != nil { 3415 return err 3416 } 3417 3418 case "nextToken": 3419 if value != nil { 3420 jtv, ok := value.(string) 3421 if !ok { 3422 return fmt.Errorf("expected nextToken to be of type string, got %T instead", value) 3423 } 3424 sv.NextToken = ptr.String(jtv) 3425 } 3426 3427 default: 3428 _, _ = key, value 3429 3430 } 3431 } 3432 *v = sv 3433 return nil 3434} 3435 3436func awsAwsjson11_deserializeOpDocumentDescribeEventTypesOutput(v **DescribeEventTypesOutput, value interface{}) error { 3437 if v == nil { 3438 return fmt.Errorf("unexpected nil of type %T", v) 3439 } 3440 if value == nil { 3441 return nil 3442 } 3443 3444 shape, ok := value.(map[string]interface{}) 3445 if !ok { 3446 return fmt.Errorf("unexpected JSON type %v", value) 3447 } 3448 3449 var sv *DescribeEventTypesOutput 3450 if *v == nil { 3451 sv = &DescribeEventTypesOutput{} 3452 } else { 3453 sv = *v 3454 } 3455 3456 for key, value := range shape { 3457 switch key { 3458 case "eventTypes": 3459 if err := awsAwsjson11_deserializeDocumentEventTypeList(&sv.EventTypes, value); err != nil { 3460 return err 3461 } 3462 3463 case "nextToken": 3464 if value != nil { 3465 jtv, ok := value.(string) 3466 if !ok { 3467 return fmt.Errorf("expected nextToken to be of type string, got %T instead", value) 3468 } 3469 sv.NextToken = ptr.String(jtv) 3470 } 3471 3472 default: 3473 _, _ = key, value 3474 3475 } 3476 } 3477 *v = sv 3478 return nil 3479} 3480 3481func awsAwsjson11_deserializeOpDocumentDescribeHealthServiceStatusForOrganizationOutput(v **DescribeHealthServiceStatusForOrganizationOutput, value interface{}) error { 3482 if v == nil { 3483 return fmt.Errorf("unexpected nil of type %T", v) 3484 } 3485 if value == nil { 3486 return nil 3487 } 3488 3489 shape, ok := value.(map[string]interface{}) 3490 if !ok { 3491 return fmt.Errorf("unexpected JSON type %v", value) 3492 } 3493 3494 var sv *DescribeHealthServiceStatusForOrganizationOutput 3495 if *v == nil { 3496 sv = &DescribeHealthServiceStatusForOrganizationOutput{} 3497 } else { 3498 sv = *v 3499 } 3500 3501 for key, value := range shape { 3502 switch key { 3503 case "healthServiceAccessStatusForOrganization": 3504 if value != nil { 3505 jtv, ok := value.(string) 3506 if !ok { 3507 return fmt.Errorf("expected healthServiceAccessStatusForOrganization to be of type string, got %T instead", value) 3508 } 3509 sv.HealthServiceAccessStatusForOrganization = ptr.String(jtv) 3510 } 3511 3512 default: 3513 _, _ = key, value 3514 3515 } 3516 } 3517 *v = sv 3518 return nil 3519} 3520