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 jtv, ok := value.(json.Number) 1642 if !ok { 1643 return fmt.Errorf("expected timestamp to be json.Number, got %T instead", value) 1644 } 1645 f64, err := jtv.Float64() 1646 if err != nil { 1647 return err 1648 } 1649 sv.LastUpdatedTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 1650 } 1651 1652 case "statusCode": 1653 if value != nil { 1654 jtv, ok := value.(string) 1655 if !ok { 1656 return fmt.Errorf("expected entityStatusCode to be of type string, got %T instead", value) 1657 } 1658 sv.StatusCode = types.EntityStatusCode(jtv) 1659 } 1660 1661 case "tags": 1662 if err := awsAwsjson11_deserializeDocumentTagSet(&sv.Tags, value); err != nil { 1663 return err 1664 } 1665 1666 default: 1667 _, _ = key, value 1668 1669 } 1670 } 1671 *v = sv 1672 return nil 1673} 1674 1675func awsAwsjson11_deserializeDocumentConcurrentModificationException(v **types.ConcurrentModificationException, value interface{}) error { 1676 if v == nil { 1677 return fmt.Errorf("unexpected nil of type %T", v) 1678 } 1679 if value == nil { 1680 return nil 1681 } 1682 1683 shape, ok := value.(map[string]interface{}) 1684 if !ok { 1685 return fmt.Errorf("unexpected JSON type %v", value) 1686 } 1687 1688 var sv *types.ConcurrentModificationException 1689 if *v == nil { 1690 sv = &types.ConcurrentModificationException{} 1691 } else { 1692 sv = *v 1693 } 1694 1695 for key, value := range shape { 1696 switch key { 1697 case "message": 1698 if value != nil { 1699 jtv, ok := value.(string) 1700 if !ok { 1701 return fmt.Errorf("expected string to be of type string, got %T instead", value) 1702 } 1703 sv.Message = ptr.String(jtv) 1704 } 1705 1706 default: 1707 _, _ = key, value 1708 1709 } 1710 } 1711 *v = sv 1712 return nil 1713} 1714 1715func awsAwsjson11_deserializeDocumentDescribeAffectedEntitiesForOrganizationFailedSet(v *[]types.OrganizationAffectedEntitiesErrorItem, value interface{}) error { 1716 if v == nil { 1717 return fmt.Errorf("unexpected nil of type %T", v) 1718 } 1719 if value == nil { 1720 return nil 1721 } 1722 1723 shape, ok := value.([]interface{}) 1724 if !ok { 1725 return fmt.Errorf("unexpected JSON type %v", value) 1726 } 1727 1728 var cv []types.OrganizationAffectedEntitiesErrorItem 1729 if *v == nil { 1730 cv = []types.OrganizationAffectedEntitiesErrorItem{} 1731 } else { 1732 cv = *v 1733 } 1734 1735 for _, value := range shape { 1736 var col types.OrganizationAffectedEntitiesErrorItem 1737 destAddr := &col 1738 if err := awsAwsjson11_deserializeDocumentOrganizationAffectedEntitiesErrorItem(&destAddr, value); err != nil { 1739 return err 1740 } 1741 col = *destAddr 1742 cv = append(cv, col) 1743 1744 } 1745 *v = cv 1746 return nil 1747} 1748 1749func awsAwsjson11_deserializeDocumentDescribeEventDetailsFailedSet(v *[]types.EventDetailsErrorItem, value interface{}) error { 1750 if v == nil { 1751 return fmt.Errorf("unexpected nil of type %T", v) 1752 } 1753 if value == nil { 1754 return nil 1755 } 1756 1757 shape, ok := value.([]interface{}) 1758 if !ok { 1759 return fmt.Errorf("unexpected JSON type %v", value) 1760 } 1761 1762 var cv []types.EventDetailsErrorItem 1763 if *v == nil { 1764 cv = []types.EventDetailsErrorItem{} 1765 } else { 1766 cv = *v 1767 } 1768 1769 for _, value := range shape { 1770 var col types.EventDetailsErrorItem 1771 destAddr := &col 1772 if err := awsAwsjson11_deserializeDocumentEventDetailsErrorItem(&destAddr, value); err != nil { 1773 return err 1774 } 1775 col = *destAddr 1776 cv = append(cv, col) 1777 1778 } 1779 *v = cv 1780 return nil 1781} 1782 1783func awsAwsjson11_deserializeDocumentDescribeEventDetailsForOrganizationFailedSet(v *[]types.OrganizationEventDetailsErrorItem, value interface{}) error { 1784 if v == nil { 1785 return fmt.Errorf("unexpected nil of type %T", v) 1786 } 1787 if value == nil { 1788 return nil 1789 } 1790 1791 shape, ok := value.([]interface{}) 1792 if !ok { 1793 return fmt.Errorf("unexpected JSON type %v", value) 1794 } 1795 1796 var cv []types.OrganizationEventDetailsErrorItem 1797 if *v == nil { 1798 cv = []types.OrganizationEventDetailsErrorItem{} 1799 } else { 1800 cv = *v 1801 } 1802 1803 for _, value := range shape { 1804 var col types.OrganizationEventDetailsErrorItem 1805 destAddr := &col 1806 if err := awsAwsjson11_deserializeDocumentOrganizationEventDetailsErrorItem(&destAddr, value); err != nil { 1807 return err 1808 } 1809 col = *destAddr 1810 cv = append(cv, col) 1811 1812 } 1813 *v = cv 1814 return nil 1815} 1816 1817func awsAwsjson11_deserializeDocumentDescribeEventDetailsForOrganizationSuccessfulSet(v *[]types.OrganizationEventDetails, value interface{}) error { 1818 if v == nil { 1819 return fmt.Errorf("unexpected nil of type %T", v) 1820 } 1821 if value == nil { 1822 return nil 1823 } 1824 1825 shape, ok := value.([]interface{}) 1826 if !ok { 1827 return fmt.Errorf("unexpected JSON type %v", value) 1828 } 1829 1830 var cv []types.OrganizationEventDetails 1831 if *v == nil { 1832 cv = []types.OrganizationEventDetails{} 1833 } else { 1834 cv = *v 1835 } 1836 1837 for _, value := range shape { 1838 var col types.OrganizationEventDetails 1839 destAddr := &col 1840 if err := awsAwsjson11_deserializeDocumentOrganizationEventDetails(&destAddr, value); err != nil { 1841 return err 1842 } 1843 col = *destAddr 1844 cv = append(cv, col) 1845 1846 } 1847 *v = cv 1848 return nil 1849} 1850 1851func awsAwsjson11_deserializeDocumentDescribeEventDetailsSuccessfulSet(v *[]types.EventDetails, value interface{}) error { 1852 if v == nil { 1853 return fmt.Errorf("unexpected nil of type %T", v) 1854 } 1855 if value == nil { 1856 return nil 1857 } 1858 1859 shape, ok := value.([]interface{}) 1860 if !ok { 1861 return fmt.Errorf("unexpected JSON type %v", value) 1862 } 1863 1864 var cv []types.EventDetails 1865 if *v == nil { 1866 cv = []types.EventDetails{} 1867 } else { 1868 cv = *v 1869 } 1870 1871 for _, value := range shape { 1872 var col types.EventDetails 1873 destAddr := &col 1874 if err := awsAwsjson11_deserializeDocumentEventDetails(&destAddr, value); err != nil { 1875 return err 1876 } 1877 col = *destAddr 1878 cv = append(cv, col) 1879 1880 } 1881 *v = cv 1882 return nil 1883} 1884 1885func awsAwsjson11_deserializeDocumentEntityAggregate(v **types.EntityAggregate, value interface{}) error { 1886 if v == nil { 1887 return fmt.Errorf("unexpected nil of type %T", v) 1888 } 1889 if value == nil { 1890 return nil 1891 } 1892 1893 shape, ok := value.(map[string]interface{}) 1894 if !ok { 1895 return fmt.Errorf("unexpected JSON type %v", value) 1896 } 1897 1898 var sv *types.EntityAggregate 1899 if *v == nil { 1900 sv = &types.EntityAggregate{} 1901 } else { 1902 sv = *v 1903 } 1904 1905 for key, value := range shape { 1906 switch key { 1907 case "count": 1908 if value != nil { 1909 jtv, ok := value.(json.Number) 1910 if !ok { 1911 return fmt.Errorf("expected count to be json.Number, got %T instead", value) 1912 } 1913 i64, err := jtv.Int64() 1914 if err != nil { 1915 return err 1916 } 1917 sv.Count = int32(i64) 1918 } 1919 1920 case "eventArn": 1921 if value != nil { 1922 jtv, ok := value.(string) 1923 if !ok { 1924 return fmt.Errorf("expected eventArn to be of type string, got %T instead", value) 1925 } 1926 sv.EventArn = ptr.String(jtv) 1927 } 1928 1929 default: 1930 _, _ = key, value 1931 1932 } 1933 } 1934 *v = sv 1935 return nil 1936} 1937 1938func awsAwsjson11_deserializeDocumentEntityAggregateList(v *[]types.EntityAggregate, value interface{}) error { 1939 if v == nil { 1940 return fmt.Errorf("unexpected nil of type %T", v) 1941 } 1942 if value == nil { 1943 return nil 1944 } 1945 1946 shape, ok := value.([]interface{}) 1947 if !ok { 1948 return fmt.Errorf("unexpected JSON type %v", value) 1949 } 1950 1951 var cv []types.EntityAggregate 1952 if *v == nil { 1953 cv = []types.EntityAggregate{} 1954 } else { 1955 cv = *v 1956 } 1957 1958 for _, value := range shape { 1959 var col types.EntityAggregate 1960 destAddr := &col 1961 if err := awsAwsjson11_deserializeDocumentEntityAggregate(&destAddr, value); err != nil { 1962 return err 1963 } 1964 col = *destAddr 1965 cv = append(cv, col) 1966 1967 } 1968 *v = cv 1969 return nil 1970} 1971 1972func awsAwsjson11_deserializeDocumentEntityList(v *[]types.AffectedEntity, value interface{}) error { 1973 if v == nil { 1974 return fmt.Errorf("unexpected nil of type %T", v) 1975 } 1976 if value == nil { 1977 return nil 1978 } 1979 1980 shape, ok := value.([]interface{}) 1981 if !ok { 1982 return fmt.Errorf("unexpected JSON type %v", value) 1983 } 1984 1985 var cv []types.AffectedEntity 1986 if *v == nil { 1987 cv = []types.AffectedEntity{} 1988 } else { 1989 cv = *v 1990 } 1991 1992 for _, value := range shape { 1993 var col types.AffectedEntity 1994 destAddr := &col 1995 if err := awsAwsjson11_deserializeDocumentAffectedEntity(&destAddr, value); err != nil { 1996 return err 1997 } 1998 col = *destAddr 1999 cv = append(cv, col) 2000 2001 } 2002 *v = cv 2003 return nil 2004} 2005 2006func awsAwsjson11_deserializeDocumentEvent(v **types.Event, value interface{}) error { 2007 if v == nil { 2008 return fmt.Errorf("unexpected nil of type %T", v) 2009 } 2010 if value == nil { 2011 return nil 2012 } 2013 2014 shape, ok := value.(map[string]interface{}) 2015 if !ok { 2016 return fmt.Errorf("unexpected JSON type %v", value) 2017 } 2018 2019 var sv *types.Event 2020 if *v == nil { 2021 sv = &types.Event{} 2022 } else { 2023 sv = *v 2024 } 2025 2026 for key, value := range shape { 2027 switch key { 2028 case "arn": 2029 if value != nil { 2030 jtv, ok := value.(string) 2031 if !ok { 2032 return fmt.Errorf("expected eventArn to be of type string, got %T instead", value) 2033 } 2034 sv.Arn = ptr.String(jtv) 2035 } 2036 2037 case "availabilityZone": 2038 if value != nil { 2039 jtv, ok := value.(string) 2040 if !ok { 2041 return fmt.Errorf("expected availabilityZone to be of type string, got %T instead", value) 2042 } 2043 sv.AvailabilityZone = ptr.String(jtv) 2044 } 2045 2046 case "endTime": 2047 if value != nil { 2048 jtv, ok := value.(json.Number) 2049 if !ok { 2050 return fmt.Errorf("expected timestamp to be json.Number, got %T instead", value) 2051 } 2052 f64, err := jtv.Float64() 2053 if err != nil { 2054 return err 2055 } 2056 sv.EndTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 2057 } 2058 2059 case "eventScopeCode": 2060 if value != nil { 2061 jtv, ok := value.(string) 2062 if !ok { 2063 return fmt.Errorf("expected eventScopeCode to be of type string, got %T instead", value) 2064 } 2065 sv.EventScopeCode = types.EventScopeCode(jtv) 2066 } 2067 2068 case "eventTypeCategory": 2069 if value != nil { 2070 jtv, ok := value.(string) 2071 if !ok { 2072 return fmt.Errorf("expected eventTypeCategory to be of type string, got %T instead", value) 2073 } 2074 sv.EventTypeCategory = types.EventTypeCategory(jtv) 2075 } 2076 2077 case "eventTypeCode": 2078 if value != nil { 2079 jtv, ok := value.(string) 2080 if !ok { 2081 return fmt.Errorf("expected eventTypeCode to be of type string, got %T instead", value) 2082 } 2083 sv.EventTypeCode = ptr.String(jtv) 2084 } 2085 2086 case "lastUpdatedTime": 2087 if value != nil { 2088 jtv, ok := value.(json.Number) 2089 if !ok { 2090 return fmt.Errorf("expected timestamp to be json.Number, got %T instead", value) 2091 } 2092 f64, err := jtv.Float64() 2093 if err != nil { 2094 return err 2095 } 2096 sv.LastUpdatedTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 2097 } 2098 2099 case "region": 2100 if value != nil { 2101 jtv, ok := value.(string) 2102 if !ok { 2103 return fmt.Errorf("expected region to be of type string, got %T instead", value) 2104 } 2105 sv.Region = ptr.String(jtv) 2106 } 2107 2108 case "service": 2109 if value != nil { 2110 jtv, ok := value.(string) 2111 if !ok { 2112 return fmt.Errorf("expected service to be of type string, got %T instead", value) 2113 } 2114 sv.Service = ptr.String(jtv) 2115 } 2116 2117 case "startTime": 2118 if value != nil { 2119 jtv, ok := value.(json.Number) 2120 if !ok { 2121 return fmt.Errorf("expected timestamp to be json.Number, got %T instead", value) 2122 } 2123 f64, err := jtv.Float64() 2124 if err != nil { 2125 return err 2126 } 2127 sv.StartTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 2128 } 2129 2130 case "statusCode": 2131 if value != nil { 2132 jtv, ok := value.(string) 2133 if !ok { 2134 return fmt.Errorf("expected eventStatusCode to be of type string, got %T instead", value) 2135 } 2136 sv.StatusCode = types.EventStatusCode(jtv) 2137 } 2138 2139 default: 2140 _, _ = key, value 2141 2142 } 2143 } 2144 *v = sv 2145 return nil 2146} 2147 2148func awsAwsjson11_deserializeDocumentEventAggregate(v **types.EventAggregate, value interface{}) error { 2149 if v == nil { 2150 return fmt.Errorf("unexpected nil of type %T", v) 2151 } 2152 if value == nil { 2153 return nil 2154 } 2155 2156 shape, ok := value.(map[string]interface{}) 2157 if !ok { 2158 return fmt.Errorf("unexpected JSON type %v", value) 2159 } 2160 2161 var sv *types.EventAggregate 2162 if *v == nil { 2163 sv = &types.EventAggregate{} 2164 } else { 2165 sv = *v 2166 } 2167 2168 for key, value := range shape { 2169 switch key { 2170 case "aggregateValue": 2171 if value != nil { 2172 jtv, ok := value.(string) 2173 if !ok { 2174 return fmt.Errorf("expected aggregateValue to be of type string, got %T instead", value) 2175 } 2176 sv.AggregateValue = ptr.String(jtv) 2177 } 2178 2179 case "count": 2180 if value != nil { 2181 jtv, ok := value.(json.Number) 2182 if !ok { 2183 return fmt.Errorf("expected count to be json.Number, got %T instead", value) 2184 } 2185 i64, err := jtv.Int64() 2186 if err != nil { 2187 return err 2188 } 2189 sv.Count = int32(i64) 2190 } 2191 2192 default: 2193 _, _ = key, value 2194 2195 } 2196 } 2197 *v = sv 2198 return nil 2199} 2200 2201func awsAwsjson11_deserializeDocumentEventAggregateList(v *[]types.EventAggregate, value interface{}) error { 2202 if v == nil { 2203 return fmt.Errorf("unexpected nil of type %T", v) 2204 } 2205 if value == nil { 2206 return nil 2207 } 2208 2209 shape, ok := value.([]interface{}) 2210 if !ok { 2211 return fmt.Errorf("unexpected JSON type %v", value) 2212 } 2213 2214 var cv []types.EventAggregate 2215 if *v == nil { 2216 cv = []types.EventAggregate{} 2217 } else { 2218 cv = *v 2219 } 2220 2221 for _, value := range shape { 2222 var col types.EventAggregate 2223 destAddr := &col 2224 if err := awsAwsjson11_deserializeDocumentEventAggregate(&destAddr, value); err != nil { 2225 return err 2226 } 2227 col = *destAddr 2228 cv = append(cv, col) 2229 2230 } 2231 *v = cv 2232 return nil 2233} 2234 2235func awsAwsjson11_deserializeDocumentEventDescription(v **types.EventDescription, value interface{}) error { 2236 if v == nil { 2237 return fmt.Errorf("unexpected nil of type %T", v) 2238 } 2239 if value == nil { 2240 return nil 2241 } 2242 2243 shape, ok := value.(map[string]interface{}) 2244 if !ok { 2245 return fmt.Errorf("unexpected JSON type %v", value) 2246 } 2247 2248 var sv *types.EventDescription 2249 if *v == nil { 2250 sv = &types.EventDescription{} 2251 } else { 2252 sv = *v 2253 } 2254 2255 for key, value := range shape { 2256 switch key { 2257 case "latestDescription": 2258 if value != nil { 2259 jtv, ok := value.(string) 2260 if !ok { 2261 return fmt.Errorf("expected EventDescription2 to be of type string, got %T instead", value) 2262 } 2263 sv.LatestDescription = ptr.String(jtv) 2264 } 2265 2266 default: 2267 _, _ = key, value 2268 2269 } 2270 } 2271 *v = sv 2272 return nil 2273} 2274 2275func awsAwsjson11_deserializeDocumentEventDetails(v **types.EventDetails, value interface{}) error { 2276 if v == nil { 2277 return fmt.Errorf("unexpected nil of type %T", v) 2278 } 2279 if value == nil { 2280 return nil 2281 } 2282 2283 shape, ok := value.(map[string]interface{}) 2284 if !ok { 2285 return fmt.Errorf("unexpected JSON type %v", value) 2286 } 2287 2288 var sv *types.EventDetails 2289 if *v == nil { 2290 sv = &types.EventDetails{} 2291 } else { 2292 sv = *v 2293 } 2294 2295 for key, value := range shape { 2296 switch key { 2297 case "event": 2298 if err := awsAwsjson11_deserializeDocumentEvent(&sv.Event, value); err != nil { 2299 return err 2300 } 2301 2302 case "eventDescription": 2303 if err := awsAwsjson11_deserializeDocumentEventDescription(&sv.EventDescription, value); err != nil { 2304 return err 2305 } 2306 2307 case "eventMetadata": 2308 if err := awsAwsjson11_deserializeDocumentEventMetadata(&sv.EventMetadata, value); err != nil { 2309 return err 2310 } 2311 2312 default: 2313 _, _ = key, value 2314 2315 } 2316 } 2317 *v = sv 2318 return nil 2319} 2320 2321func awsAwsjson11_deserializeDocumentEventDetailsErrorItem(v **types.EventDetailsErrorItem, value interface{}) error { 2322 if v == nil { 2323 return fmt.Errorf("unexpected nil of type %T", v) 2324 } 2325 if value == nil { 2326 return nil 2327 } 2328 2329 shape, ok := value.(map[string]interface{}) 2330 if !ok { 2331 return fmt.Errorf("unexpected JSON type %v", value) 2332 } 2333 2334 var sv *types.EventDetailsErrorItem 2335 if *v == nil { 2336 sv = &types.EventDetailsErrorItem{} 2337 } else { 2338 sv = *v 2339 } 2340 2341 for key, value := range shape { 2342 switch key { 2343 case "errorMessage": 2344 if value != nil { 2345 jtv, ok := value.(string) 2346 if !ok { 2347 return fmt.Errorf("expected string to be of type string, got %T instead", value) 2348 } 2349 sv.ErrorMessage = ptr.String(jtv) 2350 } 2351 2352 case "errorName": 2353 if value != nil { 2354 jtv, ok := value.(string) 2355 if !ok { 2356 return fmt.Errorf("expected string to be of type string, got %T instead", value) 2357 } 2358 sv.ErrorName = ptr.String(jtv) 2359 } 2360 2361 case "eventArn": 2362 if value != nil { 2363 jtv, ok := value.(string) 2364 if !ok { 2365 return fmt.Errorf("expected eventArn to be of type string, got %T instead", value) 2366 } 2367 sv.EventArn = ptr.String(jtv) 2368 } 2369 2370 default: 2371 _, _ = key, value 2372 2373 } 2374 } 2375 *v = sv 2376 return nil 2377} 2378 2379func awsAwsjson11_deserializeDocumentEventList(v *[]types.Event, value interface{}) error { 2380 if v == nil { 2381 return fmt.Errorf("unexpected nil of type %T", v) 2382 } 2383 if value == nil { 2384 return nil 2385 } 2386 2387 shape, ok := value.([]interface{}) 2388 if !ok { 2389 return fmt.Errorf("unexpected JSON type %v", value) 2390 } 2391 2392 var cv []types.Event 2393 if *v == nil { 2394 cv = []types.Event{} 2395 } else { 2396 cv = *v 2397 } 2398 2399 for _, value := range shape { 2400 var col types.Event 2401 destAddr := &col 2402 if err := awsAwsjson11_deserializeDocumentEvent(&destAddr, value); err != nil { 2403 return err 2404 } 2405 col = *destAddr 2406 cv = append(cv, col) 2407 2408 } 2409 *v = cv 2410 return nil 2411} 2412 2413func awsAwsjson11_deserializeDocumentEventMetadata(v *map[string]string, value interface{}) error { 2414 if v == nil { 2415 return fmt.Errorf("unexpected nil of type %T", v) 2416 } 2417 if value == nil { 2418 return nil 2419 } 2420 2421 shape, ok := value.(map[string]interface{}) 2422 if !ok { 2423 return fmt.Errorf("unexpected JSON type %v", value) 2424 } 2425 2426 var mv map[string]string 2427 if *v == nil { 2428 mv = map[string]string{} 2429 } else { 2430 mv = *v 2431 } 2432 2433 for key, value := range shape { 2434 var parsedVal string 2435 if value != nil { 2436 jtv, ok := value.(string) 2437 if !ok { 2438 return fmt.Errorf("expected metadataValue to be of type string, got %T instead", value) 2439 } 2440 parsedVal = jtv 2441 } 2442 mv[key] = parsedVal 2443 2444 } 2445 *v = mv 2446 return nil 2447} 2448 2449func awsAwsjson11_deserializeDocumentEventType(v **types.EventType, value interface{}) error { 2450 if v == nil { 2451 return fmt.Errorf("unexpected nil of type %T", v) 2452 } 2453 if value == nil { 2454 return nil 2455 } 2456 2457 shape, ok := value.(map[string]interface{}) 2458 if !ok { 2459 return fmt.Errorf("unexpected JSON type %v", value) 2460 } 2461 2462 var sv *types.EventType 2463 if *v == nil { 2464 sv = &types.EventType{} 2465 } else { 2466 sv = *v 2467 } 2468 2469 for key, value := range shape { 2470 switch key { 2471 case "category": 2472 if value != nil { 2473 jtv, ok := value.(string) 2474 if !ok { 2475 return fmt.Errorf("expected eventTypeCategory to be of type string, got %T instead", value) 2476 } 2477 sv.Category = types.EventTypeCategory(jtv) 2478 } 2479 2480 case "code": 2481 if value != nil { 2482 jtv, ok := value.(string) 2483 if !ok { 2484 return fmt.Errorf("expected eventTypeCode to be of type string, got %T instead", value) 2485 } 2486 sv.Code = ptr.String(jtv) 2487 } 2488 2489 case "service": 2490 if value != nil { 2491 jtv, ok := value.(string) 2492 if !ok { 2493 return fmt.Errorf("expected service to be of type string, got %T instead", value) 2494 } 2495 sv.Service = ptr.String(jtv) 2496 } 2497 2498 default: 2499 _, _ = key, value 2500 2501 } 2502 } 2503 *v = sv 2504 return nil 2505} 2506 2507func awsAwsjson11_deserializeDocumentEventTypeList(v *[]types.EventType, value interface{}) error { 2508 if v == nil { 2509 return fmt.Errorf("unexpected nil of type %T", v) 2510 } 2511 if value == nil { 2512 return nil 2513 } 2514 2515 shape, ok := value.([]interface{}) 2516 if !ok { 2517 return fmt.Errorf("unexpected JSON type %v", value) 2518 } 2519 2520 var cv []types.EventType 2521 if *v == nil { 2522 cv = []types.EventType{} 2523 } else { 2524 cv = *v 2525 } 2526 2527 for _, value := range shape { 2528 var col types.EventType 2529 destAddr := &col 2530 if err := awsAwsjson11_deserializeDocumentEventType(&destAddr, value); err != nil { 2531 return err 2532 } 2533 col = *destAddr 2534 cv = append(cv, col) 2535 2536 } 2537 *v = cv 2538 return nil 2539} 2540 2541func awsAwsjson11_deserializeDocumentInvalidPaginationToken(v **types.InvalidPaginationToken, value interface{}) error { 2542 if v == nil { 2543 return fmt.Errorf("unexpected nil of type %T", v) 2544 } 2545 if value == nil { 2546 return nil 2547 } 2548 2549 shape, ok := value.(map[string]interface{}) 2550 if !ok { 2551 return fmt.Errorf("unexpected JSON type %v", value) 2552 } 2553 2554 var sv *types.InvalidPaginationToken 2555 if *v == nil { 2556 sv = &types.InvalidPaginationToken{} 2557 } else { 2558 sv = *v 2559 } 2560 2561 for key, value := range shape { 2562 switch key { 2563 case "message": 2564 if value != nil { 2565 jtv, ok := value.(string) 2566 if !ok { 2567 return fmt.Errorf("expected string to be of type string, got %T instead", value) 2568 } 2569 sv.Message = ptr.String(jtv) 2570 } 2571 2572 default: 2573 _, _ = key, value 2574 2575 } 2576 } 2577 *v = sv 2578 return nil 2579} 2580 2581func awsAwsjson11_deserializeDocumentOrganizationAffectedEntitiesErrorItem(v **types.OrganizationAffectedEntitiesErrorItem, value interface{}) error { 2582 if v == nil { 2583 return fmt.Errorf("unexpected nil of type %T", v) 2584 } 2585 if value == nil { 2586 return nil 2587 } 2588 2589 shape, ok := value.(map[string]interface{}) 2590 if !ok { 2591 return fmt.Errorf("unexpected JSON type %v", value) 2592 } 2593 2594 var sv *types.OrganizationAffectedEntitiesErrorItem 2595 if *v == nil { 2596 sv = &types.OrganizationAffectedEntitiesErrorItem{} 2597 } else { 2598 sv = *v 2599 } 2600 2601 for key, value := range shape { 2602 switch key { 2603 case "awsAccountId": 2604 if value != nil { 2605 jtv, ok := value.(string) 2606 if !ok { 2607 return fmt.Errorf("expected accountId to be of type string, got %T instead", value) 2608 } 2609 sv.AwsAccountId = ptr.String(jtv) 2610 } 2611 2612 case "errorMessage": 2613 if value != nil { 2614 jtv, ok := value.(string) 2615 if !ok { 2616 return fmt.Errorf("expected string to be of type string, got %T instead", value) 2617 } 2618 sv.ErrorMessage = ptr.String(jtv) 2619 } 2620 2621 case "errorName": 2622 if value != nil { 2623 jtv, ok := value.(string) 2624 if !ok { 2625 return fmt.Errorf("expected string to be of type string, got %T instead", value) 2626 } 2627 sv.ErrorName = ptr.String(jtv) 2628 } 2629 2630 case "eventArn": 2631 if value != nil { 2632 jtv, ok := value.(string) 2633 if !ok { 2634 return fmt.Errorf("expected eventArn to be of type string, got %T instead", value) 2635 } 2636 sv.EventArn = ptr.String(jtv) 2637 } 2638 2639 default: 2640 _, _ = key, value 2641 2642 } 2643 } 2644 *v = sv 2645 return nil 2646} 2647 2648func awsAwsjson11_deserializeDocumentOrganizationEvent(v **types.OrganizationEvent, value interface{}) error { 2649 if v == nil { 2650 return fmt.Errorf("unexpected nil of type %T", v) 2651 } 2652 if value == nil { 2653 return nil 2654 } 2655 2656 shape, ok := value.(map[string]interface{}) 2657 if !ok { 2658 return fmt.Errorf("unexpected JSON type %v", value) 2659 } 2660 2661 var sv *types.OrganizationEvent 2662 if *v == nil { 2663 sv = &types.OrganizationEvent{} 2664 } else { 2665 sv = *v 2666 } 2667 2668 for key, value := range shape { 2669 switch key { 2670 case "arn": 2671 if value != nil { 2672 jtv, ok := value.(string) 2673 if !ok { 2674 return fmt.Errorf("expected eventArn to be of type string, got %T instead", value) 2675 } 2676 sv.Arn = ptr.String(jtv) 2677 } 2678 2679 case "endTime": 2680 if value != nil { 2681 jtv, ok := value.(json.Number) 2682 if !ok { 2683 return fmt.Errorf("expected timestamp to be json.Number, got %T instead", value) 2684 } 2685 f64, err := jtv.Float64() 2686 if err != nil { 2687 return err 2688 } 2689 sv.EndTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 2690 } 2691 2692 case "eventScopeCode": 2693 if value != nil { 2694 jtv, ok := value.(string) 2695 if !ok { 2696 return fmt.Errorf("expected eventScopeCode to be of type string, got %T instead", value) 2697 } 2698 sv.EventScopeCode = types.EventScopeCode(jtv) 2699 } 2700 2701 case "eventTypeCategory": 2702 if value != nil { 2703 jtv, ok := value.(string) 2704 if !ok { 2705 return fmt.Errorf("expected eventTypeCategory to be of type string, got %T instead", value) 2706 } 2707 sv.EventTypeCategory = types.EventTypeCategory(jtv) 2708 } 2709 2710 case "eventTypeCode": 2711 if value != nil { 2712 jtv, ok := value.(string) 2713 if !ok { 2714 return fmt.Errorf("expected eventTypeCode to be of type string, got %T instead", value) 2715 } 2716 sv.EventTypeCode = ptr.String(jtv) 2717 } 2718 2719 case "lastUpdatedTime": 2720 if value != nil { 2721 jtv, ok := value.(json.Number) 2722 if !ok { 2723 return fmt.Errorf("expected timestamp to be json.Number, got %T instead", value) 2724 } 2725 f64, err := jtv.Float64() 2726 if err != nil { 2727 return err 2728 } 2729 sv.LastUpdatedTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 2730 } 2731 2732 case "region": 2733 if value != nil { 2734 jtv, ok := value.(string) 2735 if !ok { 2736 return fmt.Errorf("expected region to be of type string, got %T instead", value) 2737 } 2738 sv.Region = ptr.String(jtv) 2739 } 2740 2741 case "service": 2742 if value != nil { 2743 jtv, ok := value.(string) 2744 if !ok { 2745 return fmt.Errorf("expected service to be of type string, got %T instead", value) 2746 } 2747 sv.Service = ptr.String(jtv) 2748 } 2749 2750 case "startTime": 2751 if value != nil { 2752 jtv, ok := value.(json.Number) 2753 if !ok { 2754 return fmt.Errorf("expected timestamp to be json.Number, got %T instead", value) 2755 } 2756 f64, err := jtv.Float64() 2757 if err != nil { 2758 return err 2759 } 2760 sv.StartTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 2761 } 2762 2763 case "statusCode": 2764 if value != nil { 2765 jtv, ok := value.(string) 2766 if !ok { 2767 return fmt.Errorf("expected eventStatusCode to be of type string, got %T instead", value) 2768 } 2769 sv.StatusCode = types.EventStatusCode(jtv) 2770 } 2771 2772 default: 2773 _, _ = key, value 2774 2775 } 2776 } 2777 *v = sv 2778 return nil 2779} 2780 2781func awsAwsjson11_deserializeDocumentOrganizationEventDetails(v **types.OrganizationEventDetails, value interface{}) error { 2782 if v == nil { 2783 return fmt.Errorf("unexpected nil of type %T", v) 2784 } 2785 if value == nil { 2786 return nil 2787 } 2788 2789 shape, ok := value.(map[string]interface{}) 2790 if !ok { 2791 return fmt.Errorf("unexpected JSON type %v", value) 2792 } 2793 2794 var sv *types.OrganizationEventDetails 2795 if *v == nil { 2796 sv = &types.OrganizationEventDetails{} 2797 } else { 2798 sv = *v 2799 } 2800 2801 for key, value := range shape { 2802 switch key { 2803 case "awsAccountId": 2804 if value != nil { 2805 jtv, ok := value.(string) 2806 if !ok { 2807 return fmt.Errorf("expected accountId to be of type string, got %T instead", value) 2808 } 2809 sv.AwsAccountId = ptr.String(jtv) 2810 } 2811 2812 case "event": 2813 if err := awsAwsjson11_deserializeDocumentEvent(&sv.Event, value); err != nil { 2814 return err 2815 } 2816 2817 case "eventDescription": 2818 if err := awsAwsjson11_deserializeDocumentEventDescription(&sv.EventDescription, value); err != nil { 2819 return err 2820 } 2821 2822 case "eventMetadata": 2823 if err := awsAwsjson11_deserializeDocumentEventMetadata(&sv.EventMetadata, value); err != nil { 2824 return err 2825 } 2826 2827 default: 2828 _, _ = key, value 2829 2830 } 2831 } 2832 *v = sv 2833 return nil 2834} 2835 2836func awsAwsjson11_deserializeDocumentOrganizationEventDetailsErrorItem(v **types.OrganizationEventDetailsErrorItem, value interface{}) error { 2837 if v == nil { 2838 return fmt.Errorf("unexpected nil of type %T", v) 2839 } 2840 if value == nil { 2841 return nil 2842 } 2843 2844 shape, ok := value.(map[string]interface{}) 2845 if !ok { 2846 return fmt.Errorf("unexpected JSON type %v", value) 2847 } 2848 2849 var sv *types.OrganizationEventDetailsErrorItem 2850 if *v == nil { 2851 sv = &types.OrganizationEventDetailsErrorItem{} 2852 } else { 2853 sv = *v 2854 } 2855 2856 for key, value := range shape { 2857 switch key { 2858 case "awsAccountId": 2859 if value != nil { 2860 jtv, ok := value.(string) 2861 if !ok { 2862 return fmt.Errorf("expected accountId to be of type string, got %T instead", value) 2863 } 2864 sv.AwsAccountId = ptr.String(jtv) 2865 } 2866 2867 case "errorMessage": 2868 if value != nil { 2869 jtv, ok := value.(string) 2870 if !ok { 2871 return fmt.Errorf("expected string to be of type string, got %T instead", value) 2872 } 2873 sv.ErrorMessage = ptr.String(jtv) 2874 } 2875 2876 case "errorName": 2877 if value != nil { 2878 jtv, ok := value.(string) 2879 if !ok { 2880 return fmt.Errorf("expected string to be of type string, got %T instead", value) 2881 } 2882 sv.ErrorName = ptr.String(jtv) 2883 } 2884 2885 case "eventArn": 2886 if value != nil { 2887 jtv, ok := value.(string) 2888 if !ok { 2889 return fmt.Errorf("expected eventArn to be of type string, got %T instead", value) 2890 } 2891 sv.EventArn = ptr.String(jtv) 2892 } 2893 2894 default: 2895 _, _ = key, value 2896 2897 } 2898 } 2899 *v = sv 2900 return nil 2901} 2902 2903func awsAwsjson11_deserializeDocumentOrganizationEventList(v *[]types.OrganizationEvent, value interface{}) error { 2904 if v == nil { 2905 return fmt.Errorf("unexpected nil of type %T", v) 2906 } 2907 if value == nil { 2908 return nil 2909 } 2910 2911 shape, ok := value.([]interface{}) 2912 if !ok { 2913 return fmt.Errorf("unexpected JSON type %v", value) 2914 } 2915 2916 var cv []types.OrganizationEvent 2917 if *v == nil { 2918 cv = []types.OrganizationEvent{} 2919 } else { 2920 cv = *v 2921 } 2922 2923 for _, value := range shape { 2924 var col types.OrganizationEvent 2925 destAddr := &col 2926 if err := awsAwsjson11_deserializeDocumentOrganizationEvent(&destAddr, value); err != nil { 2927 return err 2928 } 2929 col = *destAddr 2930 cv = append(cv, col) 2931 2932 } 2933 *v = cv 2934 return nil 2935} 2936 2937func awsAwsjson11_deserializeDocumentTagSet(v *map[string]string, value interface{}) error { 2938 if v == nil { 2939 return fmt.Errorf("unexpected nil of type %T", v) 2940 } 2941 if value == nil { 2942 return nil 2943 } 2944 2945 shape, ok := value.(map[string]interface{}) 2946 if !ok { 2947 return fmt.Errorf("unexpected JSON type %v", value) 2948 } 2949 2950 var mv map[string]string 2951 if *v == nil { 2952 mv = map[string]string{} 2953 } else { 2954 mv = *v 2955 } 2956 2957 for key, value := range shape { 2958 var parsedVal string 2959 if value != nil { 2960 jtv, ok := value.(string) 2961 if !ok { 2962 return fmt.Errorf("expected tagValue to be of type string, got %T instead", value) 2963 } 2964 parsedVal = jtv 2965 } 2966 mv[key] = parsedVal 2967 2968 } 2969 *v = mv 2970 return nil 2971} 2972 2973func awsAwsjson11_deserializeDocumentUnsupportedLocale(v **types.UnsupportedLocale, value interface{}) error { 2974 if v == nil { 2975 return fmt.Errorf("unexpected nil of type %T", v) 2976 } 2977 if value == nil { 2978 return nil 2979 } 2980 2981 shape, ok := value.(map[string]interface{}) 2982 if !ok { 2983 return fmt.Errorf("unexpected JSON type %v", value) 2984 } 2985 2986 var sv *types.UnsupportedLocale 2987 if *v == nil { 2988 sv = &types.UnsupportedLocale{} 2989 } else { 2990 sv = *v 2991 } 2992 2993 for key, value := range shape { 2994 switch key { 2995 case "message": 2996 if value != nil { 2997 jtv, ok := value.(string) 2998 if !ok { 2999 return fmt.Errorf("expected string to be of type string, got %T instead", value) 3000 } 3001 sv.Message = ptr.String(jtv) 3002 } 3003 3004 default: 3005 _, _ = key, value 3006 3007 } 3008 } 3009 *v = sv 3010 return nil 3011} 3012 3013func awsAwsjson11_deserializeOpDocumentDescribeAffectedAccountsForOrganizationOutput(v **DescribeAffectedAccountsForOrganizationOutput, value interface{}) error { 3014 if v == nil { 3015 return fmt.Errorf("unexpected nil of type %T", v) 3016 } 3017 if value == nil { 3018 return nil 3019 } 3020 3021 shape, ok := value.(map[string]interface{}) 3022 if !ok { 3023 return fmt.Errorf("unexpected JSON type %v", value) 3024 } 3025 3026 var sv *DescribeAffectedAccountsForOrganizationOutput 3027 if *v == nil { 3028 sv = &DescribeAffectedAccountsForOrganizationOutput{} 3029 } else { 3030 sv = *v 3031 } 3032 3033 for key, value := range shape { 3034 switch key { 3035 case "affectedAccounts": 3036 if err := awsAwsjson11_deserializeDocumentAffectedAccountsList(&sv.AffectedAccounts, value); err != nil { 3037 return err 3038 } 3039 3040 case "eventScopeCode": 3041 if value != nil { 3042 jtv, ok := value.(string) 3043 if !ok { 3044 return fmt.Errorf("expected eventScopeCode to be of type string, got %T instead", value) 3045 } 3046 sv.EventScopeCode = types.EventScopeCode(jtv) 3047 } 3048 3049 case "nextToken": 3050 if value != nil { 3051 jtv, ok := value.(string) 3052 if !ok { 3053 return fmt.Errorf("expected nextToken to be of type string, got %T instead", value) 3054 } 3055 sv.NextToken = ptr.String(jtv) 3056 } 3057 3058 default: 3059 _, _ = key, value 3060 3061 } 3062 } 3063 *v = sv 3064 return nil 3065} 3066 3067func awsAwsjson11_deserializeOpDocumentDescribeAffectedEntitiesForOrganizationOutput(v **DescribeAffectedEntitiesForOrganizationOutput, value interface{}) error { 3068 if v == nil { 3069 return fmt.Errorf("unexpected nil of type %T", v) 3070 } 3071 if value == nil { 3072 return nil 3073 } 3074 3075 shape, ok := value.(map[string]interface{}) 3076 if !ok { 3077 return fmt.Errorf("unexpected JSON type %v", value) 3078 } 3079 3080 var sv *DescribeAffectedEntitiesForOrganizationOutput 3081 if *v == nil { 3082 sv = &DescribeAffectedEntitiesForOrganizationOutput{} 3083 } else { 3084 sv = *v 3085 } 3086 3087 for key, value := range shape { 3088 switch key { 3089 case "entities": 3090 if err := awsAwsjson11_deserializeDocumentEntityList(&sv.Entities, value); err != nil { 3091 return err 3092 } 3093 3094 case "failedSet": 3095 if err := awsAwsjson11_deserializeDocumentDescribeAffectedEntitiesForOrganizationFailedSet(&sv.FailedSet, value); err != nil { 3096 return err 3097 } 3098 3099 case "nextToken": 3100 if value != nil { 3101 jtv, ok := value.(string) 3102 if !ok { 3103 return fmt.Errorf("expected nextToken to be of type string, got %T instead", value) 3104 } 3105 sv.NextToken = ptr.String(jtv) 3106 } 3107 3108 default: 3109 _, _ = key, value 3110 3111 } 3112 } 3113 *v = sv 3114 return nil 3115} 3116 3117func awsAwsjson11_deserializeOpDocumentDescribeAffectedEntitiesOutput(v **DescribeAffectedEntitiesOutput, value interface{}) error { 3118 if v == nil { 3119 return fmt.Errorf("unexpected nil of type %T", v) 3120 } 3121 if value == nil { 3122 return nil 3123 } 3124 3125 shape, ok := value.(map[string]interface{}) 3126 if !ok { 3127 return fmt.Errorf("unexpected JSON type %v", value) 3128 } 3129 3130 var sv *DescribeAffectedEntitiesOutput 3131 if *v == nil { 3132 sv = &DescribeAffectedEntitiesOutput{} 3133 } else { 3134 sv = *v 3135 } 3136 3137 for key, value := range shape { 3138 switch key { 3139 case "entities": 3140 if err := awsAwsjson11_deserializeDocumentEntityList(&sv.Entities, value); err != nil { 3141 return err 3142 } 3143 3144 case "nextToken": 3145 if value != nil { 3146 jtv, ok := value.(string) 3147 if !ok { 3148 return fmt.Errorf("expected nextToken to be of type string, got %T instead", value) 3149 } 3150 sv.NextToken = ptr.String(jtv) 3151 } 3152 3153 default: 3154 _, _ = key, value 3155 3156 } 3157 } 3158 *v = sv 3159 return nil 3160} 3161 3162func awsAwsjson11_deserializeOpDocumentDescribeEntityAggregatesOutput(v **DescribeEntityAggregatesOutput, value interface{}) error { 3163 if v == nil { 3164 return fmt.Errorf("unexpected nil of type %T", v) 3165 } 3166 if value == nil { 3167 return nil 3168 } 3169 3170 shape, ok := value.(map[string]interface{}) 3171 if !ok { 3172 return fmt.Errorf("unexpected JSON type %v", value) 3173 } 3174 3175 var sv *DescribeEntityAggregatesOutput 3176 if *v == nil { 3177 sv = &DescribeEntityAggregatesOutput{} 3178 } else { 3179 sv = *v 3180 } 3181 3182 for key, value := range shape { 3183 switch key { 3184 case "entityAggregates": 3185 if err := awsAwsjson11_deserializeDocumentEntityAggregateList(&sv.EntityAggregates, value); err != nil { 3186 return err 3187 } 3188 3189 default: 3190 _, _ = key, value 3191 3192 } 3193 } 3194 *v = sv 3195 return nil 3196} 3197 3198func awsAwsjson11_deserializeOpDocumentDescribeEventAggregatesOutput(v **DescribeEventAggregatesOutput, value interface{}) error { 3199 if v == nil { 3200 return fmt.Errorf("unexpected nil of type %T", v) 3201 } 3202 if value == nil { 3203 return nil 3204 } 3205 3206 shape, ok := value.(map[string]interface{}) 3207 if !ok { 3208 return fmt.Errorf("unexpected JSON type %v", value) 3209 } 3210 3211 var sv *DescribeEventAggregatesOutput 3212 if *v == nil { 3213 sv = &DescribeEventAggregatesOutput{} 3214 } else { 3215 sv = *v 3216 } 3217 3218 for key, value := range shape { 3219 switch key { 3220 case "eventAggregates": 3221 if err := awsAwsjson11_deserializeDocumentEventAggregateList(&sv.EventAggregates, value); err != nil { 3222 return err 3223 } 3224 3225 case "nextToken": 3226 if value != nil { 3227 jtv, ok := value.(string) 3228 if !ok { 3229 return fmt.Errorf("expected nextToken to be of type string, got %T instead", value) 3230 } 3231 sv.NextToken = ptr.String(jtv) 3232 } 3233 3234 default: 3235 _, _ = key, value 3236 3237 } 3238 } 3239 *v = sv 3240 return nil 3241} 3242 3243func awsAwsjson11_deserializeOpDocumentDescribeEventDetailsForOrganizationOutput(v **DescribeEventDetailsForOrganizationOutput, value interface{}) error { 3244 if v == nil { 3245 return fmt.Errorf("unexpected nil of type %T", v) 3246 } 3247 if value == nil { 3248 return nil 3249 } 3250 3251 shape, ok := value.(map[string]interface{}) 3252 if !ok { 3253 return fmt.Errorf("unexpected JSON type %v", value) 3254 } 3255 3256 var sv *DescribeEventDetailsForOrganizationOutput 3257 if *v == nil { 3258 sv = &DescribeEventDetailsForOrganizationOutput{} 3259 } else { 3260 sv = *v 3261 } 3262 3263 for key, value := range shape { 3264 switch key { 3265 case "failedSet": 3266 if err := awsAwsjson11_deserializeDocumentDescribeEventDetailsForOrganizationFailedSet(&sv.FailedSet, value); err != nil { 3267 return err 3268 } 3269 3270 case "successfulSet": 3271 if err := awsAwsjson11_deserializeDocumentDescribeEventDetailsForOrganizationSuccessfulSet(&sv.SuccessfulSet, value); err != nil { 3272 return err 3273 } 3274 3275 default: 3276 _, _ = key, value 3277 3278 } 3279 } 3280 *v = sv 3281 return nil 3282} 3283 3284func awsAwsjson11_deserializeOpDocumentDescribeEventDetailsOutput(v **DescribeEventDetailsOutput, value interface{}) error { 3285 if v == nil { 3286 return fmt.Errorf("unexpected nil of type %T", v) 3287 } 3288 if value == nil { 3289 return nil 3290 } 3291 3292 shape, ok := value.(map[string]interface{}) 3293 if !ok { 3294 return fmt.Errorf("unexpected JSON type %v", value) 3295 } 3296 3297 var sv *DescribeEventDetailsOutput 3298 if *v == nil { 3299 sv = &DescribeEventDetailsOutput{} 3300 } else { 3301 sv = *v 3302 } 3303 3304 for key, value := range shape { 3305 switch key { 3306 case "failedSet": 3307 if err := awsAwsjson11_deserializeDocumentDescribeEventDetailsFailedSet(&sv.FailedSet, value); err != nil { 3308 return err 3309 } 3310 3311 case "successfulSet": 3312 if err := awsAwsjson11_deserializeDocumentDescribeEventDetailsSuccessfulSet(&sv.SuccessfulSet, value); err != nil { 3313 return err 3314 } 3315 3316 default: 3317 _, _ = key, value 3318 3319 } 3320 } 3321 *v = sv 3322 return nil 3323} 3324 3325func awsAwsjson11_deserializeOpDocumentDescribeEventsForOrganizationOutput(v **DescribeEventsForOrganizationOutput, value interface{}) error { 3326 if v == nil { 3327 return fmt.Errorf("unexpected nil of type %T", v) 3328 } 3329 if value == nil { 3330 return nil 3331 } 3332 3333 shape, ok := value.(map[string]interface{}) 3334 if !ok { 3335 return fmt.Errorf("unexpected JSON type %v", value) 3336 } 3337 3338 var sv *DescribeEventsForOrganizationOutput 3339 if *v == nil { 3340 sv = &DescribeEventsForOrganizationOutput{} 3341 } else { 3342 sv = *v 3343 } 3344 3345 for key, value := range shape { 3346 switch key { 3347 case "events": 3348 if err := awsAwsjson11_deserializeDocumentOrganizationEventList(&sv.Events, value); err != nil { 3349 return err 3350 } 3351 3352 case "nextToken": 3353 if value != nil { 3354 jtv, ok := value.(string) 3355 if !ok { 3356 return fmt.Errorf("expected nextToken to be of type string, got %T instead", value) 3357 } 3358 sv.NextToken = ptr.String(jtv) 3359 } 3360 3361 default: 3362 _, _ = key, value 3363 3364 } 3365 } 3366 *v = sv 3367 return nil 3368} 3369 3370func awsAwsjson11_deserializeOpDocumentDescribeEventsOutput(v **DescribeEventsOutput, value interface{}) error { 3371 if v == nil { 3372 return fmt.Errorf("unexpected nil of type %T", v) 3373 } 3374 if value == nil { 3375 return nil 3376 } 3377 3378 shape, ok := value.(map[string]interface{}) 3379 if !ok { 3380 return fmt.Errorf("unexpected JSON type %v", value) 3381 } 3382 3383 var sv *DescribeEventsOutput 3384 if *v == nil { 3385 sv = &DescribeEventsOutput{} 3386 } else { 3387 sv = *v 3388 } 3389 3390 for key, value := range shape { 3391 switch key { 3392 case "events": 3393 if err := awsAwsjson11_deserializeDocumentEventList(&sv.Events, value); err != nil { 3394 return err 3395 } 3396 3397 case "nextToken": 3398 if value != nil { 3399 jtv, ok := value.(string) 3400 if !ok { 3401 return fmt.Errorf("expected nextToken to be of type string, got %T instead", value) 3402 } 3403 sv.NextToken = ptr.String(jtv) 3404 } 3405 3406 default: 3407 _, _ = key, value 3408 3409 } 3410 } 3411 *v = sv 3412 return nil 3413} 3414 3415func awsAwsjson11_deserializeOpDocumentDescribeEventTypesOutput(v **DescribeEventTypesOutput, value interface{}) error { 3416 if v == nil { 3417 return fmt.Errorf("unexpected nil of type %T", v) 3418 } 3419 if value == nil { 3420 return nil 3421 } 3422 3423 shape, ok := value.(map[string]interface{}) 3424 if !ok { 3425 return fmt.Errorf("unexpected JSON type %v", value) 3426 } 3427 3428 var sv *DescribeEventTypesOutput 3429 if *v == nil { 3430 sv = &DescribeEventTypesOutput{} 3431 } else { 3432 sv = *v 3433 } 3434 3435 for key, value := range shape { 3436 switch key { 3437 case "eventTypes": 3438 if err := awsAwsjson11_deserializeDocumentEventTypeList(&sv.EventTypes, value); err != nil { 3439 return err 3440 } 3441 3442 case "nextToken": 3443 if value != nil { 3444 jtv, ok := value.(string) 3445 if !ok { 3446 return fmt.Errorf("expected nextToken to be of type string, got %T instead", value) 3447 } 3448 sv.NextToken = ptr.String(jtv) 3449 } 3450 3451 default: 3452 _, _ = key, value 3453 3454 } 3455 } 3456 *v = sv 3457 return nil 3458} 3459 3460func awsAwsjson11_deserializeOpDocumentDescribeHealthServiceStatusForOrganizationOutput(v **DescribeHealthServiceStatusForOrganizationOutput, value interface{}) error { 3461 if v == nil { 3462 return fmt.Errorf("unexpected nil of type %T", v) 3463 } 3464 if value == nil { 3465 return nil 3466 } 3467 3468 shape, ok := value.(map[string]interface{}) 3469 if !ok { 3470 return fmt.Errorf("unexpected JSON type %v", value) 3471 } 3472 3473 var sv *DescribeHealthServiceStatusForOrganizationOutput 3474 if *v == nil { 3475 sv = &DescribeHealthServiceStatusForOrganizationOutput{} 3476 } else { 3477 sv = *v 3478 } 3479 3480 for key, value := range shape { 3481 switch key { 3482 case "healthServiceAccessStatusForOrganization": 3483 if value != nil { 3484 jtv, ok := value.(string) 3485 if !ok { 3486 return fmt.Errorf("expected healthServiceAccessStatusForOrganization to be of type string, got %T instead", value) 3487 } 3488 sv.HealthServiceAccessStatusForOrganization = ptr.String(jtv) 3489 } 3490 3491 default: 3492 _, _ = key, value 3493 3494 } 3495 } 3496 *v = sv 3497 return nil 3498} 3499