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