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("LimitExceededException", errorCode): 109 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 110 111 case strings.EqualFold("ResourceNotFoundException", errorCode): 112 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 113 114 default: 115 genericError := &smithy.GenericAPIError{ 116 Code: errorCode, 117 Message: errorMessage, 118 } 119 return genericError 120 121 } 122} 123 124type awsAwsjson11_deserializeOpDeleteAppsList struct { 125} 126 127func (*awsAwsjson11_deserializeOpDeleteAppsList) ID() string { 128 return "OperationDeserializer" 129} 130 131func (m *awsAwsjson11_deserializeOpDeleteAppsList) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 132 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 133) { 134 out, metadata, err = next.HandleDeserialize(ctx, in) 135 if err != nil { 136 return out, metadata, err 137 } 138 139 response, ok := out.RawResponse.(*smithyhttp.Response) 140 if !ok { 141 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 142 } 143 144 if response.StatusCode < 200 || response.StatusCode >= 300 { 145 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteAppsList(response, &metadata) 146 } 147 output := &DeleteAppsListOutput{} 148 out.Result = output 149 150 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 151 return out, metadata, &smithy.DeserializationError{ 152 Err: fmt.Errorf("failed to discard response body, %w", err), 153 } 154 } 155 156 return out, metadata, err 157} 158 159func awsAwsjson11_deserializeOpErrorDeleteAppsList(response *smithyhttp.Response, metadata *middleware.Metadata) error { 160 var errorBuffer bytes.Buffer 161 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 162 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 163 } 164 errorBody := bytes.NewReader(errorBuffer.Bytes()) 165 166 errorCode := "UnknownError" 167 errorMessage := errorCode 168 169 code := response.Header.Get("X-Amzn-ErrorType") 170 if len(code) != 0 { 171 errorCode = restjson.SanitizeErrorCode(code) 172 } 173 174 var buff [1024]byte 175 ringBuffer := smithyio.NewRingBuffer(buff[:]) 176 177 body := io.TeeReader(errorBody, ringBuffer) 178 decoder := json.NewDecoder(body) 179 decoder.UseNumber() 180 code, message, err := restjson.GetErrorInfo(decoder) 181 if err != nil { 182 var snapshot bytes.Buffer 183 io.Copy(&snapshot, ringBuffer) 184 err = &smithy.DeserializationError{ 185 Err: fmt.Errorf("failed to decode response body, %w", err), 186 Snapshot: snapshot.Bytes(), 187 } 188 return err 189 } 190 191 errorBody.Seek(0, io.SeekStart) 192 if len(code) != 0 { 193 errorCode = restjson.SanitizeErrorCode(code) 194 } 195 if len(message) != 0 { 196 errorMessage = message 197 } 198 199 switch { 200 case strings.EqualFold("InternalErrorException", errorCode): 201 return awsAwsjson11_deserializeErrorInternalErrorException(response, errorBody) 202 203 case strings.EqualFold("InvalidOperationException", errorCode): 204 return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody) 205 206 case strings.EqualFold("ResourceNotFoundException", errorCode): 207 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 208 209 default: 210 genericError := &smithy.GenericAPIError{ 211 Code: errorCode, 212 Message: errorMessage, 213 } 214 return genericError 215 216 } 217} 218 219type awsAwsjson11_deserializeOpDeleteNotificationChannel struct { 220} 221 222func (*awsAwsjson11_deserializeOpDeleteNotificationChannel) ID() string { 223 return "OperationDeserializer" 224} 225 226func (m *awsAwsjson11_deserializeOpDeleteNotificationChannel) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 227 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 228) { 229 out, metadata, err = next.HandleDeserialize(ctx, in) 230 if err != nil { 231 return out, metadata, err 232 } 233 234 response, ok := out.RawResponse.(*smithyhttp.Response) 235 if !ok { 236 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 237 } 238 239 if response.StatusCode < 200 || response.StatusCode >= 300 { 240 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteNotificationChannel(response, &metadata) 241 } 242 output := &DeleteNotificationChannelOutput{} 243 out.Result = output 244 245 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 246 return out, metadata, &smithy.DeserializationError{ 247 Err: fmt.Errorf("failed to discard response body, %w", err), 248 } 249 } 250 251 return out, metadata, err 252} 253 254func awsAwsjson11_deserializeOpErrorDeleteNotificationChannel(response *smithyhttp.Response, metadata *middleware.Metadata) error { 255 var errorBuffer bytes.Buffer 256 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 257 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 258 } 259 errorBody := bytes.NewReader(errorBuffer.Bytes()) 260 261 errorCode := "UnknownError" 262 errorMessage := errorCode 263 264 code := response.Header.Get("X-Amzn-ErrorType") 265 if len(code) != 0 { 266 errorCode = restjson.SanitizeErrorCode(code) 267 } 268 269 var buff [1024]byte 270 ringBuffer := smithyio.NewRingBuffer(buff[:]) 271 272 body := io.TeeReader(errorBody, ringBuffer) 273 decoder := json.NewDecoder(body) 274 decoder.UseNumber() 275 code, message, err := restjson.GetErrorInfo(decoder) 276 if err != nil { 277 var snapshot bytes.Buffer 278 io.Copy(&snapshot, ringBuffer) 279 err = &smithy.DeserializationError{ 280 Err: fmt.Errorf("failed to decode response body, %w", err), 281 Snapshot: snapshot.Bytes(), 282 } 283 return err 284 } 285 286 errorBody.Seek(0, io.SeekStart) 287 if len(code) != 0 { 288 errorCode = restjson.SanitizeErrorCode(code) 289 } 290 if len(message) != 0 { 291 errorMessage = message 292 } 293 294 switch { 295 case strings.EqualFold("InternalErrorException", errorCode): 296 return awsAwsjson11_deserializeErrorInternalErrorException(response, errorBody) 297 298 case strings.EqualFold("InvalidOperationException", errorCode): 299 return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody) 300 301 case strings.EqualFold("ResourceNotFoundException", errorCode): 302 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 303 304 default: 305 genericError := &smithy.GenericAPIError{ 306 Code: errorCode, 307 Message: errorMessage, 308 } 309 return genericError 310 311 } 312} 313 314type awsAwsjson11_deserializeOpDeletePolicy struct { 315} 316 317func (*awsAwsjson11_deserializeOpDeletePolicy) ID() string { 318 return "OperationDeserializer" 319} 320 321func (m *awsAwsjson11_deserializeOpDeletePolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 322 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 323) { 324 out, metadata, err = next.HandleDeserialize(ctx, in) 325 if err != nil { 326 return out, metadata, err 327 } 328 329 response, ok := out.RawResponse.(*smithyhttp.Response) 330 if !ok { 331 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 332 } 333 334 if response.StatusCode < 200 || response.StatusCode >= 300 { 335 return out, metadata, awsAwsjson11_deserializeOpErrorDeletePolicy(response, &metadata) 336 } 337 output := &DeletePolicyOutput{} 338 out.Result = output 339 340 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 341 return out, metadata, &smithy.DeserializationError{ 342 Err: fmt.Errorf("failed to discard response body, %w", err), 343 } 344 } 345 346 return out, metadata, err 347} 348 349func awsAwsjson11_deserializeOpErrorDeletePolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { 350 var errorBuffer bytes.Buffer 351 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 352 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 353 } 354 errorBody := bytes.NewReader(errorBuffer.Bytes()) 355 356 errorCode := "UnknownError" 357 errorMessage := errorCode 358 359 code := response.Header.Get("X-Amzn-ErrorType") 360 if len(code) != 0 { 361 errorCode = restjson.SanitizeErrorCode(code) 362 } 363 364 var buff [1024]byte 365 ringBuffer := smithyio.NewRingBuffer(buff[:]) 366 367 body := io.TeeReader(errorBody, ringBuffer) 368 decoder := json.NewDecoder(body) 369 decoder.UseNumber() 370 code, message, err := restjson.GetErrorInfo(decoder) 371 if err != nil { 372 var snapshot bytes.Buffer 373 io.Copy(&snapshot, ringBuffer) 374 err = &smithy.DeserializationError{ 375 Err: fmt.Errorf("failed to decode response body, %w", err), 376 Snapshot: snapshot.Bytes(), 377 } 378 return err 379 } 380 381 errorBody.Seek(0, io.SeekStart) 382 if len(code) != 0 { 383 errorCode = restjson.SanitizeErrorCode(code) 384 } 385 if len(message) != 0 { 386 errorMessage = message 387 } 388 389 switch { 390 case strings.EqualFold("InternalErrorException", errorCode): 391 return awsAwsjson11_deserializeErrorInternalErrorException(response, errorBody) 392 393 case strings.EqualFold("InvalidInputException", errorCode): 394 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 395 396 case strings.EqualFold("InvalidOperationException", errorCode): 397 return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody) 398 399 case strings.EqualFold("LimitExceededException", errorCode): 400 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 401 402 case strings.EqualFold("ResourceNotFoundException", errorCode): 403 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 404 405 default: 406 genericError := &smithy.GenericAPIError{ 407 Code: errorCode, 408 Message: errorMessage, 409 } 410 return genericError 411 412 } 413} 414 415type awsAwsjson11_deserializeOpDeleteProtocolsList struct { 416} 417 418func (*awsAwsjson11_deserializeOpDeleteProtocolsList) ID() string { 419 return "OperationDeserializer" 420} 421 422func (m *awsAwsjson11_deserializeOpDeleteProtocolsList) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 423 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 424) { 425 out, metadata, err = next.HandleDeserialize(ctx, in) 426 if err != nil { 427 return out, metadata, err 428 } 429 430 response, ok := out.RawResponse.(*smithyhttp.Response) 431 if !ok { 432 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 433 } 434 435 if response.StatusCode < 200 || response.StatusCode >= 300 { 436 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteProtocolsList(response, &metadata) 437 } 438 output := &DeleteProtocolsListOutput{} 439 out.Result = output 440 441 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 442 return out, metadata, &smithy.DeserializationError{ 443 Err: fmt.Errorf("failed to discard response body, %w", err), 444 } 445 } 446 447 return out, metadata, err 448} 449 450func awsAwsjson11_deserializeOpErrorDeleteProtocolsList(response *smithyhttp.Response, metadata *middleware.Metadata) error { 451 var errorBuffer bytes.Buffer 452 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 453 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 454 } 455 errorBody := bytes.NewReader(errorBuffer.Bytes()) 456 457 errorCode := "UnknownError" 458 errorMessage := errorCode 459 460 code := response.Header.Get("X-Amzn-ErrorType") 461 if len(code) != 0 { 462 errorCode = restjson.SanitizeErrorCode(code) 463 } 464 465 var buff [1024]byte 466 ringBuffer := smithyio.NewRingBuffer(buff[:]) 467 468 body := io.TeeReader(errorBody, ringBuffer) 469 decoder := json.NewDecoder(body) 470 decoder.UseNumber() 471 code, message, err := restjson.GetErrorInfo(decoder) 472 if err != nil { 473 var snapshot bytes.Buffer 474 io.Copy(&snapshot, ringBuffer) 475 err = &smithy.DeserializationError{ 476 Err: fmt.Errorf("failed to decode response body, %w", err), 477 Snapshot: snapshot.Bytes(), 478 } 479 return err 480 } 481 482 errorBody.Seek(0, io.SeekStart) 483 if len(code) != 0 { 484 errorCode = restjson.SanitizeErrorCode(code) 485 } 486 if len(message) != 0 { 487 errorMessage = message 488 } 489 490 switch { 491 case strings.EqualFold("InternalErrorException", errorCode): 492 return awsAwsjson11_deserializeErrorInternalErrorException(response, errorBody) 493 494 case strings.EqualFold("InvalidOperationException", errorCode): 495 return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody) 496 497 case strings.EqualFold("ResourceNotFoundException", errorCode): 498 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 499 500 default: 501 genericError := &smithy.GenericAPIError{ 502 Code: errorCode, 503 Message: errorMessage, 504 } 505 return genericError 506 507 } 508} 509 510type awsAwsjson11_deserializeOpDisassociateAdminAccount struct { 511} 512 513func (*awsAwsjson11_deserializeOpDisassociateAdminAccount) ID() string { 514 return "OperationDeserializer" 515} 516 517func (m *awsAwsjson11_deserializeOpDisassociateAdminAccount) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 518 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 519) { 520 out, metadata, err = next.HandleDeserialize(ctx, in) 521 if err != nil { 522 return out, metadata, err 523 } 524 525 response, ok := out.RawResponse.(*smithyhttp.Response) 526 if !ok { 527 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 528 } 529 530 if response.StatusCode < 200 || response.StatusCode >= 300 { 531 return out, metadata, awsAwsjson11_deserializeOpErrorDisassociateAdminAccount(response, &metadata) 532 } 533 output := &DisassociateAdminAccountOutput{} 534 out.Result = output 535 536 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 537 return out, metadata, &smithy.DeserializationError{ 538 Err: fmt.Errorf("failed to discard response body, %w", err), 539 } 540 } 541 542 return out, metadata, err 543} 544 545func awsAwsjson11_deserializeOpErrorDisassociateAdminAccount(response *smithyhttp.Response, metadata *middleware.Metadata) error { 546 var errorBuffer bytes.Buffer 547 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 548 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 549 } 550 errorBody := bytes.NewReader(errorBuffer.Bytes()) 551 552 errorCode := "UnknownError" 553 errorMessage := errorCode 554 555 code := response.Header.Get("X-Amzn-ErrorType") 556 if len(code) != 0 { 557 errorCode = restjson.SanitizeErrorCode(code) 558 } 559 560 var buff [1024]byte 561 ringBuffer := smithyio.NewRingBuffer(buff[:]) 562 563 body := io.TeeReader(errorBody, ringBuffer) 564 decoder := json.NewDecoder(body) 565 decoder.UseNumber() 566 code, message, err := restjson.GetErrorInfo(decoder) 567 if err != nil { 568 var snapshot bytes.Buffer 569 io.Copy(&snapshot, ringBuffer) 570 err = &smithy.DeserializationError{ 571 Err: fmt.Errorf("failed to decode response body, %w", err), 572 Snapshot: snapshot.Bytes(), 573 } 574 return err 575 } 576 577 errorBody.Seek(0, io.SeekStart) 578 if len(code) != 0 { 579 errorCode = restjson.SanitizeErrorCode(code) 580 } 581 if len(message) != 0 { 582 errorMessage = message 583 } 584 585 switch { 586 case strings.EqualFold("InternalErrorException", errorCode): 587 return awsAwsjson11_deserializeErrorInternalErrorException(response, errorBody) 588 589 case strings.EqualFold("InvalidOperationException", errorCode): 590 return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody) 591 592 case strings.EqualFold("ResourceNotFoundException", errorCode): 593 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 594 595 default: 596 genericError := &smithy.GenericAPIError{ 597 Code: errorCode, 598 Message: errorMessage, 599 } 600 return genericError 601 602 } 603} 604 605type awsAwsjson11_deserializeOpGetAdminAccount struct { 606} 607 608func (*awsAwsjson11_deserializeOpGetAdminAccount) ID() string { 609 return "OperationDeserializer" 610} 611 612func (m *awsAwsjson11_deserializeOpGetAdminAccount) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 613 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 614) { 615 out, metadata, err = next.HandleDeserialize(ctx, in) 616 if err != nil { 617 return out, metadata, err 618 } 619 620 response, ok := out.RawResponse.(*smithyhttp.Response) 621 if !ok { 622 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 623 } 624 625 if response.StatusCode < 200 || response.StatusCode >= 300 { 626 return out, metadata, awsAwsjson11_deserializeOpErrorGetAdminAccount(response, &metadata) 627 } 628 output := &GetAdminAccountOutput{} 629 out.Result = output 630 631 var buff [1024]byte 632 ringBuffer := smithyio.NewRingBuffer(buff[:]) 633 634 body := io.TeeReader(response.Body, ringBuffer) 635 decoder := json.NewDecoder(body) 636 decoder.UseNumber() 637 var shape interface{} 638 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 639 var snapshot bytes.Buffer 640 io.Copy(&snapshot, ringBuffer) 641 err = &smithy.DeserializationError{ 642 Err: fmt.Errorf("failed to decode response body, %w", err), 643 Snapshot: snapshot.Bytes(), 644 } 645 return out, metadata, err 646 } 647 648 err = awsAwsjson11_deserializeOpDocumentGetAdminAccountOutput(&output, shape) 649 if err != nil { 650 var snapshot bytes.Buffer 651 io.Copy(&snapshot, ringBuffer) 652 err = &smithy.DeserializationError{ 653 Err: fmt.Errorf("failed to decode response body, %w", err), 654 Snapshot: snapshot.Bytes(), 655 } 656 return out, metadata, err 657 } 658 659 return out, metadata, err 660} 661 662func awsAwsjson11_deserializeOpErrorGetAdminAccount(response *smithyhttp.Response, metadata *middleware.Metadata) error { 663 var errorBuffer bytes.Buffer 664 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 665 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 666 } 667 errorBody := bytes.NewReader(errorBuffer.Bytes()) 668 669 errorCode := "UnknownError" 670 errorMessage := errorCode 671 672 code := response.Header.Get("X-Amzn-ErrorType") 673 if len(code) != 0 { 674 errorCode = restjson.SanitizeErrorCode(code) 675 } 676 677 var buff [1024]byte 678 ringBuffer := smithyio.NewRingBuffer(buff[:]) 679 680 body := io.TeeReader(errorBody, ringBuffer) 681 decoder := json.NewDecoder(body) 682 decoder.UseNumber() 683 code, message, err := restjson.GetErrorInfo(decoder) 684 if err != nil { 685 var snapshot bytes.Buffer 686 io.Copy(&snapshot, ringBuffer) 687 err = &smithy.DeserializationError{ 688 Err: fmt.Errorf("failed to decode response body, %w", err), 689 Snapshot: snapshot.Bytes(), 690 } 691 return err 692 } 693 694 errorBody.Seek(0, io.SeekStart) 695 if len(code) != 0 { 696 errorCode = restjson.SanitizeErrorCode(code) 697 } 698 if len(message) != 0 { 699 errorMessage = message 700 } 701 702 switch { 703 case strings.EqualFold("InternalErrorException", errorCode): 704 return awsAwsjson11_deserializeErrorInternalErrorException(response, errorBody) 705 706 case strings.EqualFold("InvalidOperationException", errorCode): 707 return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody) 708 709 case strings.EqualFold("ResourceNotFoundException", errorCode): 710 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 711 712 default: 713 genericError := &smithy.GenericAPIError{ 714 Code: errorCode, 715 Message: errorMessage, 716 } 717 return genericError 718 719 } 720} 721 722type awsAwsjson11_deserializeOpGetAppsList struct { 723} 724 725func (*awsAwsjson11_deserializeOpGetAppsList) ID() string { 726 return "OperationDeserializer" 727} 728 729func (m *awsAwsjson11_deserializeOpGetAppsList) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 730 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 731) { 732 out, metadata, err = next.HandleDeserialize(ctx, in) 733 if err != nil { 734 return out, metadata, err 735 } 736 737 response, ok := out.RawResponse.(*smithyhttp.Response) 738 if !ok { 739 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 740 } 741 742 if response.StatusCode < 200 || response.StatusCode >= 300 { 743 return out, metadata, awsAwsjson11_deserializeOpErrorGetAppsList(response, &metadata) 744 } 745 output := &GetAppsListOutput{} 746 out.Result = output 747 748 var buff [1024]byte 749 ringBuffer := smithyio.NewRingBuffer(buff[:]) 750 751 body := io.TeeReader(response.Body, ringBuffer) 752 decoder := json.NewDecoder(body) 753 decoder.UseNumber() 754 var shape interface{} 755 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 756 var snapshot bytes.Buffer 757 io.Copy(&snapshot, ringBuffer) 758 err = &smithy.DeserializationError{ 759 Err: fmt.Errorf("failed to decode response body, %w", err), 760 Snapshot: snapshot.Bytes(), 761 } 762 return out, metadata, err 763 } 764 765 err = awsAwsjson11_deserializeOpDocumentGetAppsListOutput(&output, shape) 766 if err != nil { 767 var snapshot bytes.Buffer 768 io.Copy(&snapshot, ringBuffer) 769 err = &smithy.DeserializationError{ 770 Err: fmt.Errorf("failed to decode response body, %w", err), 771 Snapshot: snapshot.Bytes(), 772 } 773 return out, metadata, err 774 } 775 776 return out, metadata, err 777} 778 779func awsAwsjson11_deserializeOpErrorGetAppsList(response *smithyhttp.Response, metadata *middleware.Metadata) error { 780 var errorBuffer bytes.Buffer 781 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 782 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 783 } 784 errorBody := bytes.NewReader(errorBuffer.Bytes()) 785 786 errorCode := "UnknownError" 787 errorMessage := errorCode 788 789 code := response.Header.Get("X-Amzn-ErrorType") 790 if len(code) != 0 { 791 errorCode = restjson.SanitizeErrorCode(code) 792 } 793 794 var buff [1024]byte 795 ringBuffer := smithyio.NewRingBuffer(buff[:]) 796 797 body := io.TeeReader(errorBody, ringBuffer) 798 decoder := json.NewDecoder(body) 799 decoder.UseNumber() 800 code, message, err := restjson.GetErrorInfo(decoder) 801 if err != nil { 802 var snapshot bytes.Buffer 803 io.Copy(&snapshot, ringBuffer) 804 err = &smithy.DeserializationError{ 805 Err: fmt.Errorf("failed to decode response body, %w", err), 806 Snapshot: snapshot.Bytes(), 807 } 808 return err 809 } 810 811 errorBody.Seek(0, io.SeekStart) 812 if len(code) != 0 { 813 errorCode = restjson.SanitizeErrorCode(code) 814 } 815 if len(message) != 0 { 816 errorMessage = message 817 } 818 819 switch { 820 case strings.EqualFold("InternalErrorException", errorCode): 821 return awsAwsjson11_deserializeErrorInternalErrorException(response, errorBody) 822 823 case strings.EqualFold("InvalidOperationException", errorCode): 824 return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody) 825 826 case strings.EqualFold("ResourceNotFoundException", errorCode): 827 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 828 829 default: 830 genericError := &smithy.GenericAPIError{ 831 Code: errorCode, 832 Message: errorMessage, 833 } 834 return genericError 835 836 } 837} 838 839type awsAwsjson11_deserializeOpGetComplianceDetail struct { 840} 841 842func (*awsAwsjson11_deserializeOpGetComplianceDetail) ID() string { 843 return "OperationDeserializer" 844} 845 846func (m *awsAwsjson11_deserializeOpGetComplianceDetail) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 847 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 848) { 849 out, metadata, err = next.HandleDeserialize(ctx, in) 850 if err != nil { 851 return out, metadata, err 852 } 853 854 response, ok := out.RawResponse.(*smithyhttp.Response) 855 if !ok { 856 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 857 } 858 859 if response.StatusCode < 200 || response.StatusCode >= 300 { 860 return out, metadata, awsAwsjson11_deserializeOpErrorGetComplianceDetail(response, &metadata) 861 } 862 output := &GetComplianceDetailOutput{} 863 out.Result = output 864 865 var buff [1024]byte 866 ringBuffer := smithyio.NewRingBuffer(buff[:]) 867 868 body := io.TeeReader(response.Body, ringBuffer) 869 decoder := json.NewDecoder(body) 870 decoder.UseNumber() 871 var shape interface{} 872 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 873 var snapshot bytes.Buffer 874 io.Copy(&snapshot, ringBuffer) 875 err = &smithy.DeserializationError{ 876 Err: fmt.Errorf("failed to decode response body, %w", err), 877 Snapshot: snapshot.Bytes(), 878 } 879 return out, metadata, err 880 } 881 882 err = awsAwsjson11_deserializeOpDocumentGetComplianceDetailOutput(&output, shape) 883 if err != nil { 884 var snapshot bytes.Buffer 885 io.Copy(&snapshot, ringBuffer) 886 err = &smithy.DeserializationError{ 887 Err: fmt.Errorf("failed to decode response body, %w", err), 888 Snapshot: snapshot.Bytes(), 889 } 890 return out, metadata, err 891 } 892 893 return out, metadata, err 894} 895 896func awsAwsjson11_deserializeOpErrorGetComplianceDetail(response *smithyhttp.Response, metadata *middleware.Metadata) error { 897 var errorBuffer bytes.Buffer 898 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 899 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 900 } 901 errorBody := bytes.NewReader(errorBuffer.Bytes()) 902 903 errorCode := "UnknownError" 904 errorMessage := errorCode 905 906 code := response.Header.Get("X-Amzn-ErrorType") 907 if len(code) != 0 { 908 errorCode = restjson.SanitizeErrorCode(code) 909 } 910 911 var buff [1024]byte 912 ringBuffer := smithyio.NewRingBuffer(buff[:]) 913 914 body := io.TeeReader(errorBody, ringBuffer) 915 decoder := json.NewDecoder(body) 916 decoder.UseNumber() 917 code, message, err := restjson.GetErrorInfo(decoder) 918 if err != nil { 919 var snapshot bytes.Buffer 920 io.Copy(&snapshot, ringBuffer) 921 err = &smithy.DeserializationError{ 922 Err: fmt.Errorf("failed to decode response body, %w", err), 923 Snapshot: snapshot.Bytes(), 924 } 925 return err 926 } 927 928 errorBody.Seek(0, io.SeekStart) 929 if len(code) != 0 { 930 errorCode = restjson.SanitizeErrorCode(code) 931 } 932 if len(message) != 0 { 933 errorMessage = message 934 } 935 936 switch { 937 case strings.EqualFold("InternalErrorException", errorCode): 938 return awsAwsjson11_deserializeErrorInternalErrorException(response, errorBody) 939 940 case strings.EqualFold("InvalidInputException", errorCode): 941 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 942 943 case strings.EqualFold("InvalidOperationException", errorCode): 944 return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody) 945 946 case strings.EqualFold("ResourceNotFoundException", errorCode): 947 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 948 949 default: 950 genericError := &smithy.GenericAPIError{ 951 Code: errorCode, 952 Message: errorMessage, 953 } 954 return genericError 955 956 } 957} 958 959type awsAwsjson11_deserializeOpGetNotificationChannel struct { 960} 961 962func (*awsAwsjson11_deserializeOpGetNotificationChannel) ID() string { 963 return "OperationDeserializer" 964} 965 966func (m *awsAwsjson11_deserializeOpGetNotificationChannel) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 967 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 968) { 969 out, metadata, err = next.HandleDeserialize(ctx, in) 970 if err != nil { 971 return out, metadata, err 972 } 973 974 response, ok := out.RawResponse.(*smithyhttp.Response) 975 if !ok { 976 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 977 } 978 979 if response.StatusCode < 200 || response.StatusCode >= 300 { 980 return out, metadata, awsAwsjson11_deserializeOpErrorGetNotificationChannel(response, &metadata) 981 } 982 output := &GetNotificationChannelOutput{} 983 out.Result = output 984 985 var buff [1024]byte 986 ringBuffer := smithyio.NewRingBuffer(buff[:]) 987 988 body := io.TeeReader(response.Body, ringBuffer) 989 decoder := json.NewDecoder(body) 990 decoder.UseNumber() 991 var shape interface{} 992 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 993 var snapshot bytes.Buffer 994 io.Copy(&snapshot, ringBuffer) 995 err = &smithy.DeserializationError{ 996 Err: fmt.Errorf("failed to decode response body, %w", err), 997 Snapshot: snapshot.Bytes(), 998 } 999 return out, metadata, err 1000 } 1001 1002 err = awsAwsjson11_deserializeOpDocumentGetNotificationChannelOutput(&output, shape) 1003 if err != nil { 1004 var snapshot bytes.Buffer 1005 io.Copy(&snapshot, ringBuffer) 1006 err = &smithy.DeserializationError{ 1007 Err: fmt.Errorf("failed to decode response body, %w", err), 1008 Snapshot: snapshot.Bytes(), 1009 } 1010 return out, metadata, err 1011 } 1012 1013 return out, metadata, err 1014} 1015 1016func awsAwsjson11_deserializeOpErrorGetNotificationChannel(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1017 var errorBuffer bytes.Buffer 1018 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1019 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1020 } 1021 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1022 1023 errorCode := "UnknownError" 1024 errorMessage := errorCode 1025 1026 code := response.Header.Get("X-Amzn-ErrorType") 1027 if len(code) != 0 { 1028 errorCode = restjson.SanitizeErrorCode(code) 1029 } 1030 1031 var buff [1024]byte 1032 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1033 1034 body := io.TeeReader(errorBody, ringBuffer) 1035 decoder := json.NewDecoder(body) 1036 decoder.UseNumber() 1037 code, message, err := restjson.GetErrorInfo(decoder) 1038 if err != nil { 1039 var snapshot bytes.Buffer 1040 io.Copy(&snapshot, ringBuffer) 1041 err = &smithy.DeserializationError{ 1042 Err: fmt.Errorf("failed to decode response body, %w", err), 1043 Snapshot: snapshot.Bytes(), 1044 } 1045 return err 1046 } 1047 1048 errorBody.Seek(0, io.SeekStart) 1049 if len(code) != 0 { 1050 errorCode = restjson.SanitizeErrorCode(code) 1051 } 1052 if len(message) != 0 { 1053 errorMessage = message 1054 } 1055 1056 switch { 1057 case strings.EqualFold("InternalErrorException", errorCode): 1058 return awsAwsjson11_deserializeErrorInternalErrorException(response, errorBody) 1059 1060 case strings.EqualFold("InvalidOperationException", errorCode): 1061 return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody) 1062 1063 case strings.EqualFold("ResourceNotFoundException", errorCode): 1064 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 1065 1066 default: 1067 genericError := &smithy.GenericAPIError{ 1068 Code: errorCode, 1069 Message: errorMessage, 1070 } 1071 return genericError 1072 1073 } 1074} 1075 1076type awsAwsjson11_deserializeOpGetPolicy struct { 1077} 1078 1079func (*awsAwsjson11_deserializeOpGetPolicy) ID() string { 1080 return "OperationDeserializer" 1081} 1082 1083func (m *awsAwsjson11_deserializeOpGetPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1084 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1085) { 1086 out, metadata, err = next.HandleDeserialize(ctx, in) 1087 if err != nil { 1088 return out, metadata, err 1089 } 1090 1091 response, ok := out.RawResponse.(*smithyhttp.Response) 1092 if !ok { 1093 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1094 } 1095 1096 if response.StatusCode < 200 || response.StatusCode >= 300 { 1097 return out, metadata, awsAwsjson11_deserializeOpErrorGetPolicy(response, &metadata) 1098 } 1099 output := &GetPolicyOutput{} 1100 out.Result = output 1101 1102 var buff [1024]byte 1103 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1104 1105 body := io.TeeReader(response.Body, ringBuffer) 1106 decoder := json.NewDecoder(body) 1107 decoder.UseNumber() 1108 var shape interface{} 1109 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1110 var snapshot bytes.Buffer 1111 io.Copy(&snapshot, ringBuffer) 1112 err = &smithy.DeserializationError{ 1113 Err: fmt.Errorf("failed to decode response body, %w", err), 1114 Snapshot: snapshot.Bytes(), 1115 } 1116 return out, metadata, err 1117 } 1118 1119 err = awsAwsjson11_deserializeOpDocumentGetPolicyOutput(&output, shape) 1120 if err != nil { 1121 var snapshot bytes.Buffer 1122 io.Copy(&snapshot, ringBuffer) 1123 err = &smithy.DeserializationError{ 1124 Err: fmt.Errorf("failed to decode response body, %w", err), 1125 Snapshot: snapshot.Bytes(), 1126 } 1127 return out, metadata, err 1128 } 1129 1130 return out, metadata, err 1131} 1132 1133func awsAwsjson11_deserializeOpErrorGetPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1134 var errorBuffer bytes.Buffer 1135 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1136 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1137 } 1138 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1139 1140 errorCode := "UnknownError" 1141 errorMessage := errorCode 1142 1143 code := response.Header.Get("X-Amzn-ErrorType") 1144 if len(code) != 0 { 1145 errorCode = restjson.SanitizeErrorCode(code) 1146 } 1147 1148 var buff [1024]byte 1149 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1150 1151 body := io.TeeReader(errorBody, ringBuffer) 1152 decoder := json.NewDecoder(body) 1153 decoder.UseNumber() 1154 code, message, err := restjson.GetErrorInfo(decoder) 1155 if err != nil { 1156 var snapshot bytes.Buffer 1157 io.Copy(&snapshot, ringBuffer) 1158 err = &smithy.DeserializationError{ 1159 Err: fmt.Errorf("failed to decode response body, %w", err), 1160 Snapshot: snapshot.Bytes(), 1161 } 1162 return err 1163 } 1164 1165 errorBody.Seek(0, io.SeekStart) 1166 if len(code) != 0 { 1167 errorCode = restjson.SanitizeErrorCode(code) 1168 } 1169 if len(message) != 0 { 1170 errorMessage = message 1171 } 1172 1173 switch { 1174 case strings.EqualFold("InternalErrorException", errorCode): 1175 return awsAwsjson11_deserializeErrorInternalErrorException(response, errorBody) 1176 1177 case strings.EqualFold("InvalidOperationException", errorCode): 1178 return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody) 1179 1180 case strings.EqualFold("InvalidTypeException", errorCode): 1181 return awsAwsjson11_deserializeErrorInvalidTypeException(response, errorBody) 1182 1183 case strings.EqualFold("ResourceNotFoundException", errorCode): 1184 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 1185 1186 default: 1187 genericError := &smithy.GenericAPIError{ 1188 Code: errorCode, 1189 Message: errorMessage, 1190 } 1191 return genericError 1192 1193 } 1194} 1195 1196type awsAwsjson11_deserializeOpGetProtectionStatus struct { 1197} 1198 1199func (*awsAwsjson11_deserializeOpGetProtectionStatus) ID() string { 1200 return "OperationDeserializer" 1201} 1202 1203func (m *awsAwsjson11_deserializeOpGetProtectionStatus) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1204 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1205) { 1206 out, metadata, err = next.HandleDeserialize(ctx, in) 1207 if err != nil { 1208 return out, metadata, err 1209 } 1210 1211 response, ok := out.RawResponse.(*smithyhttp.Response) 1212 if !ok { 1213 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1214 } 1215 1216 if response.StatusCode < 200 || response.StatusCode >= 300 { 1217 return out, metadata, awsAwsjson11_deserializeOpErrorGetProtectionStatus(response, &metadata) 1218 } 1219 output := &GetProtectionStatusOutput{} 1220 out.Result = output 1221 1222 var buff [1024]byte 1223 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1224 1225 body := io.TeeReader(response.Body, ringBuffer) 1226 decoder := json.NewDecoder(body) 1227 decoder.UseNumber() 1228 var shape interface{} 1229 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1230 var snapshot bytes.Buffer 1231 io.Copy(&snapshot, ringBuffer) 1232 err = &smithy.DeserializationError{ 1233 Err: fmt.Errorf("failed to decode response body, %w", err), 1234 Snapshot: snapshot.Bytes(), 1235 } 1236 return out, metadata, err 1237 } 1238 1239 err = awsAwsjson11_deserializeOpDocumentGetProtectionStatusOutput(&output, shape) 1240 if err != nil { 1241 var snapshot bytes.Buffer 1242 io.Copy(&snapshot, ringBuffer) 1243 err = &smithy.DeserializationError{ 1244 Err: fmt.Errorf("failed to decode response body, %w", err), 1245 Snapshot: snapshot.Bytes(), 1246 } 1247 return out, metadata, err 1248 } 1249 1250 return out, metadata, err 1251} 1252 1253func awsAwsjson11_deserializeOpErrorGetProtectionStatus(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1254 var errorBuffer bytes.Buffer 1255 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1256 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1257 } 1258 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1259 1260 errorCode := "UnknownError" 1261 errorMessage := errorCode 1262 1263 code := response.Header.Get("X-Amzn-ErrorType") 1264 if len(code) != 0 { 1265 errorCode = restjson.SanitizeErrorCode(code) 1266 } 1267 1268 var buff [1024]byte 1269 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1270 1271 body := io.TeeReader(errorBody, ringBuffer) 1272 decoder := json.NewDecoder(body) 1273 decoder.UseNumber() 1274 code, message, err := restjson.GetErrorInfo(decoder) 1275 if err != nil { 1276 var snapshot bytes.Buffer 1277 io.Copy(&snapshot, ringBuffer) 1278 err = &smithy.DeserializationError{ 1279 Err: fmt.Errorf("failed to decode response body, %w", err), 1280 Snapshot: snapshot.Bytes(), 1281 } 1282 return err 1283 } 1284 1285 errorBody.Seek(0, io.SeekStart) 1286 if len(code) != 0 { 1287 errorCode = restjson.SanitizeErrorCode(code) 1288 } 1289 if len(message) != 0 { 1290 errorMessage = message 1291 } 1292 1293 switch { 1294 case strings.EqualFold("InternalErrorException", errorCode): 1295 return awsAwsjson11_deserializeErrorInternalErrorException(response, errorBody) 1296 1297 case strings.EqualFold("InvalidInputException", errorCode): 1298 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 1299 1300 case strings.EqualFold("ResourceNotFoundException", errorCode): 1301 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 1302 1303 default: 1304 genericError := &smithy.GenericAPIError{ 1305 Code: errorCode, 1306 Message: errorMessage, 1307 } 1308 return genericError 1309 1310 } 1311} 1312 1313type awsAwsjson11_deserializeOpGetProtocolsList struct { 1314} 1315 1316func (*awsAwsjson11_deserializeOpGetProtocolsList) ID() string { 1317 return "OperationDeserializer" 1318} 1319 1320func (m *awsAwsjson11_deserializeOpGetProtocolsList) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1321 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1322) { 1323 out, metadata, err = next.HandleDeserialize(ctx, in) 1324 if err != nil { 1325 return out, metadata, err 1326 } 1327 1328 response, ok := out.RawResponse.(*smithyhttp.Response) 1329 if !ok { 1330 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1331 } 1332 1333 if response.StatusCode < 200 || response.StatusCode >= 300 { 1334 return out, metadata, awsAwsjson11_deserializeOpErrorGetProtocolsList(response, &metadata) 1335 } 1336 output := &GetProtocolsListOutput{} 1337 out.Result = output 1338 1339 var buff [1024]byte 1340 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1341 1342 body := io.TeeReader(response.Body, ringBuffer) 1343 decoder := json.NewDecoder(body) 1344 decoder.UseNumber() 1345 var shape interface{} 1346 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1347 var snapshot bytes.Buffer 1348 io.Copy(&snapshot, ringBuffer) 1349 err = &smithy.DeserializationError{ 1350 Err: fmt.Errorf("failed to decode response body, %w", err), 1351 Snapshot: snapshot.Bytes(), 1352 } 1353 return out, metadata, err 1354 } 1355 1356 err = awsAwsjson11_deserializeOpDocumentGetProtocolsListOutput(&output, shape) 1357 if err != nil { 1358 var snapshot bytes.Buffer 1359 io.Copy(&snapshot, ringBuffer) 1360 err = &smithy.DeserializationError{ 1361 Err: fmt.Errorf("failed to decode response body, %w", err), 1362 Snapshot: snapshot.Bytes(), 1363 } 1364 return out, metadata, err 1365 } 1366 1367 return out, metadata, err 1368} 1369 1370func awsAwsjson11_deserializeOpErrorGetProtocolsList(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1371 var errorBuffer bytes.Buffer 1372 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1373 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1374 } 1375 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1376 1377 errorCode := "UnknownError" 1378 errorMessage := errorCode 1379 1380 code := response.Header.Get("X-Amzn-ErrorType") 1381 if len(code) != 0 { 1382 errorCode = restjson.SanitizeErrorCode(code) 1383 } 1384 1385 var buff [1024]byte 1386 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1387 1388 body := io.TeeReader(errorBody, ringBuffer) 1389 decoder := json.NewDecoder(body) 1390 decoder.UseNumber() 1391 code, message, err := restjson.GetErrorInfo(decoder) 1392 if err != nil { 1393 var snapshot bytes.Buffer 1394 io.Copy(&snapshot, ringBuffer) 1395 err = &smithy.DeserializationError{ 1396 Err: fmt.Errorf("failed to decode response body, %w", err), 1397 Snapshot: snapshot.Bytes(), 1398 } 1399 return err 1400 } 1401 1402 errorBody.Seek(0, io.SeekStart) 1403 if len(code) != 0 { 1404 errorCode = restjson.SanitizeErrorCode(code) 1405 } 1406 if len(message) != 0 { 1407 errorMessage = message 1408 } 1409 1410 switch { 1411 case strings.EqualFold("InternalErrorException", errorCode): 1412 return awsAwsjson11_deserializeErrorInternalErrorException(response, errorBody) 1413 1414 case strings.EqualFold("InvalidOperationException", errorCode): 1415 return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody) 1416 1417 case strings.EqualFold("ResourceNotFoundException", errorCode): 1418 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 1419 1420 default: 1421 genericError := &smithy.GenericAPIError{ 1422 Code: errorCode, 1423 Message: errorMessage, 1424 } 1425 return genericError 1426 1427 } 1428} 1429 1430type awsAwsjson11_deserializeOpGetViolationDetails struct { 1431} 1432 1433func (*awsAwsjson11_deserializeOpGetViolationDetails) ID() string { 1434 return "OperationDeserializer" 1435} 1436 1437func (m *awsAwsjson11_deserializeOpGetViolationDetails) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1438 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1439) { 1440 out, metadata, err = next.HandleDeserialize(ctx, in) 1441 if err != nil { 1442 return out, metadata, err 1443 } 1444 1445 response, ok := out.RawResponse.(*smithyhttp.Response) 1446 if !ok { 1447 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1448 } 1449 1450 if response.StatusCode < 200 || response.StatusCode >= 300 { 1451 return out, metadata, awsAwsjson11_deserializeOpErrorGetViolationDetails(response, &metadata) 1452 } 1453 output := &GetViolationDetailsOutput{} 1454 out.Result = output 1455 1456 var buff [1024]byte 1457 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1458 1459 body := io.TeeReader(response.Body, ringBuffer) 1460 decoder := json.NewDecoder(body) 1461 decoder.UseNumber() 1462 var shape interface{} 1463 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1464 var snapshot bytes.Buffer 1465 io.Copy(&snapshot, ringBuffer) 1466 err = &smithy.DeserializationError{ 1467 Err: fmt.Errorf("failed to decode response body, %w", err), 1468 Snapshot: snapshot.Bytes(), 1469 } 1470 return out, metadata, err 1471 } 1472 1473 err = awsAwsjson11_deserializeOpDocumentGetViolationDetailsOutput(&output, shape) 1474 if err != nil { 1475 var snapshot bytes.Buffer 1476 io.Copy(&snapshot, ringBuffer) 1477 err = &smithy.DeserializationError{ 1478 Err: fmt.Errorf("failed to decode response body, %w", err), 1479 Snapshot: snapshot.Bytes(), 1480 } 1481 return out, metadata, err 1482 } 1483 1484 return out, metadata, err 1485} 1486 1487func awsAwsjson11_deserializeOpErrorGetViolationDetails(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1488 var errorBuffer bytes.Buffer 1489 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1490 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1491 } 1492 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1493 1494 errorCode := "UnknownError" 1495 errorMessage := errorCode 1496 1497 code := response.Header.Get("X-Amzn-ErrorType") 1498 if len(code) != 0 { 1499 errorCode = restjson.SanitizeErrorCode(code) 1500 } 1501 1502 var buff [1024]byte 1503 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1504 1505 body := io.TeeReader(errorBody, ringBuffer) 1506 decoder := json.NewDecoder(body) 1507 decoder.UseNumber() 1508 code, message, err := restjson.GetErrorInfo(decoder) 1509 if err != nil { 1510 var snapshot bytes.Buffer 1511 io.Copy(&snapshot, ringBuffer) 1512 err = &smithy.DeserializationError{ 1513 Err: fmt.Errorf("failed to decode response body, %w", err), 1514 Snapshot: snapshot.Bytes(), 1515 } 1516 return err 1517 } 1518 1519 errorBody.Seek(0, io.SeekStart) 1520 if len(code) != 0 { 1521 errorCode = restjson.SanitizeErrorCode(code) 1522 } 1523 if len(message) != 0 { 1524 errorMessage = message 1525 } 1526 1527 switch { 1528 case strings.EqualFold("InternalErrorException", errorCode): 1529 return awsAwsjson11_deserializeErrorInternalErrorException(response, errorBody) 1530 1531 case strings.EqualFold("InvalidInputException", errorCode): 1532 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 1533 1534 case strings.EqualFold("ResourceNotFoundException", errorCode): 1535 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 1536 1537 default: 1538 genericError := &smithy.GenericAPIError{ 1539 Code: errorCode, 1540 Message: errorMessage, 1541 } 1542 return genericError 1543 1544 } 1545} 1546 1547type awsAwsjson11_deserializeOpListAppsLists struct { 1548} 1549 1550func (*awsAwsjson11_deserializeOpListAppsLists) ID() string { 1551 return "OperationDeserializer" 1552} 1553 1554func (m *awsAwsjson11_deserializeOpListAppsLists) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1555 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1556) { 1557 out, metadata, err = next.HandleDeserialize(ctx, in) 1558 if err != nil { 1559 return out, metadata, err 1560 } 1561 1562 response, ok := out.RawResponse.(*smithyhttp.Response) 1563 if !ok { 1564 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1565 } 1566 1567 if response.StatusCode < 200 || response.StatusCode >= 300 { 1568 return out, metadata, awsAwsjson11_deserializeOpErrorListAppsLists(response, &metadata) 1569 } 1570 output := &ListAppsListsOutput{} 1571 out.Result = output 1572 1573 var buff [1024]byte 1574 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1575 1576 body := io.TeeReader(response.Body, ringBuffer) 1577 decoder := json.NewDecoder(body) 1578 decoder.UseNumber() 1579 var shape interface{} 1580 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1581 var snapshot bytes.Buffer 1582 io.Copy(&snapshot, ringBuffer) 1583 err = &smithy.DeserializationError{ 1584 Err: fmt.Errorf("failed to decode response body, %w", err), 1585 Snapshot: snapshot.Bytes(), 1586 } 1587 return out, metadata, err 1588 } 1589 1590 err = awsAwsjson11_deserializeOpDocumentListAppsListsOutput(&output, shape) 1591 if err != nil { 1592 var snapshot bytes.Buffer 1593 io.Copy(&snapshot, ringBuffer) 1594 err = &smithy.DeserializationError{ 1595 Err: fmt.Errorf("failed to decode response body, %w", err), 1596 Snapshot: snapshot.Bytes(), 1597 } 1598 return out, metadata, err 1599 } 1600 1601 return out, metadata, err 1602} 1603 1604func awsAwsjson11_deserializeOpErrorListAppsLists(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1605 var errorBuffer bytes.Buffer 1606 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1607 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1608 } 1609 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1610 1611 errorCode := "UnknownError" 1612 errorMessage := errorCode 1613 1614 code := response.Header.Get("X-Amzn-ErrorType") 1615 if len(code) != 0 { 1616 errorCode = restjson.SanitizeErrorCode(code) 1617 } 1618 1619 var buff [1024]byte 1620 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1621 1622 body := io.TeeReader(errorBody, ringBuffer) 1623 decoder := json.NewDecoder(body) 1624 decoder.UseNumber() 1625 code, message, err := restjson.GetErrorInfo(decoder) 1626 if err != nil { 1627 var snapshot bytes.Buffer 1628 io.Copy(&snapshot, ringBuffer) 1629 err = &smithy.DeserializationError{ 1630 Err: fmt.Errorf("failed to decode response body, %w", err), 1631 Snapshot: snapshot.Bytes(), 1632 } 1633 return err 1634 } 1635 1636 errorBody.Seek(0, io.SeekStart) 1637 if len(code) != 0 { 1638 errorCode = restjson.SanitizeErrorCode(code) 1639 } 1640 if len(message) != 0 { 1641 errorMessage = message 1642 } 1643 1644 switch { 1645 case strings.EqualFold("InternalErrorException", errorCode): 1646 return awsAwsjson11_deserializeErrorInternalErrorException(response, errorBody) 1647 1648 case strings.EqualFold("InvalidOperationException", errorCode): 1649 return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody) 1650 1651 case strings.EqualFold("LimitExceededException", errorCode): 1652 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 1653 1654 case strings.EqualFold("ResourceNotFoundException", errorCode): 1655 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 1656 1657 default: 1658 genericError := &smithy.GenericAPIError{ 1659 Code: errorCode, 1660 Message: errorMessage, 1661 } 1662 return genericError 1663 1664 } 1665} 1666 1667type awsAwsjson11_deserializeOpListComplianceStatus struct { 1668} 1669 1670func (*awsAwsjson11_deserializeOpListComplianceStatus) ID() string { 1671 return "OperationDeserializer" 1672} 1673 1674func (m *awsAwsjson11_deserializeOpListComplianceStatus) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1675 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1676) { 1677 out, metadata, err = next.HandleDeserialize(ctx, in) 1678 if err != nil { 1679 return out, metadata, err 1680 } 1681 1682 response, ok := out.RawResponse.(*smithyhttp.Response) 1683 if !ok { 1684 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1685 } 1686 1687 if response.StatusCode < 200 || response.StatusCode >= 300 { 1688 return out, metadata, awsAwsjson11_deserializeOpErrorListComplianceStatus(response, &metadata) 1689 } 1690 output := &ListComplianceStatusOutput{} 1691 out.Result = output 1692 1693 var buff [1024]byte 1694 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1695 1696 body := io.TeeReader(response.Body, ringBuffer) 1697 decoder := json.NewDecoder(body) 1698 decoder.UseNumber() 1699 var shape interface{} 1700 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1701 var snapshot bytes.Buffer 1702 io.Copy(&snapshot, ringBuffer) 1703 err = &smithy.DeserializationError{ 1704 Err: fmt.Errorf("failed to decode response body, %w", err), 1705 Snapshot: snapshot.Bytes(), 1706 } 1707 return out, metadata, err 1708 } 1709 1710 err = awsAwsjson11_deserializeOpDocumentListComplianceStatusOutput(&output, shape) 1711 if err != nil { 1712 var snapshot bytes.Buffer 1713 io.Copy(&snapshot, ringBuffer) 1714 err = &smithy.DeserializationError{ 1715 Err: fmt.Errorf("failed to decode response body, %w", err), 1716 Snapshot: snapshot.Bytes(), 1717 } 1718 return out, metadata, err 1719 } 1720 1721 return out, metadata, err 1722} 1723 1724func awsAwsjson11_deserializeOpErrorListComplianceStatus(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1725 var errorBuffer bytes.Buffer 1726 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1727 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1728 } 1729 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1730 1731 errorCode := "UnknownError" 1732 errorMessage := errorCode 1733 1734 code := response.Header.Get("X-Amzn-ErrorType") 1735 if len(code) != 0 { 1736 errorCode = restjson.SanitizeErrorCode(code) 1737 } 1738 1739 var buff [1024]byte 1740 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1741 1742 body := io.TeeReader(errorBody, ringBuffer) 1743 decoder := json.NewDecoder(body) 1744 decoder.UseNumber() 1745 code, message, err := restjson.GetErrorInfo(decoder) 1746 if err != nil { 1747 var snapshot bytes.Buffer 1748 io.Copy(&snapshot, ringBuffer) 1749 err = &smithy.DeserializationError{ 1750 Err: fmt.Errorf("failed to decode response body, %w", err), 1751 Snapshot: snapshot.Bytes(), 1752 } 1753 return err 1754 } 1755 1756 errorBody.Seek(0, io.SeekStart) 1757 if len(code) != 0 { 1758 errorCode = restjson.SanitizeErrorCode(code) 1759 } 1760 if len(message) != 0 { 1761 errorMessage = message 1762 } 1763 1764 switch { 1765 case strings.EqualFold("InternalErrorException", errorCode): 1766 return awsAwsjson11_deserializeErrorInternalErrorException(response, errorBody) 1767 1768 case strings.EqualFold("ResourceNotFoundException", errorCode): 1769 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 1770 1771 default: 1772 genericError := &smithy.GenericAPIError{ 1773 Code: errorCode, 1774 Message: errorMessage, 1775 } 1776 return genericError 1777 1778 } 1779} 1780 1781type awsAwsjson11_deserializeOpListMemberAccounts struct { 1782} 1783 1784func (*awsAwsjson11_deserializeOpListMemberAccounts) ID() string { 1785 return "OperationDeserializer" 1786} 1787 1788func (m *awsAwsjson11_deserializeOpListMemberAccounts) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1789 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1790) { 1791 out, metadata, err = next.HandleDeserialize(ctx, in) 1792 if err != nil { 1793 return out, metadata, err 1794 } 1795 1796 response, ok := out.RawResponse.(*smithyhttp.Response) 1797 if !ok { 1798 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1799 } 1800 1801 if response.StatusCode < 200 || response.StatusCode >= 300 { 1802 return out, metadata, awsAwsjson11_deserializeOpErrorListMemberAccounts(response, &metadata) 1803 } 1804 output := &ListMemberAccountsOutput{} 1805 out.Result = output 1806 1807 var buff [1024]byte 1808 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1809 1810 body := io.TeeReader(response.Body, ringBuffer) 1811 decoder := json.NewDecoder(body) 1812 decoder.UseNumber() 1813 var shape interface{} 1814 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1815 var snapshot bytes.Buffer 1816 io.Copy(&snapshot, ringBuffer) 1817 err = &smithy.DeserializationError{ 1818 Err: fmt.Errorf("failed to decode response body, %w", err), 1819 Snapshot: snapshot.Bytes(), 1820 } 1821 return out, metadata, err 1822 } 1823 1824 err = awsAwsjson11_deserializeOpDocumentListMemberAccountsOutput(&output, shape) 1825 if err != nil { 1826 var snapshot bytes.Buffer 1827 io.Copy(&snapshot, ringBuffer) 1828 err = &smithy.DeserializationError{ 1829 Err: fmt.Errorf("failed to decode response body, %w", err), 1830 Snapshot: snapshot.Bytes(), 1831 } 1832 return out, metadata, err 1833 } 1834 1835 return out, metadata, err 1836} 1837 1838func awsAwsjson11_deserializeOpErrorListMemberAccounts(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1839 var errorBuffer bytes.Buffer 1840 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1841 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1842 } 1843 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1844 1845 errorCode := "UnknownError" 1846 errorMessage := errorCode 1847 1848 code := response.Header.Get("X-Amzn-ErrorType") 1849 if len(code) != 0 { 1850 errorCode = restjson.SanitizeErrorCode(code) 1851 } 1852 1853 var buff [1024]byte 1854 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1855 1856 body := io.TeeReader(errorBody, ringBuffer) 1857 decoder := json.NewDecoder(body) 1858 decoder.UseNumber() 1859 code, message, err := restjson.GetErrorInfo(decoder) 1860 if err != nil { 1861 var snapshot bytes.Buffer 1862 io.Copy(&snapshot, ringBuffer) 1863 err = &smithy.DeserializationError{ 1864 Err: fmt.Errorf("failed to decode response body, %w", err), 1865 Snapshot: snapshot.Bytes(), 1866 } 1867 return err 1868 } 1869 1870 errorBody.Seek(0, io.SeekStart) 1871 if len(code) != 0 { 1872 errorCode = restjson.SanitizeErrorCode(code) 1873 } 1874 if len(message) != 0 { 1875 errorMessage = message 1876 } 1877 1878 switch { 1879 case strings.EqualFold("InternalErrorException", errorCode): 1880 return awsAwsjson11_deserializeErrorInternalErrorException(response, errorBody) 1881 1882 case strings.EqualFold("ResourceNotFoundException", errorCode): 1883 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 1884 1885 default: 1886 genericError := &smithy.GenericAPIError{ 1887 Code: errorCode, 1888 Message: errorMessage, 1889 } 1890 return genericError 1891 1892 } 1893} 1894 1895type awsAwsjson11_deserializeOpListPolicies struct { 1896} 1897 1898func (*awsAwsjson11_deserializeOpListPolicies) ID() string { 1899 return "OperationDeserializer" 1900} 1901 1902func (m *awsAwsjson11_deserializeOpListPolicies) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1903 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1904) { 1905 out, metadata, err = next.HandleDeserialize(ctx, in) 1906 if err != nil { 1907 return out, metadata, err 1908 } 1909 1910 response, ok := out.RawResponse.(*smithyhttp.Response) 1911 if !ok { 1912 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1913 } 1914 1915 if response.StatusCode < 200 || response.StatusCode >= 300 { 1916 return out, metadata, awsAwsjson11_deserializeOpErrorListPolicies(response, &metadata) 1917 } 1918 output := &ListPoliciesOutput{} 1919 out.Result = output 1920 1921 var buff [1024]byte 1922 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1923 1924 body := io.TeeReader(response.Body, ringBuffer) 1925 decoder := json.NewDecoder(body) 1926 decoder.UseNumber() 1927 var shape interface{} 1928 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1929 var snapshot bytes.Buffer 1930 io.Copy(&snapshot, ringBuffer) 1931 err = &smithy.DeserializationError{ 1932 Err: fmt.Errorf("failed to decode response body, %w", err), 1933 Snapshot: snapshot.Bytes(), 1934 } 1935 return out, metadata, err 1936 } 1937 1938 err = awsAwsjson11_deserializeOpDocumentListPoliciesOutput(&output, shape) 1939 if err != nil { 1940 var snapshot bytes.Buffer 1941 io.Copy(&snapshot, ringBuffer) 1942 err = &smithy.DeserializationError{ 1943 Err: fmt.Errorf("failed to decode response body, %w", err), 1944 Snapshot: snapshot.Bytes(), 1945 } 1946 return out, metadata, err 1947 } 1948 1949 return out, metadata, err 1950} 1951 1952func awsAwsjson11_deserializeOpErrorListPolicies(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1953 var errorBuffer bytes.Buffer 1954 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1955 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1956 } 1957 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1958 1959 errorCode := "UnknownError" 1960 errorMessage := errorCode 1961 1962 code := response.Header.Get("X-Amzn-ErrorType") 1963 if len(code) != 0 { 1964 errorCode = restjson.SanitizeErrorCode(code) 1965 } 1966 1967 var buff [1024]byte 1968 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1969 1970 body := io.TeeReader(errorBody, ringBuffer) 1971 decoder := json.NewDecoder(body) 1972 decoder.UseNumber() 1973 code, message, err := restjson.GetErrorInfo(decoder) 1974 if err != nil { 1975 var snapshot bytes.Buffer 1976 io.Copy(&snapshot, ringBuffer) 1977 err = &smithy.DeserializationError{ 1978 Err: fmt.Errorf("failed to decode response body, %w", err), 1979 Snapshot: snapshot.Bytes(), 1980 } 1981 return err 1982 } 1983 1984 errorBody.Seek(0, io.SeekStart) 1985 if len(code) != 0 { 1986 errorCode = restjson.SanitizeErrorCode(code) 1987 } 1988 if len(message) != 0 { 1989 errorMessage = message 1990 } 1991 1992 switch { 1993 case strings.EqualFold("InternalErrorException", errorCode): 1994 return awsAwsjson11_deserializeErrorInternalErrorException(response, errorBody) 1995 1996 case strings.EqualFold("InvalidOperationException", errorCode): 1997 return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody) 1998 1999 case strings.EqualFold("LimitExceededException", errorCode): 2000 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 2001 2002 case strings.EqualFold("ResourceNotFoundException", errorCode): 2003 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 2004 2005 default: 2006 genericError := &smithy.GenericAPIError{ 2007 Code: errorCode, 2008 Message: errorMessage, 2009 } 2010 return genericError 2011 2012 } 2013} 2014 2015type awsAwsjson11_deserializeOpListProtocolsLists struct { 2016} 2017 2018func (*awsAwsjson11_deserializeOpListProtocolsLists) ID() string { 2019 return "OperationDeserializer" 2020} 2021 2022func (m *awsAwsjson11_deserializeOpListProtocolsLists) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2023 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2024) { 2025 out, metadata, err = next.HandleDeserialize(ctx, in) 2026 if err != nil { 2027 return out, metadata, err 2028 } 2029 2030 response, ok := out.RawResponse.(*smithyhttp.Response) 2031 if !ok { 2032 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2033 } 2034 2035 if response.StatusCode < 200 || response.StatusCode >= 300 { 2036 return out, metadata, awsAwsjson11_deserializeOpErrorListProtocolsLists(response, &metadata) 2037 } 2038 output := &ListProtocolsListsOutput{} 2039 out.Result = output 2040 2041 var buff [1024]byte 2042 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2043 2044 body := io.TeeReader(response.Body, ringBuffer) 2045 decoder := json.NewDecoder(body) 2046 decoder.UseNumber() 2047 var shape interface{} 2048 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2049 var snapshot bytes.Buffer 2050 io.Copy(&snapshot, ringBuffer) 2051 err = &smithy.DeserializationError{ 2052 Err: fmt.Errorf("failed to decode response body, %w", err), 2053 Snapshot: snapshot.Bytes(), 2054 } 2055 return out, metadata, err 2056 } 2057 2058 err = awsAwsjson11_deserializeOpDocumentListProtocolsListsOutput(&output, shape) 2059 if err != nil { 2060 var snapshot bytes.Buffer 2061 io.Copy(&snapshot, ringBuffer) 2062 err = &smithy.DeserializationError{ 2063 Err: fmt.Errorf("failed to decode response body, %w", err), 2064 Snapshot: snapshot.Bytes(), 2065 } 2066 return out, metadata, err 2067 } 2068 2069 return out, metadata, err 2070} 2071 2072func awsAwsjson11_deserializeOpErrorListProtocolsLists(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2073 var errorBuffer bytes.Buffer 2074 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2075 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2076 } 2077 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2078 2079 errorCode := "UnknownError" 2080 errorMessage := errorCode 2081 2082 code := response.Header.Get("X-Amzn-ErrorType") 2083 if len(code) != 0 { 2084 errorCode = restjson.SanitizeErrorCode(code) 2085 } 2086 2087 var buff [1024]byte 2088 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2089 2090 body := io.TeeReader(errorBody, ringBuffer) 2091 decoder := json.NewDecoder(body) 2092 decoder.UseNumber() 2093 code, message, err := restjson.GetErrorInfo(decoder) 2094 if err != nil { 2095 var snapshot bytes.Buffer 2096 io.Copy(&snapshot, ringBuffer) 2097 err = &smithy.DeserializationError{ 2098 Err: fmt.Errorf("failed to decode response body, %w", err), 2099 Snapshot: snapshot.Bytes(), 2100 } 2101 return err 2102 } 2103 2104 errorBody.Seek(0, io.SeekStart) 2105 if len(code) != 0 { 2106 errorCode = restjson.SanitizeErrorCode(code) 2107 } 2108 if len(message) != 0 { 2109 errorMessage = message 2110 } 2111 2112 switch { 2113 case strings.EqualFold("InternalErrorException", errorCode): 2114 return awsAwsjson11_deserializeErrorInternalErrorException(response, errorBody) 2115 2116 case strings.EqualFold("InvalidOperationException", errorCode): 2117 return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody) 2118 2119 case strings.EqualFold("ResourceNotFoundException", errorCode): 2120 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 2121 2122 default: 2123 genericError := &smithy.GenericAPIError{ 2124 Code: errorCode, 2125 Message: errorMessage, 2126 } 2127 return genericError 2128 2129 } 2130} 2131 2132type awsAwsjson11_deserializeOpListTagsForResource struct { 2133} 2134 2135func (*awsAwsjson11_deserializeOpListTagsForResource) ID() string { 2136 return "OperationDeserializer" 2137} 2138 2139func (m *awsAwsjson11_deserializeOpListTagsForResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2140 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2141) { 2142 out, metadata, err = next.HandleDeserialize(ctx, in) 2143 if err != nil { 2144 return out, metadata, err 2145 } 2146 2147 response, ok := out.RawResponse.(*smithyhttp.Response) 2148 if !ok { 2149 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2150 } 2151 2152 if response.StatusCode < 200 || response.StatusCode >= 300 { 2153 return out, metadata, awsAwsjson11_deserializeOpErrorListTagsForResource(response, &metadata) 2154 } 2155 output := &ListTagsForResourceOutput{} 2156 out.Result = output 2157 2158 var buff [1024]byte 2159 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2160 2161 body := io.TeeReader(response.Body, ringBuffer) 2162 decoder := json.NewDecoder(body) 2163 decoder.UseNumber() 2164 var shape interface{} 2165 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2166 var snapshot bytes.Buffer 2167 io.Copy(&snapshot, ringBuffer) 2168 err = &smithy.DeserializationError{ 2169 Err: fmt.Errorf("failed to decode response body, %w", err), 2170 Snapshot: snapshot.Bytes(), 2171 } 2172 return out, metadata, err 2173 } 2174 2175 err = awsAwsjson11_deserializeOpDocumentListTagsForResourceOutput(&output, shape) 2176 if err != nil { 2177 var snapshot bytes.Buffer 2178 io.Copy(&snapshot, ringBuffer) 2179 err = &smithy.DeserializationError{ 2180 Err: fmt.Errorf("failed to decode response body, %w", err), 2181 Snapshot: snapshot.Bytes(), 2182 } 2183 return out, metadata, err 2184 } 2185 2186 return out, metadata, err 2187} 2188 2189func awsAwsjson11_deserializeOpErrorListTagsForResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2190 var errorBuffer bytes.Buffer 2191 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2192 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2193 } 2194 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2195 2196 errorCode := "UnknownError" 2197 errorMessage := errorCode 2198 2199 code := response.Header.Get("X-Amzn-ErrorType") 2200 if len(code) != 0 { 2201 errorCode = restjson.SanitizeErrorCode(code) 2202 } 2203 2204 var buff [1024]byte 2205 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2206 2207 body := io.TeeReader(errorBody, ringBuffer) 2208 decoder := json.NewDecoder(body) 2209 decoder.UseNumber() 2210 code, message, err := restjson.GetErrorInfo(decoder) 2211 if err != nil { 2212 var snapshot bytes.Buffer 2213 io.Copy(&snapshot, ringBuffer) 2214 err = &smithy.DeserializationError{ 2215 Err: fmt.Errorf("failed to decode response body, %w", err), 2216 Snapshot: snapshot.Bytes(), 2217 } 2218 return err 2219 } 2220 2221 errorBody.Seek(0, io.SeekStart) 2222 if len(code) != 0 { 2223 errorCode = restjson.SanitizeErrorCode(code) 2224 } 2225 if len(message) != 0 { 2226 errorMessage = message 2227 } 2228 2229 switch { 2230 case strings.EqualFold("InternalErrorException", errorCode): 2231 return awsAwsjson11_deserializeErrorInternalErrorException(response, errorBody) 2232 2233 case strings.EqualFold("InvalidInputException", errorCode): 2234 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 2235 2236 case strings.EqualFold("InvalidOperationException", errorCode): 2237 return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody) 2238 2239 case strings.EqualFold("ResourceNotFoundException", errorCode): 2240 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 2241 2242 default: 2243 genericError := &smithy.GenericAPIError{ 2244 Code: errorCode, 2245 Message: errorMessage, 2246 } 2247 return genericError 2248 2249 } 2250} 2251 2252type awsAwsjson11_deserializeOpPutAppsList struct { 2253} 2254 2255func (*awsAwsjson11_deserializeOpPutAppsList) ID() string { 2256 return "OperationDeserializer" 2257} 2258 2259func (m *awsAwsjson11_deserializeOpPutAppsList) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2260 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2261) { 2262 out, metadata, err = next.HandleDeserialize(ctx, in) 2263 if err != nil { 2264 return out, metadata, err 2265 } 2266 2267 response, ok := out.RawResponse.(*smithyhttp.Response) 2268 if !ok { 2269 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2270 } 2271 2272 if response.StatusCode < 200 || response.StatusCode >= 300 { 2273 return out, metadata, awsAwsjson11_deserializeOpErrorPutAppsList(response, &metadata) 2274 } 2275 output := &PutAppsListOutput{} 2276 out.Result = output 2277 2278 var buff [1024]byte 2279 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2280 2281 body := io.TeeReader(response.Body, ringBuffer) 2282 decoder := json.NewDecoder(body) 2283 decoder.UseNumber() 2284 var shape interface{} 2285 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2286 var snapshot bytes.Buffer 2287 io.Copy(&snapshot, ringBuffer) 2288 err = &smithy.DeserializationError{ 2289 Err: fmt.Errorf("failed to decode response body, %w", err), 2290 Snapshot: snapshot.Bytes(), 2291 } 2292 return out, metadata, err 2293 } 2294 2295 err = awsAwsjson11_deserializeOpDocumentPutAppsListOutput(&output, shape) 2296 if err != nil { 2297 var snapshot bytes.Buffer 2298 io.Copy(&snapshot, ringBuffer) 2299 err = &smithy.DeserializationError{ 2300 Err: fmt.Errorf("failed to decode response body, %w", err), 2301 Snapshot: snapshot.Bytes(), 2302 } 2303 return out, metadata, err 2304 } 2305 2306 return out, metadata, err 2307} 2308 2309func awsAwsjson11_deserializeOpErrorPutAppsList(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2310 var errorBuffer bytes.Buffer 2311 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2312 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2313 } 2314 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2315 2316 errorCode := "UnknownError" 2317 errorMessage := errorCode 2318 2319 code := response.Header.Get("X-Amzn-ErrorType") 2320 if len(code) != 0 { 2321 errorCode = restjson.SanitizeErrorCode(code) 2322 } 2323 2324 var buff [1024]byte 2325 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2326 2327 body := io.TeeReader(errorBody, ringBuffer) 2328 decoder := json.NewDecoder(body) 2329 decoder.UseNumber() 2330 code, message, err := restjson.GetErrorInfo(decoder) 2331 if err != nil { 2332 var snapshot bytes.Buffer 2333 io.Copy(&snapshot, ringBuffer) 2334 err = &smithy.DeserializationError{ 2335 Err: fmt.Errorf("failed to decode response body, %w", err), 2336 Snapshot: snapshot.Bytes(), 2337 } 2338 return err 2339 } 2340 2341 errorBody.Seek(0, io.SeekStart) 2342 if len(code) != 0 { 2343 errorCode = restjson.SanitizeErrorCode(code) 2344 } 2345 if len(message) != 0 { 2346 errorMessage = message 2347 } 2348 2349 switch { 2350 case strings.EqualFold("InternalErrorException", errorCode): 2351 return awsAwsjson11_deserializeErrorInternalErrorException(response, errorBody) 2352 2353 case strings.EqualFold("InvalidInputException", errorCode): 2354 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 2355 2356 case strings.EqualFold("InvalidOperationException", errorCode): 2357 return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody) 2358 2359 case strings.EqualFold("LimitExceededException", errorCode): 2360 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 2361 2362 case strings.EqualFold("ResourceNotFoundException", errorCode): 2363 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 2364 2365 default: 2366 genericError := &smithy.GenericAPIError{ 2367 Code: errorCode, 2368 Message: errorMessage, 2369 } 2370 return genericError 2371 2372 } 2373} 2374 2375type awsAwsjson11_deserializeOpPutNotificationChannel struct { 2376} 2377 2378func (*awsAwsjson11_deserializeOpPutNotificationChannel) ID() string { 2379 return "OperationDeserializer" 2380} 2381 2382func (m *awsAwsjson11_deserializeOpPutNotificationChannel) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2383 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2384) { 2385 out, metadata, err = next.HandleDeserialize(ctx, in) 2386 if err != nil { 2387 return out, metadata, err 2388 } 2389 2390 response, ok := out.RawResponse.(*smithyhttp.Response) 2391 if !ok { 2392 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2393 } 2394 2395 if response.StatusCode < 200 || response.StatusCode >= 300 { 2396 return out, metadata, awsAwsjson11_deserializeOpErrorPutNotificationChannel(response, &metadata) 2397 } 2398 output := &PutNotificationChannelOutput{} 2399 out.Result = output 2400 2401 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 2402 return out, metadata, &smithy.DeserializationError{ 2403 Err: fmt.Errorf("failed to discard response body, %w", err), 2404 } 2405 } 2406 2407 return out, metadata, err 2408} 2409 2410func awsAwsjson11_deserializeOpErrorPutNotificationChannel(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2411 var errorBuffer bytes.Buffer 2412 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2413 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2414 } 2415 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2416 2417 errorCode := "UnknownError" 2418 errorMessage := errorCode 2419 2420 code := response.Header.Get("X-Amzn-ErrorType") 2421 if len(code) != 0 { 2422 errorCode = restjson.SanitizeErrorCode(code) 2423 } 2424 2425 var buff [1024]byte 2426 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2427 2428 body := io.TeeReader(errorBody, ringBuffer) 2429 decoder := json.NewDecoder(body) 2430 decoder.UseNumber() 2431 code, message, err := restjson.GetErrorInfo(decoder) 2432 if err != nil { 2433 var snapshot bytes.Buffer 2434 io.Copy(&snapshot, ringBuffer) 2435 err = &smithy.DeserializationError{ 2436 Err: fmt.Errorf("failed to decode response body, %w", err), 2437 Snapshot: snapshot.Bytes(), 2438 } 2439 return err 2440 } 2441 2442 errorBody.Seek(0, io.SeekStart) 2443 if len(code) != 0 { 2444 errorCode = restjson.SanitizeErrorCode(code) 2445 } 2446 if len(message) != 0 { 2447 errorMessage = message 2448 } 2449 2450 switch { 2451 case strings.EqualFold("InternalErrorException", errorCode): 2452 return awsAwsjson11_deserializeErrorInternalErrorException(response, errorBody) 2453 2454 case strings.EqualFold("InvalidOperationException", errorCode): 2455 return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody) 2456 2457 case strings.EqualFold("ResourceNotFoundException", errorCode): 2458 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 2459 2460 default: 2461 genericError := &smithy.GenericAPIError{ 2462 Code: errorCode, 2463 Message: errorMessage, 2464 } 2465 return genericError 2466 2467 } 2468} 2469 2470type awsAwsjson11_deserializeOpPutPolicy struct { 2471} 2472 2473func (*awsAwsjson11_deserializeOpPutPolicy) ID() string { 2474 return "OperationDeserializer" 2475} 2476 2477func (m *awsAwsjson11_deserializeOpPutPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2478 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2479) { 2480 out, metadata, err = next.HandleDeserialize(ctx, in) 2481 if err != nil { 2482 return out, metadata, err 2483 } 2484 2485 response, ok := out.RawResponse.(*smithyhttp.Response) 2486 if !ok { 2487 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2488 } 2489 2490 if response.StatusCode < 200 || response.StatusCode >= 300 { 2491 return out, metadata, awsAwsjson11_deserializeOpErrorPutPolicy(response, &metadata) 2492 } 2493 output := &PutPolicyOutput{} 2494 out.Result = output 2495 2496 var buff [1024]byte 2497 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2498 2499 body := io.TeeReader(response.Body, ringBuffer) 2500 decoder := json.NewDecoder(body) 2501 decoder.UseNumber() 2502 var shape interface{} 2503 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2504 var snapshot bytes.Buffer 2505 io.Copy(&snapshot, ringBuffer) 2506 err = &smithy.DeserializationError{ 2507 Err: fmt.Errorf("failed to decode response body, %w", err), 2508 Snapshot: snapshot.Bytes(), 2509 } 2510 return out, metadata, err 2511 } 2512 2513 err = awsAwsjson11_deserializeOpDocumentPutPolicyOutput(&output, shape) 2514 if err != nil { 2515 var snapshot bytes.Buffer 2516 io.Copy(&snapshot, ringBuffer) 2517 err = &smithy.DeserializationError{ 2518 Err: fmt.Errorf("failed to decode response body, %w", err), 2519 Snapshot: snapshot.Bytes(), 2520 } 2521 return out, metadata, err 2522 } 2523 2524 return out, metadata, err 2525} 2526 2527func awsAwsjson11_deserializeOpErrorPutPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2528 var errorBuffer bytes.Buffer 2529 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2530 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2531 } 2532 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2533 2534 errorCode := "UnknownError" 2535 errorMessage := errorCode 2536 2537 code := response.Header.Get("X-Amzn-ErrorType") 2538 if len(code) != 0 { 2539 errorCode = restjson.SanitizeErrorCode(code) 2540 } 2541 2542 var buff [1024]byte 2543 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2544 2545 body := io.TeeReader(errorBody, ringBuffer) 2546 decoder := json.NewDecoder(body) 2547 decoder.UseNumber() 2548 code, message, err := restjson.GetErrorInfo(decoder) 2549 if err != nil { 2550 var snapshot bytes.Buffer 2551 io.Copy(&snapshot, ringBuffer) 2552 err = &smithy.DeserializationError{ 2553 Err: fmt.Errorf("failed to decode response body, %w", err), 2554 Snapshot: snapshot.Bytes(), 2555 } 2556 return err 2557 } 2558 2559 errorBody.Seek(0, io.SeekStart) 2560 if len(code) != 0 { 2561 errorCode = restjson.SanitizeErrorCode(code) 2562 } 2563 if len(message) != 0 { 2564 errorMessage = message 2565 } 2566 2567 switch { 2568 case strings.EqualFold("InternalErrorException", errorCode): 2569 return awsAwsjson11_deserializeErrorInternalErrorException(response, errorBody) 2570 2571 case strings.EqualFold("InvalidInputException", errorCode): 2572 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 2573 2574 case strings.EqualFold("InvalidOperationException", errorCode): 2575 return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody) 2576 2577 case strings.EqualFold("InvalidTypeException", errorCode): 2578 return awsAwsjson11_deserializeErrorInvalidTypeException(response, errorBody) 2579 2580 case strings.EqualFold("LimitExceededException", errorCode): 2581 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 2582 2583 case strings.EqualFold("ResourceNotFoundException", errorCode): 2584 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 2585 2586 default: 2587 genericError := &smithy.GenericAPIError{ 2588 Code: errorCode, 2589 Message: errorMessage, 2590 } 2591 return genericError 2592 2593 } 2594} 2595 2596type awsAwsjson11_deserializeOpPutProtocolsList struct { 2597} 2598 2599func (*awsAwsjson11_deserializeOpPutProtocolsList) ID() string { 2600 return "OperationDeserializer" 2601} 2602 2603func (m *awsAwsjson11_deserializeOpPutProtocolsList) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2604 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2605) { 2606 out, metadata, err = next.HandleDeserialize(ctx, in) 2607 if err != nil { 2608 return out, metadata, err 2609 } 2610 2611 response, ok := out.RawResponse.(*smithyhttp.Response) 2612 if !ok { 2613 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2614 } 2615 2616 if response.StatusCode < 200 || response.StatusCode >= 300 { 2617 return out, metadata, awsAwsjson11_deserializeOpErrorPutProtocolsList(response, &metadata) 2618 } 2619 output := &PutProtocolsListOutput{} 2620 out.Result = output 2621 2622 var buff [1024]byte 2623 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2624 2625 body := io.TeeReader(response.Body, ringBuffer) 2626 decoder := json.NewDecoder(body) 2627 decoder.UseNumber() 2628 var shape interface{} 2629 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2630 var snapshot bytes.Buffer 2631 io.Copy(&snapshot, ringBuffer) 2632 err = &smithy.DeserializationError{ 2633 Err: fmt.Errorf("failed to decode response body, %w", err), 2634 Snapshot: snapshot.Bytes(), 2635 } 2636 return out, metadata, err 2637 } 2638 2639 err = awsAwsjson11_deserializeOpDocumentPutProtocolsListOutput(&output, shape) 2640 if err != nil { 2641 var snapshot bytes.Buffer 2642 io.Copy(&snapshot, ringBuffer) 2643 err = &smithy.DeserializationError{ 2644 Err: fmt.Errorf("failed to decode response body, %w", err), 2645 Snapshot: snapshot.Bytes(), 2646 } 2647 return out, metadata, err 2648 } 2649 2650 return out, metadata, err 2651} 2652 2653func awsAwsjson11_deserializeOpErrorPutProtocolsList(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2654 var errorBuffer bytes.Buffer 2655 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2656 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2657 } 2658 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2659 2660 errorCode := "UnknownError" 2661 errorMessage := errorCode 2662 2663 code := response.Header.Get("X-Amzn-ErrorType") 2664 if len(code) != 0 { 2665 errorCode = restjson.SanitizeErrorCode(code) 2666 } 2667 2668 var buff [1024]byte 2669 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2670 2671 body := io.TeeReader(errorBody, ringBuffer) 2672 decoder := json.NewDecoder(body) 2673 decoder.UseNumber() 2674 code, message, err := restjson.GetErrorInfo(decoder) 2675 if err != nil { 2676 var snapshot bytes.Buffer 2677 io.Copy(&snapshot, ringBuffer) 2678 err = &smithy.DeserializationError{ 2679 Err: fmt.Errorf("failed to decode response body, %w", err), 2680 Snapshot: snapshot.Bytes(), 2681 } 2682 return err 2683 } 2684 2685 errorBody.Seek(0, io.SeekStart) 2686 if len(code) != 0 { 2687 errorCode = restjson.SanitizeErrorCode(code) 2688 } 2689 if len(message) != 0 { 2690 errorMessage = message 2691 } 2692 2693 switch { 2694 case strings.EqualFold("InternalErrorException", errorCode): 2695 return awsAwsjson11_deserializeErrorInternalErrorException(response, errorBody) 2696 2697 case strings.EqualFold("InvalidInputException", errorCode): 2698 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 2699 2700 case strings.EqualFold("InvalidOperationException", errorCode): 2701 return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody) 2702 2703 case strings.EqualFold("LimitExceededException", errorCode): 2704 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 2705 2706 case strings.EqualFold("ResourceNotFoundException", errorCode): 2707 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 2708 2709 default: 2710 genericError := &smithy.GenericAPIError{ 2711 Code: errorCode, 2712 Message: errorMessage, 2713 } 2714 return genericError 2715 2716 } 2717} 2718 2719type awsAwsjson11_deserializeOpTagResource struct { 2720} 2721 2722func (*awsAwsjson11_deserializeOpTagResource) ID() string { 2723 return "OperationDeserializer" 2724} 2725 2726func (m *awsAwsjson11_deserializeOpTagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2727 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2728) { 2729 out, metadata, err = next.HandleDeserialize(ctx, in) 2730 if err != nil { 2731 return out, metadata, err 2732 } 2733 2734 response, ok := out.RawResponse.(*smithyhttp.Response) 2735 if !ok { 2736 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2737 } 2738 2739 if response.StatusCode < 200 || response.StatusCode >= 300 { 2740 return out, metadata, awsAwsjson11_deserializeOpErrorTagResource(response, &metadata) 2741 } 2742 output := &TagResourceOutput{} 2743 out.Result = output 2744 2745 var buff [1024]byte 2746 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2747 2748 body := io.TeeReader(response.Body, ringBuffer) 2749 decoder := json.NewDecoder(body) 2750 decoder.UseNumber() 2751 var shape interface{} 2752 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2753 var snapshot bytes.Buffer 2754 io.Copy(&snapshot, ringBuffer) 2755 err = &smithy.DeserializationError{ 2756 Err: fmt.Errorf("failed to decode response body, %w", err), 2757 Snapshot: snapshot.Bytes(), 2758 } 2759 return out, metadata, err 2760 } 2761 2762 err = awsAwsjson11_deserializeOpDocumentTagResourceOutput(&output, shape) 2763 if err != nil { 2764 var snapshot bytes.Buffer 2765 io.Copy(&snapshot, ringBuffer) 2766 err = &smithy.DeserializationError{ 2767 Err: fmt.Errorf("failed to decode response body, %w", err), 2768 Snapshot: snapshot.Bytes(), 2769 } 2770 return out, metadata, err 2771 } 2772 2773 return out, metadata, err 2774} 2775 2776func awsAwsjson11_deserializeOpErrorTagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2777 var errorBuffer bytes.Buffer 2778 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2779 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2780 } 2781 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2782 2783 errorCode := "UnknownError" 2784 errorMessage := errorCode 2785 2786 code := response.Header.Get("X-Amzn-ErrorType") 2787 if len(code) != 0 { 2788 errorCode = restjson.SanitizeErrorCode(code) 2789 } 2790 2791 var buff [1024]byte 2792 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2793 2794 body := io.TeeReader(errorBody, ringBuffer) 2795 decoder := json.NewDecoder(body) 2796 decoder.UseNumber() 2797 code, message, err := restjson.GetErrorInfo(decoder) 2798 if err != nil { 2799 var snapshot bytes.Buffer 2800 io.Copy(&snapshot, ringBuffer) 2801 err = &smithy.DeserializationError{ 2802 Err: fmt.Errorf("failed to decode response body, %w", err), 2803 Snapshot: snapshot.Bytes(), 2804 } 2805 return err 2806 } 2807 2808 errorBody.Seek(0, io.SeekStart) 2809 if len(code) != 0 { 2810 errorCode = restjson.SanitizeErrorCode(code) 2811 } 2812 if len(message) != 0 { 2813 errorMessage = message 2814 } 2815 2816 switch { 2817 case strings.EqualFold("InternalErrorException", errorCode): 2818 return awsAwsjson11_deserializeErrorInternalErrorException(response, errorBody) 2819 2820 case strings.EqualFold("InvalidInputException", errorCode): 2821 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 2822 2823 case strings.EqualFold("InvalidOperationException", errorCode): 2824 return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody) 2825 2826 case strings.EqualFold("LimitExceededException", errorCode): 2827 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 2828 2829 case strings.EqualFold("ResourceNotFoundException", errorCode): 2830 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 2831 2832 default: 2833 genericError := &smithy.GenericAPIError{ 2834 Code: errorCode, 2835 Message: errorMessage, 2836 } 2837 return genericError 2838 2839 } 2840} 2841 2842type awsAwsjson11_deserializeOpUntagResource struct { 2843} 2844 2845func (*awsAwsjson11_deserializeOpUntagResource) ID() string { 2846 return "OperationDeserializer" 2847} 2848 2849func (m *awsAwsjson11_deserializeOpUntagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2850 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2851) { 2852 out, metadata, err = next.HandleDeserialize(ctx, in) 2853 if err != nil { 2854 return out, metadata, err 2855 } 2856 2857 response, ok := out.RawResponse.(*smithyhttp.Response) 2858 if !ok { 2859 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2860 } 2861 2862 if response.StatusCode < 200 || response.StatusCode >= 300 { 2863 return out, metadata, awsAwsjson11_deserializeOpErrorUntagResource(response, &metadata) 2864 } 2865 output := &UntagResourceOutput{} 2866 out.Result = output 2867 2868 var buff [1024]byte 2869 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2870 2871 body := io.TeeReader(response.Body, ringBuffer) 2872 decoder := json.NewDecoder(body) 2873 decoder.UseNumber() 2874 var shape interface{} 2875 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2876 var snapshot bytes.Buffer 2877 io.Copy(&snapshot, ringBuffer) 2878 err = &smithy.DeserializationError{ 2879 Err: fmt.Errorf("failed to decode response body, %w", err), 2880 Snapshot: snapshot.Bytes(), 2881 } 2882 return out, metadata, err 2883 } 2884 2885 err = awsAwsjson11_deserializeOpDocumentUntagResourceOutput(&output, shape) 2886 if err != nil { 2887 var snapshot bytes.Buffer 2888 io.Copy(&snapshot, ringBuffer) 2889 err = &smithy.DeserializationError{ 2890 Err: fmt.Errorf("failed to decode response body, %w", err), 2891 Snapshot: snapshot.Bytes(), 2892 } 2893 return out, metadata, err 2894 } 2895 2896 return out, metadata, err 2897} 2898 2899func awsAwsjson11_deserializeOpErrorUntagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2900 var errorBuffer bytes.Buffer 2901 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2902 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2903 } 2904 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2905 2906 errorCode := "UnknownError" 2907 errorMessage := errorCode 2908 2909 code := response.Header.Get("X-Amzn-ErrorType") 2910 if len(code) != 0 { 2911 errorCode = restjson.SanitizeErrorCode(code) 2912 } 2913 2914 var buff [1024]byte 2915 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2916 2917 body := io.TeeReader(errorBody, ringBuffer) 2918 decoder := json.NewDecoder(body) 2919 decoder.UseNumber() 2920 code, message, err := restjson.GetErrorInfo(decoder) 2921 if err != nil { 2922 var snapshot bytes.Buffer 2923 io.Copy(&snapshot, ringBuffer) 2924 err = &smithy.DeserializationError{ 2925 Err: fmt.Errorf("failed to decode response body, %w", err), 2926 Snapshot: snapshot.Bytes(), 2927 } 2928 return err 2929 } 2930 2931 errorBody.Seek(0, io.SeekStart) 2932 if len(code) != 0 { 2933 errorCode = restjson.SanitizeErrorCode(code) 2934 } 2935 if len(message) != 0 { 2936 errorMessage = message 2937 } 2938 2939 switch { 2940 case strings.EqualFold("InternalErrorException", errorCode): 2941 return awsAwsjson11_deserializeErrorInternalErrorException(response, errorBody) 2942 2943 case strings.EqualFold("InvalidInputException", errorCode): 2944 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 2945 2946 case strings.EqualFold("InvalidOperationException", errorCode): 2947 return awsAwsjson11_deserializeErrorInvalidOperationException(response, errorBody) 2948 2949 case strings.EqualFold("ResourceNotFoundException", errorCode): 2950 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 2951 2952 default: 2953 genericError := &smithy.GenericAPIError{ 2954 Code: errorCode, 2955 Message: errorMessage, 2956 } 2957 return genericError 2958 2959 } 2960} 2961 2962func awsAwsjson11_deserializeErrorInternalErrorException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 2963 var buff [1024]byte 2964 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2965 2966 body := io.TeeReader(errorBody, ringBuffer) 2967 decoder := json.NewDecoder(body) 2968 decoder.UseNumber() 2969 var shape interface{} 2970 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2971 var snapshot bytes.Buffer 2972 io.Copy(&snapshot, ringBuffer) 2973 err = &smithy.DeserializationError{ 2974 Err: fmt.Errorf("failed to decode response body, %w", err), 2975 Snapshot: snapshot.Bytes(), 2976 } 2977 return err 2978 } 2979 2980 output := &types.InternalErrorException{} 2981 err := awsAwsjson11_deserializeDocumentInternalErrorException(&output, shape) 2982 2983 if err != nil { 2984 var snapshot bytes.Buffer 2985 io.Copy(&snapshot, ringBuffer) 2986 err = &smithy.DeserializationError{ 2987 Err: fmt.Errorf("failed to decode response body, %w", err), 2988 Snapshot: snapshot.Bytes(), 2989 } 2990 return err 2991 } 2992 2993 errorBody.Seek(0, io.SeekStart) 2994 return output 2995} 2996 2997func awsAwsjson11_deserializeErrorInvalidInputException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 2998 var buff [1024]byte 2999 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3000 3001 body := io.TeeReader(errorBody, ringBuffer) 3002 decoder := json.NewDecoder(body) 3003 decoder.UseNumber() 3004 var shape interface{} 3005 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3006 var snapshot bytes.Buffer 3007 io.Copy(&snapshot, ringBuffer) 3008 err = &smithy.DeserializationError{ 3009 Err: fmt.Errorf("failed to decode response body, %w", err), 3010 Snapshot: snapshot.Bytes(), 3011 } 3012 return err 3013 } 3014 3015 output := &types.InvalidInputException{} 3016 err := awsAwsjson11_deserializeDocumentInvalidInputException(&output, shape) 3017 3018 if err != nil { 3019 var snapshot bytes.Buffer 3020 io.Copy(&snapshot, ringBuffer) 3021 err = &smithy.DeserializationError{ 3022 Err: fmt.Errorf("failed to decode response body, %w", err), 3023 Snapshot: snapshot.Bytes(), 3024 } 3025 return err 3026 } 3027 3028 errorBody.Seek(0, io.SeekStart) 3029 return output 3030} 3031 3032func awsAwsjson11_deserializeErrorInvalidOperationException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 3033 var buff [1024]byte 3034 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3035 3036 body := io.TeeReader(errorBody, ringBuffer) 3037 decoder := json.NewDecoder(body) 3038 decoder.UseNumber() 3039 var shape interface{} 3040 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3041 var snapshot bytes.Buffer 3042 io.Copy(&snapshot, ringBuffer) 3043 err = &smithy.DeserializationError{ 3044 Err: fmt.Errorf("failed to decode response body, %w", err), 3045 Snapshot: snapshot.Bytes(), 3046 } 3047 return err 3048 } 3049 3050 output := &types.InvalidOperationException{} 3051 err := awsAwsjson11_deserializeDocumentInvalidOperationException(&output, shape) 3052 3053 if err != nil { 3054 var snapshot bytes.Buffer 3055 io.Copy(&snapshot, ringBuffer) 3056 err = &smithy.DeserializationError{ 3057 Err: fmt.Errorf("failed to decode response body, %w", err), 3058 Snapshot: snapshot.Bytes(), 3059 } 3060 return err 3061 } 3062 3063 errorBody.Seek(0, io.SeekStart) 3064 return output 3065} 3066 3067func awsAwsjson11_deserializeErrorInvalidTypeException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 3068 var buff [1024]byte 3069 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3070 3071 body := io.TeeReader(errorBody, ringBuffer) 3072 decoder := json.NewDecoder(body) 3073 decoder.UseNumber() 3074 var shape interface{} 3075 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3076 var snapshot bytes.Buffer 3077 io.Copy(&snapshot, ringBuffer) 3078 err = &smithy.DeserializationError{ 3079 Err: fmt.Errorf("failed to decode response body, %w", err), 3080 Snapshot: snapshot.Bytes(), 3081 } 3082 return err 3083 } 3084 3085 output := &types.InvalidTypeException{} 3086 err := awsAwsjson11_deserializeDocumentInvalidTypeException(&output, shape) 3087 3088 if err != nil { 3089 var snapshot bytes.Buffer 3090 io.Copy(&snapshot, ringBuffer) 3091 err = &smithy.DeserializationError{ 3092 Err: fmt.Errorf("failed to decode response body, %w", err), 3093 Snapshot: snapshot.Bytes(), 3094 } 3095 return err 3096 } 3097 3098 errorBody.Seek(0, io.SeekStart) 3099 return output 3100} 3101 3102func awsAwsjson11_deserializeErrorLimitExceededException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 3103 var buff [1024]byte 3104 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3105 3106 body := io.TeeReader(errorBody, ringBuffer) 3107 decoder := json.NewDecoder(body) 3108 decoder.UseNumber() 3109 var shape interface{} 3110 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3111 var snapshot bytes.Buffer 3112 io.Copy(&snapshot, ringBuffer) 3113 err = &smithy.DeserializationError{ 3114 Err: fmt.Errorf("failed to decode response body, %w", err), 3115 Snapshot: snapshot.Bytes(), 3116 } 3117 return err 3118 } 3119 3120 output := &types.LimitExceededException{} 3121 err := awsAwsjson11_deserializeDocumentLimitExceededException(&output, shape) 3122 3123 if err != nil { 3124 var snapshot bytes.Buffer 3125 io.Copy(&snapshot, ringBuffer) 3126 err = &smithy.DeserializationError{ 3127 Err: fmt.Errorf("failed to decode response body, %w", err), 3128 Snapshot: snapshot.Bytes(), 3129 } 3130 return err 3131 } 3132 3133 errorBody.Seek(0, io.SeekStart) 3134 return output 3135} 3136 3137func awsAwsjson11_deserializeErrorResourceNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 3138 var buff [1024]byte 3139 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3140 3141 body := io.TeeReader(errorBody, ringBuffer) 3142 decoder := json.NewDecoder(body) 3143 decoder.UseNumber() 3144 var shape interface{} 3145 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3146 var snapshot bytes.Buffer 3147 io.Copy(&snapshot, ringBuffer) 3148 err = &smithy.DeserializationError{ 3149 Err: fmt.Errorf("failed to decode response body, %w", err), 3150 Snapshot: snapshot.Bytes(), 3151 } 3152 return err 3153 } 3154 3155 output := &types.ResourceNotFoundException{} 3156 err := awsAwsjson11_deserializeDocumentResourceNotFoundException(&output, shape) 3157 3158 if err != nil { 3159 var snapshot bytes.Buffer 3160 io.Copy(&snapshot, ringBuffer) 3161 err = &smithy.DeserializationError{ 3162 Err: fmt.Errorf("failed to decode response body, %w", err), 3163 Snapshot: snapshot.Bytes(), 3164 } 3165 return err 3166 } 3167 3168 errorBody.Seek(0, io.SeekStart) 3169 return output 3170} 3171 3172func awsAwsjson11_deserializeDocumentActionTarget(v **types.ActionTarget, value interface{}) error { 3173 if v == nil { 3174 return fmt.Errorf("unexpected nil of type %T", v) 3175 } 3176 if value == nil { 3177 return nil 3178 } 3179 3180 shape, ok := value.(map[string]interface{}) 3181 if !ok { 3182 return fmt.Errorf("unexpected JSON type %v", value) 3183 } 3184 3185 var sv *types.ActionTarget 3186 if *v == nil { 3187 sv = &types.ActionTarget{} 3188 } else { 3189 sv = *v 3190 } 3191 3192 for key, value := range shape { 3193 switch key { 3194 case "Description": 3195 if value != nil { 3196 jtv, ok := value.(string) 3197 if !ok { 3198 return fmt.Errorf("expected LengthBoundedString to be of type string, got %T instead", value) 3199 } 3200 sv.Description = ptr.String(jtv) 3201 } 3202 3203 case "ResourceId": 3204 if value != nil { 3205 jtv, ok := value.(string) 3206 if !ok { 3207 return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value) 3208 } 3209 sv.ResourceId = ptr.String(jtv) 3210 } 3211 3212 default: 3213 _, _ = key, value 3214 3215 } 3216 } 3217 *v = sv 3218 return nil 3219} 3220 3221func awsAwsjson11_deserializeDocumentApp(v **types.App, value interface{}) error { 3222 if v == nil { 3223 return fmt.Errorf("unexpected nil of type %T", v) 3224 } 3225 if value == nil { 3226 return nil 3227 } 3228 3229 shape, ok := value.(map[string]interface{}) 3230 if !ok { 3231 return fmt.Errorf("unexpected JSON type %v", value) 3232 } 3233 3234 var sv *types.App 3235 if *v == nil { 3236 sv = &types.App{} 3237 } else { 3238 sv = *v 3239 } 3240 3241 for key, value := range shape { 3242 switch key { 3243 case "AppName": 3244 if value != nil { 3245 jtv, ok := value.(string) 3246 if !ok { 3247 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value) 3248 } 3249 sv.AppName = ptr.String(jtv) 3250 } 3251 3252 case "Port": 3253 if value != nil { 3254 jtv, ok := value.(json.Number) 3255 if !ok { 3256 return fmt.Errorf("expected IPPortNumber to be json.Number, got %T instead", value) 3257 } 3258 i64, err := jtv.Int64() 3259 if err != nil { 3260 return err 3261 } 3262 sv.Port = ptr.Int64(i64) 3263 } 3264 3265 case "Protocol": 3266 if value != nil { 3267 jtv, ok := value.(string) 3268 if !ok { 3269 return fmt.Errorf("expected Protocol to be of type string, got %T instead", value) 3270 } 3271 sv.Protocol = ptr.String(jtv) 3272 } 3273 3274 default: 3275 _, _ = key, value 3276 3277 } 3278 } 3279 *v = sv 3280 return nil 3281} 3282 3283func awsAwsjson11_deserializeDocumentAppsList(v *[]types.App, value interface{}) error { 3284 if v == nil { 3285 return fmt.Errorf("unexpected nil of type %T", v) 3286 } 3287 if value == nil { 3288 return nil 3289 } 3290 3291 shape, ok := value.([]interface{}) 3292 if !ok { 3293 return fmt.Errorf("unexpected JSON type %v", value) 3294 } 3295 3296 var cv []types.App 3297 if *v == nil { 3298 cv = []types.App{} 3299 } else { 3300 cv = *v 3301 } 3302 3303 for _, value := range shape { 3304 var col types.App 3305 destAddr := &col 3306 if err := awsAwsjson11_deserializeDocumentApp(&destAddr, value); err != nil { 3307 return err 3308 } 3309 col = *destAddr 3310 cv = append(cv, col) 3311 3312 } 3313 *v = cv 3314 return nil 3315} 3316 3317func awsAwsjson11_deserializeDocumentAppsListData(v **types.AppsListData, value interface{}) error { 3318 if v == nil { 3319 return fmt.Errorf("unexpected nil of type %T", v) 3320 } 3321 if value == nil { 3322 return nil 3323 } 3324 3325 shape, ok := value.(map[string]interface{}) 3326 if !ok { 3327 return fmt.Errorf("unexpected JSON type %v", value) 3328 } 3329 3330 var sv *types.AppsListData 3331 if *v == nil { 3332 sv = &types.AppsListData{} 3333 } else { 3334 sv = *v 3335 } 3336 3337 for key, value := range shape { 3338 switch key { 3339 case "AppsList": 3340 if err := awsAwsjson11_deserializeDocumentAppsList(&sv.AppsList, value); err != nil { 3341 return err 3342 } 3343 3344 case "CreateTime": 3345 if value != nil { 3346 switch jtv := value.(type) { 3347 case json.Number: 3348 f64, err := jtv.Float64() 3349 if err != nil { 3350 return err 3351 } 3352 sv.CreateTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 3353 3354 default: 3355 return fmt.Errorf("expected TimeStamp to be a JSON Number, got %T instead", value) 3356 3357 } 3358 } 3359 3360 case "LastUpdateTime": 3361 if value != nil { 3362 switch jtv := value.(type) { 3363 case json.Number: 3364 f64, err := jtv.Float64() 3365 if err != nil { 3366 return err 3367 } 3368 sv.LastUpdateTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 3369 3370 default: 3371 return fmt.Errorf("expected TimeStamp to be a JSON Number, got %T instead", value) 3372 3373 } 3374 } 3375 3376 case "ListId": 3377 if value != nil { 3378 jtv, ok := value.(string) 3379 if !ok { 3380 return fmt.Errorf("expected ListId to be of type string, got %T instead", value) 3381 } 3382 sv.ListId = ptr.String(jtv) 3383 } 3384 3385 case "ListName": 3386 if value != nil { 3387 jtv, ok := value.(string) 3388 if !ok { 3389 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value) 3390 } 3391 sv.ListName = ptr.String(jtv) 3392 } 3393 3394 case "ListUpdateToken": 3395 if value != nil { 3396 jtv, ok := value.(string) 3397 if !ok { 3398 return fmt.Errorf("expected UpdateToken to be of type string, got %T instead", value) 3399 } 3400 sv.ListUpdateToken = ptr.String(jtv) 3401 } 3402 3403 case "PreviousAppsList": 3404 if err := awsAwsjson11_deserializeDocumentPreviousAppsList(&sv.PreviousAppsList, value); err != nil { 3405 return err 3406 } 3407 3408 default: 3409 _, _ = key, value 3410 3411 } 3412 } 3413 *v = sv 3414 return nil 3415} 3416 3417func awsAwsjson11_deserializeDocumentAppsListDataSummary(v **types.AppsListDataSummary, value interface{}) error { 3418 if v == nil { 3419 return fmt.Errorf("unexpected nil of type %T", v) 3420 } 3421 if value == nil { 3422 return nil 3423 } 3424 3425 shape, ok := value.(map[string]interface{}) 3426 if !ok { 3427 return fmt.Errorf("unexpected JSON type %v", value) 3428 } 3429 3430 var sv *types.AppsListDataSummary 3431 if *v == nil { 3432 sv = &types.AppsListDataSummary{} 3433 } else { 3434 sv = *v 3435 } 3436 3437 for key, value := range shape { 3438 switch key { 3439 case "AppsList": 3440 if err := awsAwsjson11_deserializeDocumentAppsList(&sv.AppsList, value); err != nil { 3441 return err 3442 } 3443 3444 case "ListArn": 3445 if value != nil { 3446 jtv, ok := value.(string) 3447 if !ok { 3448 return fmt.Errorf("expected ResourceArn to be of type string, got %T instead", value) 3449 } 3450 sv.ListArn = ptr.String(jtv) 3451 } 3452 3453 case "ListId": 3454 if value != nil { 3455 jtv, ok := value.(string) 3456 if !ok { 3457 return fmt.Errorf("expected ListId to be of type string, got %T instead", value) 3458 } 3459 sv.ListId = ptr.String(jtv) 3460 } 3461 3462 case "ListName": 3463 if value != nil { 3464 jtv, ok := value.(string) 3465 if !ok { 3466 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value) 3467 } 3468 sv.ListName = ptr.String(jtv) 3469 } 3470 3471 default: 3472 _, _ = key, value 3473 3474 } 3475 } 3476 *v = sv 3477 return nil 3478} 3479 3480func awsAwsjson11_deserializeDocumentAppsListsData(v *[]types.AppsListDataSummary, value interface{}) error { 3481 if v == nil { 3482 return fmt.Errorf("unexpected nil of type %T", v) 3483 } 3484 if value == nil { 3485 return nil 3486 } 3487 3488 shape, ok := value.([]interface{}) 3489 if !ok { 3490 return fmt.Errorf("unexpected JSON type %v", value) 3491 } 3492 3493 var cv []types.AppsListDataSummary 3494 if *v == nil { 3495 cv = []types.AppsListDataSummary{} 3496 } else { 3497 cv = *v 3498 } 3499 3500 for _, value := range shape { 3501 var col types.AppsListDataSummary 3502 destAddr := &col 3503 if err := awsAwsjson11_deserializeDocumentAppsListDataSummary(&destAddr, value); err != nil { 3504 return err 3505 } 3506 col = *destAddr 3507 cv = append(cv, col) 3508 3509 } 3510 *v = cv 3511 return nil 3512} 3513 3514func awsAwsjson11_deserializeDocumentAwsEc2InstanceViolation(v **types.AwsEc2InstanceViolation, value interface{}) error { 3515 if v == nil { 3516 return fmt.Errorf("unexpected nil of type %T", v) 3517 } 3518 if value == nil { 3519 return nil 3520 } 3521 3522 shape, ok := value.(map[string]interface{}) 3523 if !ok { 3524 return fmt.Errorf("unexpected JSON type %v", value) 3525 } 3526 3527 var sv *types.AwsEc2InstanceViolation 3528 if *v == nil { 3529 sv = &types.AwsEc2InstanceViolation{} 3530 } else { 3531 sv = *v 3532 } 3533 3534 for key, value := range shape { 3535 switch key { 3536 case "AwsEc2NetworkInterfaceViolations": 3537 if err := awsAwsjson11_deserializeDocumentAwsEc2NetworkInterfaceViolations(&sv.AwsEc2NetworkInterfaceViolations, value); err != nil { 3538 return err 3539 } 3540 3541 case "ViolationTarget": 3542 if value != nil { 3543 jtv, ok := value.(string) 3544 if !ok { 3545 return fmt.Errorf("expected ViolationTarget to be of type string, got %T instead", value) 3546 } 3547 sv.ViolationTarget = ptr.String(jtv) 3548 } 3549 3550 default: 3551 _, _ = key, value 3552 3553 } 3554 } 3555 *v = sv 3556 return nil 3557} 3558 3559func awsAwsjson11_deserializeDocumentAwsEc2NetworkInterfaceViolation(v **types.AwsEc2NetworkInterfaceViolation, value interface{}) error { 3560 if v == nil { 3561 return fmt.Errorf("unexpected nil of type %T", v) 3562 } 3563 if value == nil { 3564 return nil 3565 } 3566 3567 shape, ok := value.(map[string]interface{}) 3568 if !ok { 3569 return fmt.Errorf("unexpected JSON type %v", value) 3570 } 3571 3572 var sv *types.AwsEc2NetworkInterfaceViolation 3573 if *v == nil { 3574 sv = &types.AwsEc2NetworkInterfaceViolation{} 3575 } else { 3576 sv = *v 3577 } 3578 3579 for key, value := range shape { 3580 switch key { 3581 case "ViolatingSecurityGroups": 3582 if err := awsAwsjson11_deserializeDocumentResourceIdList(&sv.ViolatingSecurityGroups, value); err != nil { 3583 return err 3584 } 3585 3586 case "ViolationTarget": 3587 if value != nil { 3588 jtv, ok := value.(string) 3589 if !ok { 3590 return fmt.Errorf("expected ViolationTarget to be of type string, got %T instead", value) 3591 } 3592 sv.ViolationTarget = ptr.String(jtv) 3593 } 3594 3595 default: 3596 _, _ = key, value 3597 3598 } 3599 } 3600 *v = sv 3601 return nil 3602} 3603 3604func awsAwsjson11_deserializeDocumentAwsEc2NetworkInterfaceViolations(v *[]types.AwsEc2NetworkInterfaceViolation, value interface{}) error { 3605 if v == nil { 3606 return fmt.Errorf("unexpected nil of type %T", v) 3607 } 3608 if value == nil { 3609 return nil 3610 } 3611 3612 shape, ok := value.([]interface{}) 3613 if !ok { 3614 return fmt.Errorf("unexpected JSON type %v", value) 3615 } 3616 3617 var cv []types.AwsEc2NetworkInterfaceViolation 3618 if *v == nil { 3619 cv = []types.AwsEc2NetworkInterfaceViolation{} 3620 } else { 3621 cv = *v 3622 } 3623 3624 for _, value := range shape { 3625 var col types.AwsEc2NetworkInterfaceViolation 3626 destAddr := &col 3627 if err := awsAwsjson11_deserializeDocumentAwsEc2NetworkInterfaceViolation(&destAddr, value); err != nil { 3628 return err 3629 } 3630 col = *destAddr 3631 cv = append(cv, col) 3632 3633 } 3634 *v = cv 3635 return nil 3636} 3637 3638func awsAwsjson11_deserializeDocumentAwsVPCSecurityGroupViolation(v **types.AwsVPCSecurityGroupViolation, value interface{}) error { 3639 if v == nil { 3640 return fmt.Errorf("unexpected nil of type %T", v) 3641 } 3642 if value == nil { 3643 return nil 3644 } 3645 3646 shape, ok := value.(map[string]interface{}) 3647 if !ok { 3648 return fmt.Errorf("unexpected JSON type %v", value) 3649 } 3650 3651 var sv *types.AwsVPCSecurityGroupViolation 3652 if *v == nil { 3653 sv = &types.AwsVPCSecurityGroupViolation{} 3654 } else { 3655 sv = *v 3656 } 3657 3658 for key, value := range shape { 3659 switch key { 3660 case "PartialMatches": 3661 if err := awsAwsjson11_deserializeDocumentPartialMatches(&sv.PartialMatches, value); err != nil { 3662 return err 3663 } 3664 3665 case "PossibleSecurityGroupRemediationActions": 3666 if err := awsAwsjson11_deserializeDocumentSecurityGroupRemediationActions(&sv.PossibleSecurityGroupRemediationActions, value); err != nil { 3667 return err 3668 } 3669 3670 case "ViolationTarget": 3671 if value != nil { 3672 jtv, ok := value.(string) 3673 if !ok { 3674 return fmt.Errorf("expected ViolationTarget to be of type string, got %T instead", value) 3675 } 3676 sv.ViolationTarget = ptr.String(jtv) 3677 } 3678 3679 case "ViolationTargetDescription": 3680 if value != nil { 3681 jtv, ok := value.(string) 3682 if !ok { 3683 return fmt.Errorf("expected LengthBoundedString to be of type string, got %T instead", value) 3684 } 3685 sv.ViolationTargetDescription = ptr.String(jtv) 3686 } 3687 3688 default: 3689 _, _ = key, value 3690 3691 } 3692 } 3693 *v = sv 3694 return nil 3695} 3696 3697func awsAwsjson11_deserializeDocumentComplianceViolator(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.(map[string]interface{}) 3706 if !ok { 3707 return fmt.Errorf("unexpected JSON type %v", value) 3708 } 3709 3710 var sv *types.ComplianceViolator 3711 if *v == nil { 3712 sv = &types.ComplianceViolator{} 3713 } else { 3714 sv = *v 3715 } 3716 3717 for key, value := range shape { 3718 switch key { 3719 case "ResourceId": 3720 if value != nil { 3721 jtv, ok := value.(string) 3722 if !ok { 3723 return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value) 3724 } 3725 sv.ResourceId = ptr.String(jtv) 3726 } 3727 3728 case "ResourceType": 3729 if value != nil { 3730 jtv, ok := value.(string) 3731 if !ok { 3732 return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value) 3733 } 3734 sv.ResourceType = ptr.String(jtv) 3735 } 3736 3737 case "ViolationReason": 3738 if value != nil { 3739 jtv, ok := value.(string) 3740 if !ok { 3741 return fmt.Errorf("expected ViolationReason to be of type string, got %T instead", value) 3742 } 3743 sv.ViolationReason = types.ViolationReason(jtv) 3744 } 3745 3746 default: 3747 _, _ = key, value 3748 3749 } 3750 } 3751 *v = sv 3752 return nil 3753} 3754 3755func awsAwsjson11_deserializeDocumentComplianceViolators(v *[]types.ComplianceViolator, value interface{}) error { 3756 if v == nil { 3757 return fmt.Errorf("unexpected nil of type %T", v) 3758 } 3759 if value == nil { 3760 return nil 3761 } 3762 3763 shape, ok := value.([]interface{}) 3764 if !ok { 3765 return fmt.Errorf("unexpected JSON type %v", value) 3766 } 3767 3768 var cv []types.ComplianceViolator 3769 if *v == nil { 3770 cv = []types.ComplianceViolator{} 3771 } else { 3772 cv = *v 3773 } 3774 3775 for _, value := range shape { 3776 var col types.ComplianceViolator 3777 destAddr := &col 3778 if err := awsAwsjson11_deserializeDocumentComplianceViolator(&destAddr, value); err != nil { 3779 return err 3780 } 3781 col = *destAddr 3782 cv = append(cv, col) 3783 3784 } 3785 *v = cv 3786 return nil 3787} 3788 3789func awsAwsjson11_deserializeDocumentCustomerPolicyScopeIdList(v *[]string, value interface{}) error { 3790 if v == nil { 3791 return fmt.Errorf("unexpected nil of type %T", v) 3792 } 3793 if value == nil { 3794 return nil 3795 } 3796 3797 shape, ok := value.([]interface{}) 3798 if !ok { 3799 return fmt.Errorf("unexpected JSON type %v", value) 3800 } 3801 3802 var cv []string 3803 if *v == nil { 3804 cv = []string{} 3805 } else { 3806 cv = *v 3807 } 3808 3809 for _, value := range shape { 3810 var col string 3811 if value != nil { 3812 jtv, ok := value.(string) 3813 if !ok { 3814 return fmt.Errorf("expected CustomerPolicyScopeId to be of type string, got %T instead", value) 3815 } 3816 col = jtv 3817 } 3818 cv = append(cv, col) 3819 3820 } 3821 *v = cv 3822 return nil 3823} 3824 3825func awsAwsjson11_deserializeDocumentCustomerPolicyScopeMap(v *map[string][]string, value interface{}) error { 3826 if v == nil { 3827 return fmt.Errorf("unexpected nil of type %T", v) 3828 } 3829 if value == nil { 3830 return nil 3831 } 3832 3833 shape, ok := value.(map[string]interface{}) 3834 if !ok { 3835 return fmt.Errorf("unexpected JSON type %v", value) 3836 } 3837 3838 var mv map[string][]string 3839 if *v == nil { 3840 mv = map[string][]string{} 3841 } else { 3842 mv = *v 3843 } 3844 3845 for key, value := range shape { 3846 var parsedVal []string 3847 mapVar := parsedVal 3848 if err := awsAwsjson11_deserializeDocumentCustomerPolicyScopeIdList(&mapVar, value); err != nil { 3849 return err 3850 } 3851 parsedVal = mapVar 3852 mv[key] = parsedVal 3853 3854 } 3855 *v = mv 3856 return nil 3857} 3858 3859func awsAwsjson11_deserializeDocumentDnsDuplicateRuleGroupViolation(v **types.DnsDuplicateRuleGroupViolation, value interface{}) error { 3860 if v == nil { 3861 return fmt.Errorf("unexpected nil of type %T", v) 3862 } 3863 if value == nil { 3864 return nil 3865 } 3866 3867 shape, ok := value.(map[string]interface{}) 3868 if !ok { 3869 return fmt.Errorf("unexpected JSON type %v", value) 3870 } 3871 3872 var sv *types.DnsDuplicateRuleGroupViolation 3873 if *v == nil { 3874 sv = &types.DnsDuplicateRuleGroupViolation{} 3875 } else { 3876 sv = *v 3877 } 3878 3879 for key, value := range shape { 3880 switch key { 3881 case "ViolationTarget": 3882 if value != nil { 3883 jtv, ok := value.(string) 3884 if !ok { 3885 return fmt.Errorf("expected ViolationTarget to be of type string, got %T instead", value) 3886 } 3887 sv.ViolationTarget = ptr.String(jtv) 3888 } 3889 3890 case "ViolationTargetDescription": 3891 if value != nil { 3892 jtv, ok := value.(string) 3893 if !ok { 3894 return fmt.Errorf("expected LengthBoundedString to be of type string, got %T instead", value) 3895 } 3896 sv.ViolationTargetDescription = ptr.String(jtv) 3897 } 3898 3899 default: 3900 _, _ = key, value 3901 3902 } 3903 } 3904 *v = sv 3905 return nil 3906} 3907 3908func awsAwsjson11_deserializeDocumentDnsRuleGroupLimitExceededViolation(v **types.DnsRuleGroupLimitExceededViolation, value interface{}) error { 3909 if v == nil { 3910 return fmt.Errorf("unexpected nil of type %T", v) 3911 } 3912 if value == nil { 3913 return nil 3914 } 3915 3916 shape, ok := value.(map[string]interface{}) 3917 if !ok { 3918 return fmt.Errorf("unexpected JSON type %v", value) 3919 } 3920 3921 var sv *types.DnsRuleGroupLimitExceededViolation 3922 if *v == nil { 3923 sv = &types.DnsRuleGroupLimitExceededViolation{} 3924 } else { 3925 sv = *v 3926 } 3927 3928 for key, value := range shape { 3929 switch key { 3930 case "NumberOfRuleGroupsAlreadyAssociated": 3931 if value != nil { 3932 jtv, ok := value.(json.Number) 3933 if !ok { 3934 return fmt.Errorf("expected BasicInteger to be json.Number, got %T instead", value) 3935 } 3936 i64, err := jtv.Int64() 3937 if err != nil { 3938 return err 3939 } 3940 sv.NumberOfRuleGroupsAlreadyAssociated = int32(i64) 3941 } 3942 3943 case "ViolationTarget": 3944 if value != nil { 3945 jtv, ok := value.(string) 3946 if !ok { 3947 return fmt.Errorf("expected ViolationTarget to be of type string, got %T instead", value) 3948 } 3949 sv.ViolationTarget = ptr.String(jtv) 3950 } 3951 3952 case "ViolationTargetDescription": 3953 if value != nil { 3954 jtv, ok := value.(string) 3955 if !ok { 3956 return fmt.Errorf("expected LengthBoundedString to be of type string, got %T instead", value) 3957 } 3958 sv.ViolationTargetDescription = ptr.String(jtv) 3959 } 3960 3961 default: 3962 _, _ = key, value 3963 3964 } 3965 } 3966 *v = sv 3967 return nil 3968} 3969 3970func awsAwsjson11_deserializeDocumentDnsRuleGroupPriorities(v *[]int32, value interface{}) error { 3971 if v == nil { 3972 return fmt.Errorf("unexpected nil of type %T", v) 3973 } 3974 if value == nil { 3975 return nil 3976 } 3977 3978 shape, ok := value.([]interface{}) 3979 if !ok { 3980 return fmt.Errorf("unexpected JSON type %v", value) 3981 } 3982 3983 var cv []int32 3984 if *v == nil { 3985 cv = []int32{} 3986 } else { 3987 cv = *v 3988 } 3989 3990 for _, value := range shape { 3991 var col int32 3992 if value != nil { 3993 jtv, ok := value.(json.Number) 3994 if !ok { 3995 return fmt.Errorf("expected DnsRuleGroupPriority to be json.Number, got %T instead", value) 3996 } 3997 i64, err := jtv.Int64() 3998 if err != nil { 3999 return err 4000 } 4001 col = int32(i64) 4002 } 4003 cv = append(cv, col) 4004 4005 } 4006 *v = cv 4007 return nil 4008} 4009 4010func awsAwsjson11_deserializeDocumentDnsRuleGroupPriorityConflictViolation(v **types.DnsRuleGroupPriorityConflictViolation, value interface{}) error { 4011 if v == nil { 4012 return fmt.Errorf("unexpected nil of type %T", v) 4013 } 4014 if value == nil { 4015 return nil 4016 } 4017 4018 shape, ok := value.(map[string]interface{}) 4019 if !ok { 4020 return fmt.Errorf("unexpected JSON type %v", value) 4021 } 4022 4023 var sv *types.DnsRuleGroupPriorityConflictViolation 4024 if *v == nil { 4025 sv = &types.DnsRuleGroupPriorityConflictViolation{} 4026 } else { 4027 sv = *v 4028 } 4029 4030 for key, value := range shape { 4031 switch key { 4032 case "ConflictingPolicyId": 4033 if value != nil { 4034 jtv, ok := value.(string) 4035 if !ok { 4036 return fmt.Errorf("expected PolicyId to be of type string, got %T instead", value) 4037 } 4038 sv.ConflictingPolicyId = ptr.String(jtv) 4039 } 4040 4041 case "ConflictingPriority": 4042 if value != nil { 4043 jtv, ok := value.(json.Number) 4044 if !ok { 4045 return fmt.Errorf("expected DnsRuleGroupPriority to be json.Number, got %T instead", value) 4046 } 4047 i64, err := jtv.Int64() 4048 if err != nil { 4049 return err 4050 } 4051 sv.ConflictingPriority = int32(i64) 4052 } 4053 4054 case "UnavailablePriorities": 4055 if err := awsAwsjson11_deserializeDocumentDnsRuleGroupPriorities(&sv.UnavailablePriorities, value); err != nil { 4056 return err 4057 } 4058 4059 case "ViolationTarget": 4060 if value != nil { 4061 jtv, ok := value.(string) 4062 if !ok { 4063 return fmt.Errorf("expected ViolationTarget to be of type string, got %T instead", value) 4064 } 4065 sv.ViolationTarget = ptr.String(jtv) 4066 } 4067 4068 case "ViolationTargetDescription": 4069 if value != nil { 4070 jtv, ok := value.(string) 4071 if !ok { 4072 return fmt.Errorf("expected LengthBoundedString to be of type string, got %T instead", value) 4073 } 4074 sv.ViolationTargetDescription = ptr.String(jtv) 4075 } 4076 4077 default: 4078 _, _ = key, value 4079 4080 } 4081 } 4082 *v = sv 4083 return nil 4084} 4085 4086func awsAwsjson11_deserializeDocumentEC2AssociateRouteTableAction(v **types.EC2AssociateRouteTableAction, value interface{}) error { 4087 if v == nil { 4088 return fmt.Errorf("unexpected nil of type %T", v) 4089 } 4090 if value == nil { 4091 return nil 4092 } 4093 4094 shape, ok := value.(map[string]interface{}) 4095 if !ok { 4096 return fmt.Errorf("unexpected JSON type %v", value) 4097 } 4098 4099 var sv *types.EC2AssociateRouteTableAction 4100 if *v == nil { 4101 sv = &types.EC2AssociateRouteTableAction{} 4102 } else { 4103 sv = *v 4104 } 4105 4106 for key, value := range shape { 4107 switch key { 4108 case "Description": 4109 if value != nil { 4110 jtv, ok := value.(string) 4111 if !ok { 4112 return fmt.Errorf("expected LengthBoundedString to be of type string, got %T instead", value) 4113 } 4114 sv.Description = ptr.String(jtv) 4115 } 4116 4117 case "GatewayId": 4118 if err := awsAwsjson11_deserializeDocumentActionTarget(&sv.GatewayId, value); err != nil { 4119 return err 4120 } 4121 4122 case "RouteTableId": 4123 if err := awsAwsjson11_deserializeDocumentActionTarget(&sv.RouteTableId, value); err != nil { 4124 return err 4125 } 4126 4127 case "SubnetId": 4128 if err := awsAwsjson11_deserializeDocumentActionTarget(&sv.SubnetId, value); err != nil { 4129 return err 4130 } 4131 4132 default: 4133 _, _ = key, value 4134 4135 } 4136 } 4137 *v = sv 4138 return nil 4139} 4140 4141func awsAwsjson11_deserializeDocumentEC2CopyRouteTableAction(v **types.EC2CopyRouteTableAction, value interface{}) error { 4142 if v == nil { 4143 return fmt.Errorf("unexpected nil of type %T", v) 4144 } 4145 if value == nil { 4146 return nil 4147 } 4148 4149 shape, ok := value.(map[string]interface{}) 4150 if !ok { 4151 return fmt.Errorf("unexpected JSON type %v", value) 4152 } 4153 4154 var sv *types.EC2CopyRouteTableAction 4155 if *v == nil { 4156 sv = &types.EC2CopyRouteTableAction{} 4157 } else { 4158 sv = *v 4159 } 4160 4161 for key, value := range shape { 4162 switch key { 4163 case "Description": 4164 if value != nil { 4165 jtv, ok := value.(string) 4166 if !ok { 4167 return fmt.Errorf("expected LengthBoundedString to be of type string, got %T instead", value) 4168 } 4169 sv.Description = ptr.String(jtv) 4170 } 4171 4172 case "RouteTableId": 4173 if err := awsAwsjson11_deserializeDocumentActionTarget(&sv.RouteTableId, value); err != nil { 4174 return err 4175 } 4176 4177 case "VpcId": 4178 if err := awsAwsjson11_deserializeDocumentActionTarget(&sv.VpcId, value); err != nil { 4179 return err 4180 } 4181 4182 default: 4183 _, _ = key, value 4184 4185 } 4186 } 4187 *v = sv 4188 return nil 4189} 4190 4191func awsAwsjson11_deserializeDocumentEC2CreateRouteAction(v **types.EC2CreateRouteAction, value interface{}) error { 4192 if v == nil { 4193 return fmt.Errorf("unexpected nil of type %T", v) 4194 } 4195 if value == nil { 4196 return nil 4197 } 4198 4199 shape, ok := value.(map[string]interface{}) 4200 if !ok { 4201 return fmt.Errorf("unexpected JSON type %v", value) 4202 } 4203 4204 var sv *types.EC2CreateRouteAction 4205 if *v == nil { 4206 sv = &types.EC2CreateRouteAction{} 4207 } else { 4208 sv = *v 4209 } 4210 4211 for key, value := range shape { 4212 switch key { 4213 case "Description": 4214 if value != nil { 4215 jtv, ok := value.(string) 4216 if !ok { 4217 return fmt.Errorf("expected LengthBoundedString to be of type string, got %T instead", value) 4218 } 4219 sv.Description = ptr.String(jtv) 4220 } 4221 4222 case "DestinationCidrBlock": 4223 if value != nil { 4224 jtv, ok := value.(string) 4225 if !ok { 4226 return fmt.Errorf("expected CIDR to be of type string, got %T instead", value) 4227 } 4228 sv.DestinationCidrBlock = ptr.String(jtv) 4229 } 4230 4231 case "DestinationIpv6CidrBlock": 4232 if value != nil { 4233 jtv, ok := value.(string) 4234 if !ok { 4235 return fmt.Errorf("expected CIDR to be of type string, got %T instead", value) 4236 } 4237 sv.DestinationIpv6CidrBlock = ptr.String(jtv) 4238 } 4239 4240 case "DestinationPrefixListId": 4241 if value != nil { 4242 jtv, ok := value.(string) 4243 if !ok { 4244 return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value) 4245 } 4246 sv.DestinationPrefixListId = ptr.String(jtv) 4247 } 4248 4249 case "GatewayId": 4250 if err := awsAwsjson11_deserializeDocumentActionTarget(&sv.GatewayId, value); err != nil { 4251 return err 4252 } 4253 4254 case "RouteTableId": 4255 if err := awsAwsjson11_deserializeDocumentActionTarget(&sv.RouteTableId, value); err != nil { 4256 return err 4257 } 4258 4259 case "VpcEndpointId": 4260 if err := awsAwsjson11_deserializeDocumentActionTarget(&sv.VpcEndpointId, value); err != nil { 4261 return err 4262 } 4263 4264 default: 4265 _, _ = key, value 4266 4267 } 4268 } 4269 *v = sv 4270 return nil 4271} 4272 4273func awsAwsjson11_deserializeDocumentEC2CreateRouteTableAction(v **types.EC2CreateRouteTableAction, value interface{}) error { 4274 if v == nil { 4275 return fmt.Errorf("unexpected nil of type %T", v) 4276 } 4277 if value == nil { 4278 return nil 4279 } 4280 4281 shape, ok := value.(map[string]interface{}) 4282 if !ok { 4283 return fmt.Errorf("unexpected JSON type %v", value) 4284 } 4285 4286 var sv *types.EC2CreateRouteTableAction 4287 if *v == nil { 4288 sv = &types.EC2CreateRouteTableAction{} 4289 } else { 4290 sv = *v 4291 } 4292 4293 for key, value := range shape { 4294 switch key { 4295 case "Description": 4296 if value != nil { 4297 jtv, ok := value.(string) 4298 if !ok { 4299 return fmt.Errorf("expected LengthBoundedString to be of type string, got %T instead", value) 4300 } 4301 sv.Description = ptr.String(jtv) 4302 } 4303 4304 case "VpcId": 4305 if err := awsAwsjson11_deserializeDocumentActionTarget(&sv.VpcId, value); err != nil { 4306 return err 4307 } 4308 4309 default: 4310 _, _ = key, value 4311 4312 } 4313 } 4314 *v = sv 4315 return nil 4316} 4317 4318func awsAwsjson11_deserializeDocumentEC2DeleteRouteAction(v **types.EC2DeleteRouteAction, value interface{}) error { 4319 if v == nil { 4320 return fmt.Errorf("unexpected nil of type %T", v) 4321 } 4322 if value == nil { 4323 return nil 4324 } 4325 4326 shape, ok := value.(map[string]interface{}) 4327 if !ok { 4328 return fmt.Errorf("unexpected JSON type %v", value) 4329 } 4330 4331 var sv *types.EC2DeleteRouteAction 4332 if *v == nil { 4333 sv = &types.EC2DeleteRouteAction{} 4334 } else { 4335 sv = *v 4336 } 4337 4338 for key, value := range shape { 4339 switch key { 4340 case "Description": 4341 if value != nil { 4342 jtv, ok := value.(string) 4343 if !ok { 4344 return fmt.Errorf("expected LengthBoundedString to be of type string, got %T instead", value) 4345 } 4346 sv.Description = ptr.String(jtv) 4347 } 4348 4349 case "DestinationCidrBlock": 4350 if value != nil { 4351 jtv, ok := value.(string) 4352 if !ok { 4353 return fmt.Errorf("expected CIDR to be of type string, got %T instead", value) 4354 } 4355 sv.DestinationCidrBlock = ptr.String(jtv) 4356 } 4357 4358 case "DestinationIpv6CidrBlock": 4359 if value != nil { 4360 jtv, ok := value.(string) 4361 if !ok { 4362 return fmt.Errorf("expected CIDR to be of type string, got %T instead", value) 4363 } 4364 sv.DestinationIpv6CidrBlock = ptr.String(jtv) 4365 } 4366 4367 case "DestinationPrefixListId": 4368 if value != nil { 4369 jtv, ok := value.(string) 4370 if !ok { 4371 return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value) 4372 } 4373 sv.DestinationPrefixListId = ptr.String(jtv) 4374 } 4375 4376 case "RouteTableId": 4377 if err := awsAwsjson11_deserializeDocumentActionTarget(&sv.RouteTableId, value); err != nil { 4378 return err 4379 } 4380 4381 default: 4382 _, _ = key, value 4383 4384 } 4385 } 4386 *v = sv 4387 return nil 4388} 4389 4390func awsAwsjson11_deserializeDocumentEC2ReplaceRouteAction(v **types.EC2ReplaceRouteAction, value interface{}) error { 4391 if v == nil { 4392 return fmt.Errorf("unexpected nil of type %T", v) 4393 } 4394 if value == nil { 4395 return nil 4396 } 4397 4398 shape, ok := value.(map[string]interface{}) 4399 if !ok { 4400 return fmt.Errorf("unexpected JSON type %v", value) 4401 } 4402 4403 var sv *types.EC2ReplaceRouteAction 4404 if *v == nil { 4405 sv = &types.EC2ReplaceRouteAction{} 4406 } else { 4407 sv = *v 4408 } 4409 4410 for key, value := range shape { 4411 switch key { 4412 case "Description": 4413 if value != nil { 4414 jtv, ok := value.(string) 4415 if !ok { 4416 return fmt.Errorf("expected LengthBoundedString to be of type string, got %T instead", value) 4417 } 4418 sv.Description = ptr.String(jtv) 4419 } 4420 4421 case "DestinationCidrBlock": 4422 if value != nil { 4423 jtv, ok := value.(string) 4424 if !ok { 4425 return fmt.Errorf("expected CIDR to be of type string, got %T instead", value) 4426 } 4427 sv.DestinationCidrBlock = ptr.String(jtv) 4428 } 4429 4430 case "DestinationIpv6CidrBlock": 4431 if value != nil { 4432 jtv, ok := value.(string) 4433 if !ok { 4434 return fmt.Errorf("expected CIDR to be of type string, got %T instead", value) 4435 } 4436 sv.DestinationIpv6CidrBlock = ptr.String(jtv) 4437 } 4438 4439 case "DestinationPrefixListId": 4440 if value != nil { 4441 jtv, ok := value.(string) 4442 if !ok { 4443 return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value) 4444 } 4445 sv.DestinationPrefixListId = ptr.String(jtv) 4446 } 4447 4448 case "GatewayId": 4449 if err := awsAwsjson11_deserializeDocumentActionTarget(&sv.GatewayId, value); err != nil { 4450 return err 4451 } 4452 4453 case "RouteTableId": 4454 if err := awsAwsjson11_deserializeDocumentActionTarget(&sv.RouteTableId, value); err != nil { 4455 return err 4456 } 4457 4458 default: 4459 _, _ = key, value 4460 4461 } 4462 } 4463 *v = sv 4464 return nil 4465} 4466 4467func awsAwsjson11_deserializeDocumentEC2ReplaceRouteTableAssociationAction(v **types.EC2ReplaceRouteTableAssociationAction, value interface{}) error { 4468 if v == nil { 4469 return fmt.Errorf("unexpected nil of type %T", v) 4470 } 4471 if value == nil { 4472 return nil 4473 } 4474 4475 shape, ok := value.(map[string]interface{}) 4476 if !ok { 4477 return fmt.Errorf("unexpected JSON type %v", value) 4478 } 4479 4480 var sv *types.EC2ReplaceRouteTableAssociationAction 4481 if *v == nil { 4482 sv = &types.EC2ReplaceRouteTableAssociationAction{} 4483 } else { 4484 sv = *v 4485 } 4486 4487 for key, value := range shape { 4488 switch key { 4489 case "AssociationId": 4490 if err := awsAwsjson11_deserializeDocumentActionTarget(&sv.AssociationId, value); err != nil { 4491 return err 4492 } 4493 4494 case "Description": 4495 if value != nil { 4496 jtv, ok := value.(string) 4497 if !ok { 4498 return fmt.Errorf("expected LengthBoundedString to be of type string, got %T instead", value) 4499 } 4500 sv.Description = ptr.String(jtv) 4501 } 4502 4503 case "RouteTableId": 4504 if err := awsAwsjson11_deserializeDocumentActionTarget(&sv.RouteTableId, value); err != nil { 4505 return err 4506 } 4507 4508 default: 4509 _, _ = key, value 4510 4511 } 4512 } 4513 *v = sv 4514 return nil 4515} 4516 4517func awsAwsjson11_deserializeDocumentEvaluationResult(v **types.EvaluationResult, value interface{}) error { 4518 if v == nil { 4519 return fmt.Errorf("unexpected nil of type %T", v) 4520 } 4521 if value == nil { 4522 return nil 4523 } 4524 4525 shape, ok := value.(map[string]interface{}) 4526 if !ok { 4527 return fmt.Errorf("unexpected JSON type %v", value) 4528 } 4529 4530 var sv *types.EvaluationResult 4531 if *v == nil { 4532 sv = &types.EvaluationResult{} 4533 } else { 4534 sv = *v 4535 } 4536 4537 for key, value := range shape { 4538 switch key { 4539 case "ComplianceStatus": 4540 if value != nil { 4541 jtv, ok := value.(string) 4542 if !ok { 4543 return fmt.Errorf("expected PolicyComplianceStatusType to be of type string, got %T instead", value) 4544 } 4545 sv.ComplianceStatus = types.PolicyComplianceStatusType(jtv) 4546 } 4547 4548 case "EvaluationLimitExceeded": 4549 if value != nil { 4550 jtv, ok := value.(bool) 4551 if !ok { 4552 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 4553 } 4554 sv.EvaluationLimitExceeded = jtv 4555 } 4556 4557 case "ViolatorCount": 4558 if value != nil { 4559 jtv, ok := value.(json.Number) 4560 if !ok { 4561 return fmt.Errorf("expected ResourceCount to be json.Number, got %T instead", value) 4562 } 4563 i64, err := jtv.Int64() 4564 if err != nil { 4565 return err 4566 } 4567 sv.ViolatorCount = i64 4568 } 4569 4570 default: 4571 _, _ = key, value 4572 4573 } 4574 } 4575 *v = sv 4576 return nil 4577} 4578 4579func awsAwsjson11_deserializeDocumentEvaluationResults(v *[]types.EvaluationResult, value interface{}) error { 4580 if v == nil { 4581 return fmt.Errorf("unexpected nil of type %T", v) 4582 } 4583 if value == nil { 4584 return nil 4585 } 4586 4587 shape, ok := value.([]interface{}) 4588 if !ok { 4589 return fmt.Errorf("unexpected JSON type %v", value) 4590 } 4591 4592 var cv []types.EvaluationResult 4593 if *v == nil { 4594 cv = []types.EvaluationResult{} 4595 } else { 4596 cv = *v 4597 } 4598 4599 for _, value := range shape { 4600 var col types.EvaluationResult 4601 destAddr := &col 4602 if err := awsAwsjson11_deserializeDocumentEvaluationResult(&destAddr, value); err != nil { 4603 return err 4604 } 4605 col = *destAddr 4606 cv = append(cv, col) 4607 4608 } 4609 *v = cv 4610 return nil 4611} 4612 4613func awsAwsjson11_deserializeDocumentExpectedRoute(v **types.ExpectedRoute, value interface{}) error { 4614 if v == nil { 4615 return fmt.Errorf("unexpected nil of type %T", v) 4616 } 4617 if value == nil { 4618 return nil 4619 } 4620 4621 shape, ok := value.(map[string]interface{}) 4622 if !ok { 4623 return fmt.Errorf("unexpected JSON type %v", value) 4624 } 4625 4626 var sv *types.ExpectedRoute 4627 if *v == nil { 4628 sv = &types.ExpectedRoute{} 4629 } else { 4630 sv = *v 4631 } 4632 4633 for key, value := range shape { 4634 switch key { 4635 case "AllowedTargets": 4636 if err := awsAwsjson11_deserializeDocumentLengthBoundedStringList(&sv.AllowedTargets, value); err != nil { 4637 return err 4638 } 4639 4640 case "ContributingSubnets": 4641 if err := awsAwsjson11_deserializeDocumentResourceIdList(&sv.ContributingSubnets, value); err != nil { 4642 return err 4643 } 4644 4645 case "IpV4Cidr": 4646 if value != nil { 4647 jtv, ok := value.(string) 4648 if !ok { 4649 return fmt.Errorf("expected CIDR to be of type string, got %T instead", value) 4650 } 4651 sv.IpV4Cidr = ptr.String(jtv) 4652 } 4653 4654 case "IpV6Cidr": 4655 if value != nil { 4656 jtv, ok := value.(string) 4657 if !ok { 4658 return fmt.Errorf("expected CIDR to be of type string, got %T instead", value) 4659 } 4660 sv.IpV6Cidr = ptr.String(jtv) 4661 } 4662 4663 case "PrefixListId": 4664 if value != nil { 4665 jtv, ok := value.(string) 4666 if !ok { 4667 return fmt.Errorf("expected CIDR to be of type string, got %T instead", value) 4668 } 4669 sv.PrefixListId = ptr.String(jtv) 4670 } 4671 4672 case "RouteTableId": 4673 if value != nil { 4674 jtv, ok := value.(string) 4675 if !ok { 4676 return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value) 4677 } 4678 sv.RouteTableId = ptr.String(jtv) 4679 } 4680 4681 default: 4682 _, _ = key, value 4683 4684 } 4685 } 4686 *v = sv 4687 return nil 4688} 4689 4690func awsAwsjson11_deserializeDocumentExpectedRoutes(v *[]types.ExpectedRoute, value interface{}) error { 4691 if v == nil { 4692 return fmt.Errorf("unexpected nil of type %T", v) 4693 } 4694 if value == nil { 4695 return nil 4696 } 4697 4698 shape, ok := value.([]interface{}) 4699 if !ok { 4700 return fmt.Errorf("unexpected JSON type %v", value) 4701 } 4702 4703 var cv []types.ExpectedRoute 4704 if *v == nil { 4705 cv = []types.ExpectedRoute{} 4706 } else { 4707 cv = *v 4708 } 4709 4710 for _, value := range shape { 4711 var col types.ExpectedRoute 4712 destAddr := &col 4713 if err := awsAwsjson11_deserializeDocumentExpectedRoute(&destAddr, value); err != nil { 4714 return err 4715 } 4716 col = *destAddr 4717 cv = append(cv, col) 4718 4719 } 4720 *v = cv 4721 return nil 4722} 4723 4724func awsAwsjson11_deserializeDocumentInternalErrorException(v **types.InternalErrorException, value interface{}) error { 4725 if v == nil { 4726 return fmt.Errorf("unexpected nil of type %T", v) 4727 } 4728 if value == nil { 4729 return nil 4730 } 4731 4732 shape, ok := value.(map[string]interface{}) 4733 if !ok { 4734 return fmt.Errorf("unexpected JSON type %v", value) 4735 } 4736 4737 var sv *types.InternalErrorException 4738 if *v == nil { 4739 sv = &types.InternalErrorException{} 4740 } else { 4741 sv = *v 4742 } 4743 4744 for key, value := range shape { 4745 switch key { 4746 case "Message": 4747 if value != nil { 4748 jtv, ok := value.(string) 4749 if !ok { 4750 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 4751 } 4752 sv.Message = ptr.String(jtv) 4753 } 4754 4755 default: 4756 _, _ = key, value 4757 4758 } 4759 } 4760 *v = sv 4761 return nil 4762} 4763 4764func awsAwsjson11_deserializeDocumentInvalidInputException(v **types.InvalidInputException, value interface{}) error { 4765 if v == nil { 4766 return fmt.Errorf("unexpected nil of type %T", v) 4767 } 4768 if value == nil { 4769 return nil 4770 } 4771 4772 shape, ok := value.(map[string]interface{}) 4773 if !ok { 4774 return fmt.Errorf("unexpected JSON type %v", value) 4775 } 4776 4777 var sv *types.InvalidInputException 4778 if *v == nil { 4779 sv = &types.InvalidInputException{} 4780 } else { 4781 sv = *v 4782 } 4783 4784 for key, value := range shape { 4785 switch key { 4786 case "Message": 4787 if value != nil { 4788 jtv, ok := value.(string) 4789 if !ok { 4790 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 4791 } 4792 sv.Message = ptr.String(jtv) 4793 } 4794 4795 default: 4796 _, _ = key, value 4797 4798 } 4799 } 4800 *v = sv 4801 return nil 4802} 4803 4804func awsAwsjson11_deserializeDocumentInvalidOperationException(v **types.InvalidOperationException, value interface{}) error { 4805 if v == nil { 4806 return fmt.Errorf("unexpected nil of type %T", v) 4807 } 4808 if value == nil { 4809 return nil 4810 } 4811 4812 shape, ok := value.(map[string]interface{}) 4813 if !ok { 4814 return fmt.Errorf("unexpected JSON type %v", value) 4815 } 4816 4817 var sv *types.InvalidOperationException 4818 if *v == nil { 4819 sv = &types.InvalidOperationException{} 4820 } else { 4821 sv = *v 4822 } 4823 4824 for key, value := range shape { 4825 switch key { 4826 case "Message": 4827 if value != nil { 4828 jtv, ok := value.(string) 4829 if !ok { 4830 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 4831 } 4832 sv.Message = ptr.String(jtv) 4833 } 4834 4835 default: 4836 _, _ = key, value 4837 4838 } 4839 } 4840 *v = sv 4841 return nil 4842} 4843 4844func awsAwsjson11_deserializeDocumentInvalidTypeException(v **types.InvalidTypeException, value interface{}) error { 4845 if v == nil { 4846 return fmt.Errorf("unexpected nil of type %T", v) 4847 } 4848 if value == nil { 4849 return nil 4850 } 4851 4852 shape, ok := value.(map[string]interface{}) 4853 if !ok { 4854 return fmt.Errorf("unexpected JSON type %v", value) 4855 } 4856 4857 var sv *types.InvalidTypeException 4858 if *v == nil { 4859 sv = &types.InvalidTypeException{} 4860 } else { 4861 sv = *v 4862 } 4863 4864 for key, value := range shape { 4865 switch key { 4866 case "Message": 4867 if value != nil { 4868 jtv, ok := value.(string) 4869 if !ok { 4870 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 4871 } 4872 sv.Message = ptr.String(jtv) 4873 } 4874 4875 default: 4876 _, _ = key, value 4877 4878 } 4879 } 4880 *v = sv 4881 return nil 4882} 4883 4884func awsAwsjson11_deserializeDocumentIssueInfoMap(v *map[string]string, value interface{}) error { 4885 if v == nil { 4886 return fmt.Errorf("unexpected nil of type %T", v) 4887 } 4888 if value == nil { 4889 return nil 4890 } 4891 4892 shape, ok := value.(map[string]interface{}) 4893 if !ok { 4894 return fmt.Errorf("unexpected JSON type %v", value) 4895 } 4896 4897 var mv map[string]string 4898 if *v == nil { 4899 mv = map[string]string{} 4900 } else { 4901 mv = *v 4902 } 4903 4904 for key, value := range shape { 4905 var parsedVal string 4906 if value != nil { 4907 jtv, ok := value.(string) 4908 if !ok { 4909 return fmt.Errorf("expected DetailedInfo to be of type string, got %T instead", value) 4910 } 4911 parsedVal = jtv 4912 } 4913 mv[key] = parsedVal 4914 4915 } 4916 *v = mv 4917 return nil 4918} 4919 4920func awsAwsjson11_deserializeDocumentLengthBoundedStringList(v *[]string, value interface{}) error { 4921 if v == nil { 4922 return fmt.Errorf("unexpected nil of type %T", v) 4923 } 4924 if value == nil { 4925 return nil 4926 } 4927 4928 shape, ok := value.([]interface{}) 4929 if !ok { 4930 return fmt.Errorf("unexpected JSON type %v", value) 4931 } 4932 4933 var cv []string 4934 if *v == nil { 4935 cv = []string{} 4936 } else { 4937 cv = *v 4938 } 4939 4940 for _, value := range shape { 4941 var col string 4942 if value != nil { 4943 jtv, ok := value.(string) 4944 if !ok { 4945 return fmt.Errorf("expected LengthBoundedString to be of type string, got %T instead", value) 4946 } 4947 col = jtv 4948 } 4949 cv = append(cv, col) 4950 4951 } 4952 *v = cv 4953 return nil 4954} 4955 4956func awsAwsjson11_deserializeDocumentLimitExceededException(v **types.LimitExceededException, value interface{}) error { 4957 if v == nil { 4958 return fmt.Errorf("unexpected nil of type %T", v) 4959 } 4960 if value == nil { 4961 return nil 4962 } 4963 4964 shape, ok := value.(map[string]interface{}) 4965 if !ok { 4966 return fmt.Errorf("unexpected JSON type %v", value) 4967 } 4968 4969 var sv *types.LimitExceededException 4970 if *v == nil { 4971 sv = &types.LimitExceededException{} 4972 } else { 4973 sv = *v 4974 } 4975 4976 for key, value := range shape { 4977 switch key { 4978 case "Message": 4979 if value != nil { 4980 jtv, ok := value.(string) 4981 if !ok { 4982 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 4983 } 4984 sv.Message = ptr.String(jtv) 4985 } 4986 4987 default: 4988 _, _ = key, value 4989 4990 } 4991 } 4992 *v = sv 4993 return nil 4994} 4995 4996func awsAwsjson11_deserializeDocumentMemberAccounts(v *[]string, value interface{}) error { 4997 if v == nil { 4998 return fmt.Errorf("unexpected nil of type %T", v) 4999 } 5000 if value == nil { 5001 return nil 5002 } 5003 5004 shape, ok := value.([]interface{}) 5005 if !ok { 5006 return fmt.Errorf("unexpected JSON type %v", value) 5007 } 5008 5009 var cv []string 5010 if *v == nil { 5011 cv = []string{} 5012 } else { 5013 cv = *v 5014 } 5015 5016 for _, value := range shape { 5017 var col string 5018 if value != nil { 5019 jtv, ok := value.(string) 5020 if !ok { 5021 return fmt.Errorf("expected AWSAccountId to be of type string, got %T instead", value) 5022 } 5023 col = jtv 5024 } 5025 cv = append(cv, col) 5026 5027 } 5028 *v = cv 5029 return nil 5030} 5031 5032func awsAwsjson11_deserializeDocumentNetworkFirewallActionList(v *[]string, value interface{}) error { 5033 if v == nil { 5034 return fmt.Errorf("unexpected nil of type %T", v) 5035 } 5036 if value == nil { 5037 return nil 5038 } 5039 5040 shape, ok := value.([]interface{}) 5041 if !ok { 5042 return fmt.Errorf("unexpected JSON type %v", value) 5043 } 5044 5045 var cv []string 5046 if *v == nil { 5047 cv = []string{} 5048 } else { 5049 cv = *v 5050 } 5051 5052 for _, value := range shape { 5053 var col string 5054 if value != nil { 5055 jtv, ok := value.(string) 5056 if !ok { 5057 return fmt.Errorf("expected NetworkFirewallAction to be of type string, got %T instead", value) 5058 } 5059 col = jtv 5060 } 5061 cv = append(cv, col) 5062 5063 } 5064 *v = cv 5065 return nil 5066} 5067 5068func awsAwsjson11_deserializeDocumentNetworkFirewallBlackHoleRouteDetectedViolation(v **types.NetworkFirewallBlackHoleRouteDetectedViolation, value interface{}) error { 5069 if v == nil { 5070 return fmt.Errorf("unexpected nil of type %T", v) 5071 } 5072 if value == nil { 5073 return nil 5074 } 5075 5076 shape, ok := value.(map[string]interface{}) 5077 if !ok { 5078 return fmt.Errorf("unexpected JSON type %v", value) 5079 } 5080 5081 var sv *types.NetworkFirewallBlackHoleRouteDetectedViolation 5082 if *v == nil { 5083 sv = &types.NetworkFirewallBlackHoleRouteDetectedViolation{} 5084 } else { 5085 sv = *v 5086 } 5087 5088 for key, value := range shape { 5089 switch key { 5090 case "RouteTableId": 5091 if value != nil { 5092 jtv, ok := value.(string) 5093 if !ok { 5094 return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value) 5095 } 5096 sv.RouteTableId = ptr.String(jtv) 5097 } 5098 5099 case "ViolatingRoutes": 5100 if err := awsAwsjson11_deserializeDocumentRoutes(&sv.ViolatingRoutes, value); err != nil { 5101 return err 5102 } 5103 5104 case "ViolationTarget": 5105 if value != nil { 5106 jtv, ok := value.(string) 5107 if !ok { 5108 return fmt.Errorf("expected ViolationTarget to be of type string, got %T instead", value) 5109 } 5110 sv.ViolationTarget = ptr.String(jtv) 5111 } 5112 5113 case "VpcId": 5114 if value != nil { 5115 jtv, ok := value.(string) 5116 if !ok { 5117 return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value) 5118 } 5119 sv.VpcId = ptr.String(jtv) 5120 } 5121 5122 default: 5123 _, _ = key, value 5124 5125 } 5126 } 5127 *v = sv 5128 return nil 5129} 5130 5131func awsAwsjson11_deserializeDocumentNetworkFirewallInternetTrafficNotInspectedViolation(v **types.NetworkFirewallInternetTrafficNotInspectedViolation, value interface{}) error { 5132 if v == nil { 5133 return fmt.Errorf("unexpected nil of type %T", v) 5134 } 5135 if value == nil { 5136 return nil 5137 } 5138 5139 shape, ok := value.(map[string]interface{}) 5140 if !ok { 5141 return fmt.Errorf("unexpected JSON type %v", value) 5142 } 5143 5144 var sv *types.NetworkFirewallInternetTrafficNotInspectedViolation 5145 if *v == nil { 5146 sv = &types.NetworkFirewallInternetTrafficNotInspectedViolation{} 5147 } else { 5148 sv = *v 5149 } 5150 5151 for key, value := range shape { 5152 switch key { 5153 case "ActualFirewallSubnetRoutes": 5154 if err := awsAwsjson11_deserializeDocumentRoutes(&sv.ActualFirewallSubnetRoutes, value); err != nil { 5155 return err 5156 } 5157 5158 case "ActualInternetGatewayRoutes": 5159 if err := awsAwsjson11_deserializeDocumentRoutes(&sv.ActualInternetGatewayRoutes, value); err != nil { 5160 return err 5161 } 5162 5163 case "CurrentFirewallSubnetRouteTable": 5164 if value != nil { 5165 jtv, ok := value.(string) 5166 if !ok { 5167 return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value) 5168 } 5169 sv.CurrentFirewallSubnetRouteTable = ptr.String(jtv) 5170 } 5171 5172 case "CurrentInternetGatewayRouteTable": 5173 if value != nil { 5174 jtv, ok := value.(string) 5175 if !ok { 5176 return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value) 5177 } 5178 sv.CurrentInternetGatewayRouteTable = ptr.String(jtv) 5179 } 5180 5181 case "ExpectedFirewallEndpoint": 5182 if value != nil { 5183 jtv, ok := value.(string) 5184 if !ok { 5185 return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value) 5186 } 5187 sv.ExpectedFirewallEndpoint = ptr.String(jtv) 5188 } 5189 5190 case "ExpectedFirewallSubnetRoutes": 5191 if err := awsAwsjson11_deserializeDocumentExpectedRoutes(&sv.ExpectedFirewallSubnetRoutes, value); err != nil { 5192 return err 5193 } 5194 5195 case "ExpectedInternetGatewayRoutes": 5196 if err := awsAwsjson11_deserializeDocumentExpectedRoutes(&sv.ExpectedInternetGatewayRoutes, value); err != nil { 5197 return err 5198 } 5199 5200 case "FirewallSubnetId": 5201 if value != nil { 5202 jtv, ok := value.(string) 5203 if !ok { 5204 return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value) 5205 } 5206 sv.FirewallSubnetId = ptr.String(jtv) 5207 } 5208 5209 case "InternetGatewayId": 5210 if value != nil { 5211 jtv, ok := value.(string) 5212 if !ok { 5213 return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value) 5214 } 5215 sv.InternetGatewayId = ptr.String(jtv) 5216 } 5217 5218 case "IsRouteTableUsedInDifferentAZ": 5219 if value != nil { 5220 jtv, ok := value.(bool) 5221 if !ok { 5222 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 5223 } 5224 sv.IsRouteTableUsedInDifferentAZ = jtv 5225 } 5226 5227 case "RouteTableId": 5228 if value != nil { 5229 jtv, ok := value.(string) 5230 if !ok { 5231 return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value) 5232 } 5233 sv.RouteTableId = ptr.String(jtv) 5234 } 5235 5236 case "SubnetAvailabilityZone": 5237 if value != nil { 5238 jtv, ok := value.(string) 5239 if !ok { 5240 return fmt.Errorf("expected LengthBoundedString to be of type string, got %T instead", value) 5241 } 5242 sv.SubnetAvailabilityZone = ptr.String(jtv) 5243 } 5244 5245 case "SubnetId": 5246 if value != nil { 5247 jtv, ok := value.(string) 5248 if !ok { 5249 return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value) 5250 } 5251 sv.SubnetId = ptr.String(jtv) 5252 } 5253 5254 case "ViolatingRoutes": 5255 if err := awsAwsjson11_deserializeDocumentRoutes(&sv.ViolatingRoutes, value); err != nil { 5256 return err 5257 } 5258 5259 case "VpcId": 5260 if value != nil { 5261 jtv, ok := value.(string) 5262 if !ok { 5263 return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value) 5264 } 5265 sv.VpcId = ptr.String(jtv) 5266 } 5267 5268 default: 5269 _, _ = key, value 5270 5271 } 5272 } 5273 *v = sv 5274 return nil 5275} 5276 5277func awsAwsjson11_deserializeDocumentNetworkFirewallInvalidRouteConfigurationViolation(v **types.NetworkFirewallInvalidRouteConfigurationViolation, value interface{}) error { 5278 if v == nil { 5279 return fmt.Errorf("unexpected nil of type %T", v) 5280 } 5281 if value == nil { 5282 return nil 5283 } 5284 5285 shape, ok := value.(map[string]interface{}) 5286 if !ok { 5287 return fmt.Errorf("unexpected JSON type %v", value) 5288 } 5289 5290 var sv *types.NetworkFirewallInvalidRouteConfigurationViolation 5291 if *v == nil { 5292 sv = &types.NetworkFirewallInvalidRouteConfigurationViolation{} 5293 } else { 5294 sv = *v 5295 } 5296 5297 for key, value := range shape { 5298 switch key { 5299 case "ActualFirewallEndpoint": 5300 if value != nil { 5301 jtv, ok := value.(string) 5302 if !ok { 5303 return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value) 5304 } 5305 sv.ActualFirewallEndpoint = ptr.String(jtv) 5306 } 5307 5308 case "ActualFirewallSubnetId": 5309 if value != nil { 5310 jtv, ok := value.(string) 5311 if !ok { 5312 return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value) 5313 } 5314 sv.ActualFirewallSubnetId = ptr.String(jtv) 5315 } 5316 5317 case "ActualFirewallSubnetRoutes": 5318 if err := awsAwsjson11_deserializeDocumentRoutes(&sv.ActualFirewallSubnetRoutes, value); err != nil { 5319 return err 5320 } 5321 5322 case "ActualInternetGatewayRoutes": 5323 if err := awsAwsjson11_deserializeDocumentRoutes(&sv.ActualInternetGatewayRoutes, value); err != nil { 5324 return err 5325 } 5326 5327 case "AffectedSubnets": 5328 if err := awsAwsjson11_deserializeDocumentResourceIdList(&sv.AffectedSubnets, value); err != nil { 5329 return err 5330 } 5331 5332 case "CurrentFirewallSubnetRouteTable": 5333 if value != nil { 5334 jtv, ok := value.(string) 5335 if !ok { 5336 return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value) 5337 } 5338 sv.CurrentFirewallSubnetRouteTable = ptr.String(jtv) 5339 } 5340 5341 case "CurrentInternetGatewayRouteTable": 5342 if value != nil { 5343 jtv, ok := value.(string) 5344 if !ok { 5345 return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value) 5346 } 5347 sv.CurrentInternetGatewayRouteTable = ptr.String(jtv) 5348 } 5349 5350 case "ExpectedFirewallEndpoint": 5351 if value != nil { 5352 jtv, ok := value.(string) 5353 if !ok { 5354 return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value) 5355 } 5356 sv.ExpectedFirewallEndpoint = ptr.String(jtv) 5357 } 5358 5359 case "ExpectedFirewallSubnetId": 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 sv.ExpectedFirewallSubnetId = ptr.String(jtv) 5366 } 5367 5368 case "ExpectedFirewallSubnetRoutes": 5369 if err := awsAwsjson11_deserializeDocumentExpectedRoutes(&sv.ExpectedFirewallSubnetRoutes, value); err != nil { 5370 return err 5371 } 5372 5373 case "ExpectedInternetGatewayRoutes": 5374 if err := awsAwsjson11_deserializeDocumentExpectedRoutes(&sv.ExpectedInternetGatewayRoutes, value); err != nil { 5375 return err 5376 } 5377 5378 case "InternetGatewayId": 5379 if value != nil { 5380 jtv, ok := value.(string) 5381 if !ok { 5382 return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value) 5383 } 5384 sv.InternetGatewayId = ptr.String(jtv) 5385 } 5386 5387 case "IsRouteTableUsedInDifferentAZ": 5388 if value != nil { 5389 jtv, ok := value.(bool) 5390 if !ok { 5391 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 5392 } 5393 sv.IsRouteTableUsedInDifferentAZ = jtv 5394 } 5395 5396 case "RouteTableId": 5397 if value != nil { 5398 jtv, ok := value.(string) 5399 if !ok { 5400 return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value) 5401 } 5402 sv.RouteTableId = ptr.String(jtv) 5403 } 5404 5405 case "ViolatingRoute": 5406 if err := awsAwsjson11_deserializeDocumentRoute(&sv.ViolatingRoute, value); err != nil { 5407 return err 5408 } 5409 5410 case "VpcId": 5411 if value != nil { 5412 jtv, ok := value.(string) 5413 if !ok { 5414 return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value) 5415 } 5416 sv.VpcId = ptr.String(jtv) 5417 } 5418 5419 default: 5420 _, _ = key, value 5421 5422 } 5423 } 5424 *v = sv 5425 return nil 5426} 5427 5428func awsAwsjson11_deserializeDocumentNetworkFirewallMissingExpectedRoutesViolation(v **types.NetworkFirewallMissingExpectedRoutesViolation, value interface{}) error { 5429 if v == nil { 5430 return fmt.Errorf("unexpected nil of type %T", v) 5431 } 5432 if value == nil { 5433 return nil 5434 } 5435 5436 shape, ok := value.(map[string]interface{}) 5437 if !ok { 5438 return fmt.Errorf("unexpected JSON type %v", value) 5439 } 5440 5441 var sv *types.NetworkFirewallMissingExpectedRoutesViolation 5442 if *v == nil { 5443 sv = &types.NetworkFirewallMissingExpectedRoutesViolation{} 5444 } else { 5445 sv = *v 5446 } 5447 5448 for key, value := range shape { 5449 switch key { 5450 case "ExpectedRoutes": 5451 if err := awsAwsjson11_deserializeDocumentExpectedRoutes(&sv.ExpectedRoutes, value); err != nil { 5452 return err 5453 } 5454 5455 case "ViolationTarget": 5456 if value != nil { 5457 jtv, ok := value.(string) 5458 if !ok { 5459 return fmt.Errorf("expected ViolationTarget to be of type string, got %T instead", value) 5460 } 5461 sv.ViolationTarget = ptr.String(jtv) 5462 } 5463 5464 case "VpcId": 5465 if value != nil { 5466 jtv, ok := value.(string) 5467 if !ok { 5468 return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value) 5469 } 5470 sv.VpcId = ptr.String(jtv) 5471 } 5472 5473 default: 5474 _, _ = key, value 5475 5476 } 5477 } 5478 *v = sv 5479 return nil 5480} 5481 5482func awsAwsjson11_deserializeDocumentNetworkFirewallMissingExpectedRTViolation(v **types.NetworkFirewallMissingExpectedRTViolation, value interface{}) error { 5483 if v == nil { 5484 return fmt.Errorf("unexpected nil of type %T", v) 5485 } 5486 if value == nil { 5487 return nil 5488 } 5489 5490 shape, ok := value.(map[string]interface{}) 5491 if !ok { 5492 return fmt.Errorf("unexpected JSON type %v", value) 5493 } 5494 5495 var sv *types.NetworkFirewallMissingExpectedRTViolation 5496 if *v == nil { 5497 sv = &types.NetworkFirewallMissingExpectedRTViolation{} 5498 } else { 5499 sv = *v 5500 } 5501 5502 for key, value := range shape { 5503 switch key { 5504 case "AvailabilityZone": 5505 if value != nil { 5506 jtv, ok := value.(string) 5507 if !ok { 5508 return fmt.Errorf("expected LengthBoundedString to be of type string, got %T instead", value) 5509 } 5510 sv.AvailabilityZone = ptr.String(jtv) 5511 } 5512 5513 case "CurrentRouteTable": 5514 if value != nil { 5515 jtv, ok := value.(string) 5516 if !ok { 5517 return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value) 5518 } 5519 sv.CurrentRouteTable = ptr.String(jtv) 5520 } 5521 5522 case "ExpectedRouteTable": 5523 if value != nil { 5524 jtv, ok := value.(string) 5525 if !ok { 5526 return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value) 5527 } 5528 sv.ExpectedRouteTable = ptr.String(jtv) 5529 } 5530 5531 case "ViolationTarget": 5532 if value != nil { 5533 jtv, ok := value.(string) 5534 if !ok { 5535 return fmt.Errorf("expected ViolationTarget to be of type string, got %T instead", value) 5536 } 5537 sv.ViolationTarget = ptr.String(jtv) 5538 } 5539 5540 case "VPC": 5541 if value != nil { 5542 jtv, ok := value.(string) 5543 if !ok { 5544 return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value) 5545 } 5546 sv.VPC = ptr.String(jtv) 5547 } 5548 5549 default: 5550 _, _ = key, value 5551 5552 } 5553 } 5554 *v = sv 5555 return nil 5556} 5557 5558func awsAwsjson11_deserializeDocumentNetworkFirewallMissingFirewallViolation(v **types.NetworkFirewallMissingFirewallViolation, value interface{}) error { 5559 if v == nil { 5560 return fmt.Errorf("unexpected nil of type %T", v) 5561 } 5562 if value == nil { 5563 return nil 5564 } 5565 5566 shape, ok := value.(map[string]interface{}) 5567 if !ok { 5568 return fmt.Errorf("unexpected JSON type %v", value) 5569 } 5570 5571 var sv *types.NetworkFirewallMissingFirewallViolation 5572 if *v == nil { 5573 sv = &types.NetworkFirewallMissingFirewallViolation{} 5574 } else { 5575 sv = *v 5576 } 5577 5578 for key, value := range shape { 5579 switch key { 5580 case "AvailabilityZone": 5581 if value != nil { 5582 jtv, ok := value.(string) 5583 if !ok { 5584 return fmt.Errorf("expected LengthBoundedString to be of type string, got %T instead", value) 5585 } 5586 sv.AvailabilityZone = ptr.String(jtv) 5587 } 5588 5589 case "TargetViolationReason": 5590 if value != nil { 5591 jtv, ok := value.(string) 5592 if !ok { 5593 return fmt.Errorf("expected TargetViolationReason to be of type string, got %T instead", value) 5594 } 5595 sv.TargetViolationReason = ptr.String(jtv) 5596 } 5597 5598 case "ViolationTarget": 5599 if value != nil { 5600 jtv, ok := value.(string) 5601 if !ok { 5602 return fmt.Errorf("expected ViolationTarget to be of type string, got %T instead", value) 5603 } 5604 sv.ViolationTarget = ptr.String(jtv) 5605 } 5606 5607 case "VPC": 5608 if value != nil { 5609 jtv, ok := value.(string) 5610 if !ok { 5611 return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value) 5612 } 5613 sv.VPC = ptr.String(jtv) 5614 } 5615 5616 default: 5617 _, _ = key, value 5618 5619 } 5620 } 5621 *v = sv 5622 return nil 5623} 5624 5625func awsAwsjson11_deserializeDocumentNetworkFirewallMissingSubnetViolation(v **types.NetworkFirewallMissingSubnetViolation, value interface{}) error { 5626 if v == nil { 5627 return fmt.Errorf("unexpected nil of type %T", v) 5628 } 5629 if value == nil { 5630 return nil 5631 } 5632 5633 shape, ok := value.(map[string]interface{}) 5634 if !ok { 5635 return fmt.Errorf("unexpected JSON type %v", value) 5636 } 5637 5638 var sv *types.NetworkFirewallMissingSubnetViolation 5639 if *v == nil { 5640 sv = &types.NetworkFirewallMissingSubnetViolation{} 5641 } else { 5642 sv = *v 5643 } 5644 5645 for key, value := range shape { 5646 switch key { 5647 case "AvailabilityZone": 5648 if value != nil { 5649 jtv, ok := value.(string) 5650 if !ok { 5651 return fmt.Errorf("expected LengthBoundedString to be of type string, got %T instead", value) 5652 } 5653 sv.AvailabilityZone = ptr.String(jtv) 5654 } 5655 5656 case "TargetViolationReason": 5657 if value != nil { 5658 jtv, ok := value.(string) 5659 if !ok { 5660 return fmt.Errorf("expected TargetViolationReason to be of type string, got %T instead", value) 5661 } 5662 sv.TargetViolationReason = ptr.String(jtv) 5663 } 5664 5665 case "ViolationTarget": 5666 if value != nil { 5667 jtv, ok := value.(string) 5668 if !ok { 5669 return fmt.Errorf("expected ViolationTarget to be of type string, got %T instead", value) 5670 } 5671 sv.ViolationTarget = ptr.String(jtv) 5672 } 5673 5674 case "VPC": 5675 if value != nil { 5676 jtv, ok := value.(string) 5677 if !ok { 5678 return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value) 5679 } 5680 sv.VPC = ptr.String(jtv) 5681 } 5682 5683 default: 5684 _, _ = key, value 5685 5686 } 5687 } 5688 *v = sv 5689 return nil 5690} 5691 5692func awsAwsjson11_deserializeDocumentNetworkFirewallPolicyDescription(v **types.NetworkFirewallPolicyDescription, value interface{}) error { 5693 if v == nil { 5694 return fmt.Errorf("unexpected nil of type %T", v) 5695 } 5696 if value == nil { 5697 return nil 5698 } 5699 5700 shape, ok := value.(map[string]interface{}) 5701 if !ok { 5702 return fmt.Errorf("unexpected JSON type %v", value) 5703 } 5704 5705 var sv *types.NetworkFirewallPolicyDescription 5706 if *v == nil { 5707 sv = &types.NetworkFirewallPolicyDescription{} 5708 } else { 5709 sv = *v 5710 } 5711 5712 for key, value := range shape { 5713 switch key { 5714 case "StatefulRuleGroups": 5715 if err := awsAwsjson11_deserializeDocumentStatefulRuleGroupList(&sv.StatefulRuleGroups, value); err != nil { 5716 return err 5717 } 5718 5719 case "StatelessCustomActions": 5720 if err := awsAwsjson11_deserializeDocumentNetworkFirewallActionList(&sv.StatelessCustomActions, value); err != nil { 5721 return err 5722 } 5723 5724 case "StatelessDefaultActions": 5725 if err := awsAwsjson11_deserializeDocumentNetworkFirewallActionList(&sv.StatelessDefaultActions, value); err != nil { 5726 return err 5727 } 5728 5729 case "StatelessFragmentDefaultActions": 5730 if err := awsAwsjson11_deserializeDocumentNetworkFirewallActionList(&sv.StatelessFragmentDefaultActions, value); err != nil { 5731 return err 5732 } 5733 5734 case "StatelessRuleGroups": 5735 if err := awsAwsjson11_deserializeDocumentStatelessRuleGroupList(&sv.StatelessRuleGroups, value); err != nil { 5736 return err 5737 } 5738 5739 default: 5740 _, _ = key, value 5741 5742 } 5743 } 5744 *v = sv 5745 return nil 5746} 5747 5748func awsAwsjson11_deserializeDocumentNetworkFirewallPolicyModifiedViolation(v **types.NetworkFirewallPolicyModifiedViolation, value interface{}) error { 5749 if v == nil { 5750 return fmt.Errorf("unexpected nil of type %T", v) 5751 } 5752 if value == nil { 5753 return nil 5754 } 5755 5756 shape, ok := value.(map[string]interface{}) 5757 if !ok { 5758 return fmt.Errorf("unexpected JSON type %v", value) 5759 } 5760 5761 var sv *types.NetworkFirewallPolicyModifiedViolation 5762 if *v == nil { 5763 sv = &types.NetworkFirewallPolicyModifiedViolation{} 5764 } else { 5765 sv = *v 5766 } 5767 5768 for key, value := range shape { 5769 switch key { 5770 case "CurrentPolicyDescription": 5771 if err := awsAwsjson11_deserializeDocumentNetworkFirewallPolicyDescription(&sv.CurrentPolicyDescription, value); err != nil { 5772 return err 5773 } 5774 5775 case "ExpectedPolicyDescription": 5776 if err := awsAwsjson11_deserializeDocumentNetworkFirewallPolicyDescription(&sv.ExpectedPolicyDescription, value); err != nil { 5777 return err 5778 } 5779 5780 case "ViolationTarget": 5781 if value != nil { 5782 jtv, ok := value.(string) 5783 if !ok { 5784 return fmt.Errorf("expected ViolationTarget to be of type string, got %T instead", value) 5785 } 5786 sv.ViolationTarget = ptr.String(jtv) 5787 } 5788 5789 default: 5790 _, _ = key, value 5791 5792 } 5793 } 5794 *v = sv 5795 return nil 5796} 5797 5798func awsAwsjson11_deserializeDocumentNetworkFirewallUnexpectedFirewallRoutesViolation(v **types.NetworkFirewallUnexpectedFirewallRoutesViolation, value interface{}) error { 5799 if v == nil { 5800 return fmt.Errorf("unexpected nil of type %T", v) 5801 } 5802 if value == nil { 5803 return nil 5804 } 5805 5806 shape, ok := value.(map[string]interface{}) 5807 if !ok { 5808 return fmt.Errorf("unexpected JSON type %v", value) 5809 } 5810 5811 var sv *types.NetworkFirewallUnexpectedFirewallRoutesViolation 5812 if *v == nil { 5813 sv = &types.NetworkFirewallUnexpectedFirewallRoutesViolation{} 5814 } else { 5815 sv = *v 5816 } 5817 5818 for key, value := range shape { 5819 switch key { 5820 case "FirewallEndpoint": 5821 if value != nil { 5822 jtv, ok := value.(string) 5823 if !ok { 5824 return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value) 5825 } 5826 sv.FirewallEndpoint = ptr.String(jtv) 5827 } 5828 5829 case "FirewallSubnetId": 5830 if value != nil { 5831 jtv, ok := value.(string) 5832 if !ok { 5833 return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value) 5834 } 5835 sv.FirewallSubnetId = ptr.String(jtv) 5836 } 5837 5838 case "RouteTableId": 5839 if value != nil { 5840 jtv, ok := value.(string) 5841 if !ok { 5842 return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value) 5843 } 5844 sv.RouteTableId = ptr.String(jtv) 5845 } 5846 5847 case "ViolatingRoutes": 5848 if err := awsAwsjson11_deserializeDocumentRoutes(&sv.ViolatingRoutes, value); err != nil { 5849 return err 5850 } 5851 5852 case "VpcId": 5853 if value != nil { 5854 jtv, ok := value.(string) 5855 if !ok { 5856 return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value) 5857 } 5858 sv.VpcId = ptr.String(jtv) 5859 } 5860 5861 default: 5862 _, _ = key, value 5863 5864 } 5865 } 5866 *v = sv 5867 return nil 5868} 5869 5870func awsAwsjson11_deserializeDocumentNetworkFirewallUnexpectedGatewayRoutesViolation(v **types.NetworkFirewallUnexpectedGatewayRoutesViolation, value interface{}) error { 5871 if v == nil { 5872 return fmt.Errorf("unexpected nil of type %T", v) 5873 } 5874 if value == nil { 5875 return nil 5876 } 5877 5878 shape, ok := value.(map[string]interface{}) 5879 if !ok { 5880 return fmt.Errorf("unexpected JSON type %v", value) 5881 } 5882 5883 var sv *types.NetworkFirewallUnexpectedGatewayRoutesViolation 5884 if *v == nil { 5885 sv = &types.NetworkFirewallUnexpectedGatewayRoutesViolation{} 5886 } else { 5887 sv = *v 5888 } 5889 5890 for key, value := range shape { 5891 switch key { 5892 case "GatewayId": 5893 if value != nil { 5894 jtv, ok := value.(string) 5895 if !ok { 5896 return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value) 5897 } 5898 sv.GatewayId = ptr.String(jtv) 5899 } 5900 5901 case "RouteTableId": 5902 if value != nil { 5903 jtv, ok := value.(string) 5904 if !ok { 5905 return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value) 5906 } 5907 sv.RouteTableId = ptr.String(jtv) 5908 } 5909 5910 case "ViolatingRoutes": 5911 if err := awsAwsjson11_deserializeDocumentRoutes(&sv.ViolatingRoutes, value); err != nil { 5912 return err 5913 } 5914 5915 case "VpcId": 5916 if value != nil { 5917 jtv, ok := value.(string) 5918 if !ok { 5919 return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value) 5920 } 5921 sv.VpcId = ptr.String(jtv) 5922 } 5923 5924 default: 5925 _, _ = key, value 5926 5927 } 5928 } 5929 *v = sv 5930 return nil 5931} 5932 5933func awsAwsjson11_deserializeDocumentOrderedRemediationActions(v *[]types.RemediationActionWithOrder, value interface{}) error { 5934 if v == nil { 5935 return fmt.Errorf("unexpected nil of type %T", v) 5936 } 5937 if value == nil { 5938 return nil 5939 } 5940 5941 shape, ok := value.([]interface{}) 5942 if !ok { 5943 return fmt.Errorf("unexpected JSON type %v", value) 5944 } 5945 5946 var cv []types.RemediationActionWithOrder 5947 if *v == nil { 5948 cv = []types.RemediationActionWithOrder{} 5949 } else { 5950 cv = *v 5951 } 5952 5953 for _, value := range shape { 5954 var col types.RemediationActionWithOrder 5955 destAddr := &col 5956 if err := awsAwsjson11_deserializeDocumentRemediationActionWithOrder(&destAddr, value); err != nil { 5957 return err 5958 } 5959 col = *destAddr 5960 cv = append(cv, col) 5961 5962 } 5963 *v = cv 5964 return nil 5965} 5966 5967func awsAwsjson11_deserializeDocumentPartialMatch(v **types.PartialMatch, value interface{}) error { 5968 if v == nil { 5969 return fmt.Errorf("unexpected nil of type %T", v) 5970 } 5971 if value == nil { 5972 return nil 5973 } 5974 5975 shape, ok := value.(map[string]interface{}) 5976 if !ok { 5977 return fmt.Errorf("unexpected JSON type %v", value) 5978 } 5979 5980 var sv *types.PartialMatch 5981 if *v == nil { 5982 sv = &types.PartialMatch{} 5983 } else { 5984 sv = *v 5985 } 5986 5987 for key, value := range shape { 5988 switch key { 5989 case "Reference": 5990 if value != nil { 5991 jtv, ok := value.(string) 5992 if !ok { 5993 return fmt.Errorf("expected ReferenceRule to be of type string, got %T instead", value) 5994 } 5995 sv.Reference = ptr.String(jtv) 5996 } 5997 5998 case "TargetViolationReasons": 5999 if err := awsAwsjson11_deserializeDocumentTargetViolationReasons(&sv.TargetViolationReasons, value); err != nil { 6000 return err 6001 } 6002 6003 default: 6004 _, _ = key, value 6005 6006 } 6007 } 6008 *v = sv 6009 return nil 6010} 6011 6012func awsAwsjson11_deserializeDocumentPartialMatches(v *[]types.PartialMatch, value interface{}) error { 6013 if v == nil { 6014 return fmt.Errorf("unexpected nil of type %T", v) 6015 } 6016 if value == nil { 6017 return nil 6018 } 6019 6020 shape, ok := value.([]interface{}) 6021 if !ok { 6022 return fmt.Errorf("unexpected JSON type %v", value) 6023 } 6024 6025 var cv []types.PartialMatch 6026 if *v == nil { 6027 cv = []types.PartialMatch{} 6028 } else { 6029 cv = *v 6030 } 6031 6032 for _, value := range shape { 6033 var col types.PartialMatch 6034 destAddr := &col 6035 if err := awsAwsjson11_deserializeDocumentPartialMatch(&destAddr, value); err != nil { 6036 return err 6037 } 6038 col = *destAddr 6039 cv = append(cv, col) 6040 6041 } 6042 *v = cv 6043 return nil 6044} 6045 6046func awsAwsjson11_deserializeDocumentPolicy(v **types.Policy, value interface{}) error { 6047 if v == nil { 6048 return fmt.Errorf("unexpected nil of type %T", v) 6049 } 6050 if value == nil { 6051 return nil 6052 } 6053 6054 shape, ok := value.(map[string]interface{}) 6055 if !ok { 6056 return fmt.Errorf("unexpected JSON type %v", value) 6057 } 6058 6059 var sv *types.Policy 6060 if *v == nil { 6061 sv = &types.Policy{} 6062 } else { 6063 sv = *v 6064 } 6065 6066 for key, value := range shape { 6067 switch key { 6068 case "DeleteUnusedFMManagedResources": 6069 if value != nil { 6070 jtv, ok := value.(bool) 6071 if !ok { 6072 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 6073 } 6074 sv.DeleteUnusedFMManagedResources = jtv 6075 } 6076 6077 case "ExcludeMap": 6078 if err := awsAwsjson11_deserializeDocumentCustomerPolicyScopeMap(&sv.ExcludeMap, value); err != nil { 6079 return err 6080 } 6081 6082 case "ExcludeResourceTags": 6083 if value != nil { 6084 jtv, ok := value.(bool) 6085 if !ok { 6086 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 6087 } 6088 sv.ExcludeResourceTags = jtv 6089 } 6090 6091 case "IncludeMap": 6092 if err := awsAwsjson11_deserializeDocumentCustomerPolicyScopeMap(&sv.IncludeMap, value); err != nil { 6093 return err 6094 } 6095 6096 case "PolicyId": 6097 if value != nil { 6098 jtv, ok := value.(string) 6099 if !ok { 6100 return fmt.Errorf("expected PolicyId to be of type string, got %T instead", value) 6101 } 6102 sv.PolicyId = ptr.String(jtv) 6103 } 6104 6105 case "PolicyName": 6106 if value != nil { 6107 jtv, ok := value.(string) 6108 if !ok { 6109 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value) 6110 } 6111 sv.PolicyName = ptr.String(jtv) 6112 } 6113 6114 case "PolicyUpdateToken": 6115 if value != nil { 6116 jtv, ok := value.(string) 6117 if !ok { 6118 return fmt.Errorf("expected PolicyUpdateToken to be of type string, got %T instead", value) 6119 } 6120 sv.PolicyUpdateToken = ptr.String(jtv) 6121 } 6122 6123 case "RemediationEnabled": 6124 if value != nil { 6125 jtv, ok := value.(bool) 6126 if !ok { 6127 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 6128 } 6129 sv.RemediationEnabled = jtv 6130 } 6131 6132 case "ResourceTags": 6133 if err := awsAwsjson11_deserializeDocumentResourceTags(&sv.ResourceTags, value); err != nil { 6134 return err 6135 } 6136 6137 case "ResourceType": 6138 if value != nil { 6139 jtv, ok := value.(string) 6140 if !ok { 6141 return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value) 6142 } 6143 sv.ResourceType = ptr.String(jtv) 6144 } 6145 6146 case "ResourceTypeList": 6147 if err := awsAwsjson11_deserializeDocumentResourceTypeList(&sv.ResourceTypeList, value); err != nil { 6148 return err 6149 } 6150 6151 case "SecurityServicePolicyData": 6152 if err := awsAwsjson11_deserializeDocumentSecurityServicePolicyData(&sv.SecurityServicePolicyData, value); err != nil { 6153 return err 6154 } 6155 6156 default: 6157 _, _ = key, value 6158 6159 } 6160 } 6161 *v = sv 6162 return nil 6163} 6164 6165func awsAwsjson11_deserializeDocumentPolicyComplianceDetail(v **types.PolicyComplianceDetail, value interface{}) error { 6166 if v == nil { 6167 return fmt.Errorf("unexpected nil of type %T", v) 6168 } 6169 if value == nil { 6170 return nil 6171 } 6172 6173 shape, ok := value.(map[string]interface{}) 6174 if !ok { 6175 return fmt.Errorf("unexpected JSON type %v", value) 6176 } 6177 6178 var sv *types.PolicyComplianceDetail 6179 if *v == nil { 6180 sv = &types.PolicyComplianceDetail{} 6181 } else { 6182 sv = *v 6183 } 6184 6185 for key, value := range shape { 6186 switch key { 6187 case "EvaluationLimitExceeded": 6188 if value != nil { 6189 jtv, ok := value.(bool) 6190 if !ok { 6191 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 6192 } 6193 sv.EvaluationLimitExceeded = jtv 6194 } 6195 6196 case "ExpiredAt": 6197 if value != nil { 6198 switch jtv := value.(type) { 6199 case json.Number: 6200 f64, err := jtv.Float64() 6201 if err != nil { 6202 return err 6203 } 6204 sv.ExpiredAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 6205 6206 default: 6207 return fmt.Errorf("expected TimeStamp to be a JSON Number, got %T instead", value) 6208 6209 } 6210 } 6211 6212 case "IssueInfoMap": 6213 if err := awsAwsjson11_deserializeDocumentIssueInfoMap(&sv.IssueInfoMap, value); err != nil { 6214 return err 6215 } 6216 6217 case "MemberAccount": 6218 if value != nil { 6219 jtv, ok := value.(string) 6220 if !ok { 6221 return fmt.Errorf("expected AWSAccountId to be of type string, got %T instead", value) 6222 } 6223 sv.MemberAccount = ptr.String(jtv) 6224 } 6225 6226 case "PolicyId": 6227 if value != nil { 6228 jtv, ok := value.(string) 6229 if !ok { 6230 return fmt.Errorf("expected PolicyId to be of type string, got %T instead", value) 6231 } 6232 sv.PolicyId = ptr.String(jtv) 6233 } 6234 6235 case "PolicyOwner": 6236 if value != nil { 6237 jtv, ok := value.(string) 6238 if !ok { 6239 return fmt.Errorf("expected AWSAccountId to be of type string, got %T instead", value) 6240 } 6241 sv.PolicyOwner = ptr.String(jtv) 6242 } 6243 6244 case "Violators": 6245 if err := awsAwsjson11_deserializeDocumentComplianceViolators(&sv.Violators, value); err != nil { 6246 return err 6247 } 6248 6249 default: 6250 _, _ = key, value 6251 6252 } 6253 } 6254 *v = sv 6255 return nil 6256} 6257 6258func awsAwsjson11_deserializeDocumentPolicyComplianceStatus(v **types.PolicyComplianceStatus, value interface{}) error { 6259 if v == nil { 6260 return fmt.Errorf("unexpected nil of type %T", v) 6261 } 6262 if value == nil { 6263 return nil 6264 } 6265 6266 shape, ok := value.(map[string]interface{}) 6267 if !ok { 6268 return fmt.Errorf("unexpected JSON type %v", value) 6269 } 6270 6271 var sv *types.PolicyComplianceStatus 6272 if *v == nil { 6273 sv = &types.PolicyComplianceStatus{} 6274 } else { 6275 sv = *v 6276 } 6277 6278 for key, value := range shape { 6279 switch key { 6280 case "EvaluationResults": 6281 if err := awsAwsjson11_deserializeDocumentEvaluationResults(&sv.EvaluationResults, value); err != nil { 6282 return err 6283 } 6284 6285 case "IssueInfoMap": 6286 if err := awsAwsjson11_deserializeDocumentIssueInfoMap(&sv.IssueInfoMap, value); err != nil { 6287 return err 6288 } 6289 6290 case "LastUpdated": 6291 if value != nil { 6292 switch jtv := value.(type) { 6293 case json.Number: 6294 f64, err := jtv.Float64() 6295 if err != nil { 6296 return err 6297 } 6298 sv.LastUpdated = ptr.Time(smithytime.ParseEpochSeconds(f64)) 6299 6300 default: 6301 return fmt.Errorf("expected TimeStamp to be a JSON Number, got %T instead", value) 6302 6303 } 6304 } 6305 6306 case "MemberAccount": 6307 if value != nil { 6308 jtv, ok := value.(string) 6309 if !ok { 6310 return fmt.Errorf("expected AWSAccountId to be of type string, got %T instead", value) 6311 } 6312 sv.MemberAccount = ptr.String(jtv) 6313 } 6314 6315 case "PolicyId": 6316 if value != nil { 6317 jtv, ok := value.(string) 6318 if !ok { 6319 return fmt.Errorf("expected PolicyId to be of type string, got %T instead", value) 6320 } 6321 sv.PolicyId = ptr.String(jtv) 6322 } 6323 6324 case "PolicyName": 6325 if value != nil { 6326 jtv, ok := value.(string) 6327 if !ok { 6328 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value) 6329 } 6330 sv.PolicyName = ptr.String(jtv) 6331 } 6332 6333 case "PolicyOwner": 6334 if value != nil { 6335 jtv, ok := value.(string) 6336 if !ok { 6337 return fmt.Errorf("expected AWSAccountId to be of type string, got %T instead", value) 6338 } 6339 sv.PolicyOwner = ptr.String(jtv) 6340 } 6341 6342 default: 6343 _, _ = key, value 6344 6345 } 6346 } 6347 *v = sv 6348 return nil 6349} 6350 6351func awsAwsjson11_deserializeDocumentPolicyComplianceStatusList(v *[]types.PolicyComplianceStatus, value interface{}) error { 6352 if v == nil { 6353 return fmt.Errorf("unexpected nil of type %T", v) 6354 } 6355 if value == nil { 6356 return nil 6357 } 6358 6359 shape, ok := value.([]interface{}) 6360 if !ok { 6361 return fmt.Errorf("unexpected JSON type %v", value) 6362 } 6363 6364 var cv []types.PolicyComplianceStatus 6365 if *v == nil { 6366 cv = []types.PolicyComplianceStatus{} 6367 } else { 6368 cv = *v 6369 } 6370 6371 for _, value := range shape { 6372 var col types.PolicyComplianceStatus 6373 destAddr := &col 6374 if err := awsAwsjson11_deserializeDocumentPolicyComplianceStatus(&destAddr, value); err != nil { 6375 return err 6376 } 6377 col = *destAddr 6378 cv = append(cv, col) 6379 6380 } 6381 *v = cv 6382 return nil 6383} 6384 6385func awsAwsjson11_deserializeDocumentPolicySummary(v **types.PolicySummary, value interface{}) error { 6386 if v == nil { 6387 return fmt.Errorf("unexpected nil of type %T", v) 6388 } 6389 if value == nil { 6390 return nil 6391 } 6392 6393 shape, ok := value.(map[string]interface{}) 6394 if !ok { 6395 return fmt.Errorf("unexpected JSON type %v", value) 6396 } 6397 6398 var sv *types.PolicySummary 6399 if *v == nil { 6400 sv = &types.PolicySummary{} 6401 } else { 6402 sv = *v 6403 } 6404 6405 for key, value := range shape { 6406 switch key { 6407 case "DeleteUnusedFMManagedResources": 6408 if value != nil { 6409 jtv, ok := value.(bool) 6410 if !ok { 6411 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 6412 } 6413 sv.DeleteUnusedFMManagedResources = jtv 6414 } 6415 6416 case "PolicyArn": 6417 if value != nil { 6418 jtv, ok := value.(string) 6419 if !ok { 6420 return fmt.Errorf("expected ResourceArn to be of type string, got %T instead", value) 6421 } 6422 sv.PolicyArn = ptr.String(jtv) 6423 } 6424 6425 case "PolicyId": 6426 if value != nil { 6427 jtv, ok := value.(string) 6428 if !ok { 6429 return fmt.Errorf("expected PolicyId to be of type string, got %T instead", value) 6430 } 6431 sv.PolicyId = ptr.String(jtv) 6432 } 6433 6434 case "PolicyName": 6435 if value != nil { 6436 jtv, ok := value.(string) 6437 if !ok { 6438 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value) 6439 } 6440 sv.PolicyName = ptr.String(jtv) 6441 } 6442 6443 case "RemediationEnabled": 6444 if value != nil { 6445 jtv, ok := value.(bool) 6446 if !ok { 6447 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 6448 } 6449 sv.RemediationEnabled = jtv 6450 } 6451 6452 case "ResourceType": 6453 if value != nil { 6454 jtv, ok := value.(string) 6455 if !ok { 6456 return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value) 6457 } 6458 sv.ResourceType = ptr.String(jtv) 6459 } 6460 6461 case "SecurityServiceType": 6462 if value != nil { 6463 jtv, ok := value.(string) 6464 if !ok { 6465 return fmt.Errorf("expected SecurityServiceType to be of type string, got %T instead", value) 6466 } 6467 sv.SecurityServiceType = types.SecurityServiceType(jtv) 6468 } 6469 6470 default: 6471 _, _ = key, value 6472 6473 } 6474 } 6475 *v = sv 6476 return nil 6477} 6478 6479func awsAwsjson11_deserializeDocumentPolicySummaryList(v *[]types.PolicySummary, value interface{}) error { 6480 if v == nil { 6481 return fmt.Errorf("unexpected nil of type %T", v) 6482 } 6483 if value == nil { 6484 return nil 6485 } 6486 6487 shape, ok := value.([]interface{}) 6488 if !ok { 6489 return fmt.Errorf("unexpected JSON type %v", value) 6490 } 6491 6492 var cv []types.PolicySummary 6493 if *v == nil { 6494 cv = []types.PolicySummary{} 6495 } else { 6496 cv = *v 6497 } 6498 6499 for _, value := range shape { 6500 var col types.PolicySummary 6501 destAddr := &col 6502 if err := awsAwsjson11_deserializeDocumentPolicySummary(&destAddr, value); err != nil { 6503 return err 6504 } 6505 col = *destAddr 6506 cv = append(cv, col) 6507 6508 } 6509 *v = cv 6510 return nil 6511} 6512 6513func awsAwsjson11_deserializeDocumentPossibleRemediationAction(v **types.PossibleRemediationAction, value interface{}) error { 6514 if v == nil { 6515 return fmt.Errorf("unexpected nil of type %T", v) 6516 } 6517 if value == nil { 6518 return nil 6519 } 6520 6521 shape, ok := value.(map[string]interface{}) 6522 if !ok { 6523 return fmt.Errorf("unexpected JSON type %v", value) 6524 } 6525 6526 var sv *types.PossibleRemediationAction 6527 if *v == nil { 6528 sv = &types.PossibleRemediationAction{} 6529 } else { 6530 sv = *v 6531 } 6532 6533 for key, value := range shape { 6534 switch key { 6535 case "Description": 6536 if value != nil { 6537 jtv, ok := value.(string) 6538 if !ok { 6539 return fmt.Errorf("expected LengthBoundedString to be of type string, got %T instead", value) 6540 } 6541 sv.Description = ptr.String(jtv) 6542 } 6543 6544 case "IsDefaultAction": 6545 if value != nil { 6546 jtv, ok := value.(bool) 6547 if !ok { 6548 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 6549 } 6550 sv.IsDefaultAction = jtv 6551 } 6552 6553 case "OrderedRemediationActions": 6554 if err := awsAwsjson11_deserializeDocumentOrderedRemediationActions(&sv.OrderedRemediationActions, value); err != nil { 6555 return err 6556 } 6557 6558 default: 6559 _, _ = key, value 6560 6561 } 6562 } 6563 *v = sv 6564 return nil 6565} 6566 6567func awsAwsjson11_deserializeDocumentPossibleRemediationActionList(v *[]types.PossibleRemediationAction, value interface{}) error { 6568 if v == nil { 6569 return fmt.Errorf("unexpected nil of type %T", v) 6570 } 6571 if value == nil { 6572 return nil 6573 } 6574 6575 shape, ok := value.([]interface{}) 6576 if !ok { 6577 return fmt.Errorf("unexpected JSON type %v", value) 6578 } 6579 6580 var cv []types.PossibleRemediationAction 6581 if *v == nil { 6582 cv = []types.PossibleRemediationAction{} 6583 } else { 6584 cv = *v 6585 } 6586 6587 for _, value := range shape { 6588 var col types.PossibleRemediationAction 6589 destAddr := &col 6590 if err := awsAwsjson11_deserializeDocumentPossibleRemediationAction(&destAddr, value); err != nil { 6591 return err 6592 } 6593 col = *destAddr 6594 cv = append(cv, col) 6595 6596 } 6597 *v = cv 6598 return nil 6599} 6600 6601func awsAwsjson11_deserializeDocumentPossibleRemediationActions(v **types.PossibleRemediationActions, value interface{}) error { 6602 if v == nil { 6603 return fmt.Errorf("unexpected nil of type %T", v) 6604 } 6605 if value == nil { 6606 return nil 6607 } 6608 6609 shape, ok := value.(map[string]interface{}) 6610 if !ok { 6611 return fmt.Errorf("unexpected JSON type %v", value) 6612 } 6613 6614 var sv *types.PossibleRemediationActions 6615 if *v == nil { 6616 sv = &types.PossibleRemediationActions{} 6617 } else { 6618 sv = *v 6619 } 6620 6621 for key, value := range shape { 6622 switch key { 6623 case "Actions": 6624 if err := awsAwsjson11_deserializeDocumentPossibleRemediationActionList(&sv.Actions, value); err != nil { 6625 return err 6626 } 6627 6628 case "Description": 6629 if value != nil { 6630 jtv, ok := value.(string) 6631 if !ok { 6632 return fmt.Errorf("expected LengthBoundedString to be of type string, got %T instead", value) 6633 } 6634 sv.Description = ptr.String(jtv) 6635 } 6636 6637 default: 6638 _, _ = key, value 6639 6640 } 6641 } 6642 *v = sv 6643 return nil 6644} 6645 6646func awsAwsjson11_deserializeDocumentPreviousAppsList(v *map[string][]types.App, value interface{}) error { 6647 if v == nil { 6648 return fmt.Errorf("unexpected nil of type %T", v) 6649 } 6650 if value == nil { 6651 return nil 6652 } 6653 6654 shape, ok := value.(map[string]interface{}) 6655 if !ok { 6656 return fmt.Errorf("unexpected JSON type %v", value) 6657 } 6658 6659 var mv map[string][]types.App 6660 if *v == nil { 6661 mv = map[string][]types.App{} 6662 } else { 6663 mv = *v 6664 } 6665 6666 for key, value := range shape { 6667 var parsedVal []types.App 6668 mapVar := parsedVal 6669 if err := awsAwsjson11_deserializeDocumentAppsList(&mapVar, value); err != nil { 6670 return err 6671 } 6672 parsedVal = mapVar 6673 mv[key] = parsedVal 6674 6675 } 6676 *v = mv 6677 return nil 6678} 6679 6680func awsAwsjson11_deserializeDocumentPreviousProtocolsList(v *map[string][]string, value interface{}) error { 6681 if v == nil { 6682 return fmt.Errorf("unexpected nil of type %T", v) 6683 } 6684 if value == nil { 6685 return nil 6686 } 6687 6688 shape, ok := value.(map[string]interface{}) 6689 if !ok { 6690 return fmt.Errorf("unexpected JSON type %v", value) 6691 } 6692 6693 var mv map[string][]string 6694 if *v == nil { 6695 mv = map[string][]string{} 6696 } else { 6697 mv = *v 6698 } 6699 6700 for key, value := range shape { 6701 var parsedVal []string 6702 mapVar := parsedVal 6703 if err := awsAwsjson11_deserializeDocumentProtocolsList(&mapVar, value); err != nil { 6704 return err 6705 } 6706 parsedVal = mapVar 6707 mv[key] = parsedVal 6708 6709 } 6710 *v = mv 6711 return nil 6712} 6713 6714func awsAwsjson11_deserializeDocumentProtocolsList(v *[]string, value interface{}) error { 6715 if v == nil { 6716 return fmt.Errorf("unexpected nil of type %T", v) 6717 } 6718 if value == nil { 6719 return nil 6720 } 6721 6722 shape, ok := value.([]interface{}) 6723 if !ok { 6724 return fmt.Errorf("unexpected JSON type %v", value) 6725 } 6726 6727 var cv []string 6728 if *v == nil { 6729 cv = []string{} 6730 } else { 6731 cv = *v 6732 } 6733 6734 for _, value := range shape { 6735 var col string 6736 if value != nil { 6737 jtv, ok := value.(string) 6738 if !ok { 6739 return fmt.Errorf("expected Protocol to be of type string, got %T instead", value) 6740 } 6741 col = jtv 6742 } 6743 cv = append(cv, col) 6744 6745 } 6746 *v = cv 6747 return nil 6748} 6749 6750func awsAwsjson11_deserializeDocumentProtocolsListData(v **types.ProtocolsListData, value interface{}) error { 6751 if v == nil { 6752 return fmt.Errorf("unexpected nil of type %T", v) 6753 } 6754 if value == nil { 6755 return nil 6756 } 6757 6758 shape, ok := value.(map[string]interface{}) 6759 if !ok { 6760 return fmt.Errorf("unexpected JSON type %v", value) 6761 } 6762 6763 var sv *types.ProtocolsListData 6764 if *v == nil { 6765 sv = &types.ProtocolsListData{} 6766 } else { 6767 sv = *v 6768 } 6769 6770 for key, value := range shape { 6771 switch key { 6772 case "CreateTime": 6773 if value != nil { 6774 switch jtv := value.(type) { 6775 case json.Number: 6776 f64, err := jtv.Float64() 6777 if err != nil { 6778 return err 6779 } 6780 sv.CreateTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 6781 6782 default: 6783 return fmt.Errorf("expected TimeStamp to be a JSON Number, got %T instead", value) 6784 6785 } 6786 } 6787 6788 case "LastUpdateTime": 6789 if value != nil { 6790 switch jtv := value.(type) { 6791 case json.Number: 6792 f64, err := jtv.Float64() 6793 if err != nil { 6794 return err 6795 } 6796 sv.LastUpdateTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 6797 6798 default: 6799 return fmt.Errorf("expected TimeStamp to be a JSON Number, got %T instead", value) 6800 6801 } 6802 } 6803 6804 case "ListId": 6805 if value != nil { 6806 jtv, ok := value.(string) 6807 if !ok { 6808 return fmt.Errorf("expected ListId to be of type string, got %T instead", value) 6809 } 6810 sv.ListId = ptr.String(jtv) 6811 } 6812 6813 case "ListName": 6814 if value != nil { 6815 jtv, ok := value.(string) 6816 if !ok { 6817 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value) 6818 } 6819 sv.ListName = ptr.String(jtv) 6820 } 6821 6822 case "ListUpdateToken": 6823 if value != nil { 6824 jtv, ok := value.(string) 6825 if !ok { 6826 return fmt.Errorf("expected UpdateToken to be of type string, got %T instead", value) 6827 } 6828 sv.ListUpdateToken = ptr.String(jtv) 6829 } 6830 6831 case "PreviousProtocolsList": 6832 if err := awsAwsjson11_deserializeDocumentPreviousProtocolsList(&sv.PreviousProtocolsList, value); err != nil { 6833 return err 6834 } 6835 6836 case "ProtocolsList": 6837 if err := awsAwsjson11_deserializeDocumentProtocolsList(&sv.ProtocolsList, value); err != nil { 6838 return err 6839 } 6840 6841 default: 6842 _, _ = key, value 6843 6844 } 6845 } 6846 *v = sv 6847 return nil 6848} 6849 6850func awsAwsjson11_deserializeDocumentProtocolsListDataSummary(v **types.ProtocolsListDataSummary, value interface{}) error { 6851 if v == nil { 6852 return fmt.Errorf("unexpected nil of type %T", v) 6853 } 6854 if value == nil { 6855 return nil 6856 } 6857 6858 shape, ok := value.(map[string]interface{}) 6859 if !ok { 6860 return fmt.Errorf("unexpected JSON type %v", value) 6861 } 6862 6863 var sv *types.ProtocolsListDataSummary 6864 if *v == nil { 6865 sv = &types.ProtocolsListDataSummary{} 6866 } else { 6867 sv = *v 6868 } 6869 6870 for key, value := range shape { 6871 switch key { 6872 case "ListArn": 6873 if value != nil { 6874 jtv, ok := value.(string) 6875 if !ok { 6876 return fmt.Errorf("expected ResourceArn to be of type string, got %T instead", value) 6877 } 6878 sv.ListArn = ptr.String(jtv) 6879 } 6880 6881 case "ListId": 6882 if value != nil { 6883 jtv, ok := value.(string) 6884 if !ok { 6885 return fmt.Errorf("expected ListId to be of type string, got %T instead", value) 6886 } 6887 sv.ListId = ptr.String(jtv) 6888 } 6889 6890 case "ListName": 6891 if value != nil { 6892 jtv, ok := value.(string) 6893 if !ok { 6894 return fmt.Errorf("expected ResourceName to be of type string, got %T instead", value) 6895 } 6896 sv.ListName = ptr.String(jtv) 6897 } 6898 6899 case "ProtocolsList": 6900 if err := awsAwsjson11_deserializeDocumentProtocolsList(&sv.ProtocolsList, value); err != nil { 6901 return err 6902 } 6903 6904 default: 6905 _, _ = key, value 6906 6907 } 6908 } 6909 *v = sv 6910 return nil 6911} 6912 6913func awsAwsjson11_deserializeDocumentProtocolsListsData(v *[]types.ProtocolsListDataSummary, value interface{}) error { 6914 if v == nil { 6915 return fmt.Errorf("unexpected nil of type %T", v) 6916 } 6917 if value == nil { 6918 return nil 6919 } 6920 6921 shape, ok := value.([]interface{}) 6922 if !ok { 6923 return fmt.Errorf("unexpected JSON type %v", value) 6924 } 6925 6926 var cv []types.ProtocolsListDataSummary 6927 if *v == nil { 6928 cv = []types.ProtocolsListDataSummary{} 6929 } else { 6930 cv = *v 6931 } 6932 6933 for _, value := range shape { 6934 var col types.ProtocolsListDataSummary 6935 destAddr := &col 6936 if err := awsAwsjson11_deserializeDocumentProtocolsListDataSummary(&destAddr, value); err != nil { 6937 return err 6938 } 6939 col = *destAddr 6940 cv = append(cv, col) 6941 6942 } 6943 *v = cv 6944 return nil 6945} 6946 6947func awsAwsjson11_deserializeDocumentRemediationAction(v **types.RemediationAction, value interface{}) error { 6948 if v == nil { 6949 return fmt.Errorf("unexpected nil of type %T", v) 6950 } 6951 if value == nil { 6952 return nil 6953 } 6954 6955 shape, ok := value.(map[string]interface{}) 6956 if !ok { 6957 return fmt.Errorf("unexpected JSON type %v", value) 6958 } 6959 6960 var sv *types.RemediationAction 6961 if *v == nil { 6962 sv = &types.RemediationAction{} 6963 } else { 6964 sv = *v 6965 } 6966 6967 for key, value := range shape { 6968 switch key { 6969 case "Description": 6970 if value != nil { 6971 jtv, ok := value.(string) 6972 if !ok { 6973 return fmt.Errorf("expected LengthBoundedString to be of type string, got %T instead", value) 6974 } 6975 sv.Description = ptr.String(jtv) 6976 } 6977 6978 case "EC2AssociateRouteTableAction": 6979 if err := awsAwsjson11_deserializeDocumentEC2AssociateRouteTableAction(&sv.EC2AssociateRouteTableAction, value); err != nil { 6980 return err 6981 } 6982 6983 case "EC2CopyRouteTableAction": 6984 if err := awsAwsjson11_deserializeDocumentEC2CopyRouteTableAction(&sv.EC2CopyRouteTableAction, value); err != nil { 6985 return err 6986 } 6987 6988 case "EC2CreateRouteAction": 6989 if err := awsAwsjson11_deserializeDocumentEC2CreateRouteAction(&sv.EC2CreateRouteAction, value); err != nil { 6990 return err 6991 } 6992 6993 case "EC2CreateRouteTableAction": 6994 if err := awsAwsjson11_deserializeDocumentEC2CreateRouteTableAction(&sv.EC2CreateRouteTableAction, value); err != nil { 6995 return err 6996 } 6997 6998 case "EC2DeleteRouteAction": 6999 if err := awsAwsjson11_deserializeDocumentEC2DeleteRouteAction(&sv.EC2DeleteRouteAction, value); err != nil { 7000 return err 7001 } 7002 7003 case "EC2ReplaceRouteAction": 7004 if err := awsAwsjson11_deserializeDocumentEC2ReplaceRouteAction(&sv.EC2ReplaceRouteAction, value); err != nil { 7005 return err 7006 } 7007 7008 case "EC2ReplaceRouteTableAssociationAction": 7009 if err := awsAwsjson11_deserializeDocumentEC2ReplaceRouteTableAssociationAction(&sv.EC2ReplaceRouteTableAssociationAction, value); err != nil { 7010 return err 7011 } 7012 7013 default: 7014 _, _ = key, value 7015 7016 } 7017 } 7018 *v = sv 7019 return nil 7020} 7021 7022func awsAwsjson11_deserializeDocumentRemediationActionWithOrder(v **types.RemediationActionWithOrder, value interface{}) error { 7023 if v == nil { 7024 return fmt.Errorf("unexpected nil of type %T", v) 7025 } 7026 if value == nil { 7027 return nil 7028 } 7029 7030 shape, ok := value.(map[string]interface{}) 7031 if !ok { 7032 return fmt.Errorf("unexpected JSON type %v", value) 7033 } 7034 7035 var sv *types.RemediationActionWithOrder 7036 if *v == nil { 7037 sv = &types.RemediationActionWithOrder{} 7038 } else { 7039 sv = *v 7040 } 7041 7042 for key, value := range shape { 7043 switch key { 7044 case "Order": 7045 if value != nil { 7046 jtv, ok := value.(json.Number) 7047 if !ok { 7048 return fmt.Errorf("expected BasicInteger to be json.Number, got %T instead", value) 7049 } 7050 i64, err := jtv.Int64() 7051 if err != nil { 7052 return err 7053 } 7054 sv.Order = int32(i64) 7055 } 7056 7057 case "RemediationAction": 7058 if err := awsAwsjson11_deserializeDocumentRemediationAction(&sv.RemediationAction, value); err != nil { 7059 return err 7060 } 7061 7062 default: 7063 _, _ = key, value 7064 7065 } 7066 } 7067 *v = sv 7068 return nil 7069} 7070 7071func awsAwsjson11_deserializeDocumentResourceIdList(v *[]string, value interface{}) error { 7072 if v == nil { 7073 return fmt.Errorf("unexpected nil of type %T", v) 7074 } 7075 if value == nil { 7076 return nil 7077 } 7078 7079 shape, ok := value.([]interface{}) 7080 if !ok { 7081 return fmt.Errorf("unexpected JSON type %v", value) 7082 } 7083 7084 var cv []string 7085 if *v == nil { 7086 cv = []string{} 7087 } else { 7088 cv = *v 7089 } 7090 7091 for _, value := range shape { 7092 var col string 7093 if value != nil { 7094 jtv, ok := value.(string) 7095 if !ok { 7096 return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value) 7097 } 7098 col = jtv 7099 } 7100 cv = append(cv, col) 7101 7102 } 7103 *v = cv 7104 return nil 7105} 7106 7107func awsAwsjson11_deserializeDocumentResourceNotFoundException(v **types.ResourceNotFoundException, value interface{}) error { 7108 if v == nil { 7109 return fmt.Errorf("unexpected nil of type %T", v) 7110 } 7111 if value == nil { 7112 return nil 7113 } 7114 7115 shape, ok := value.(map[string]interface{}) 7116 if !ok { 7117 return fmt.Errorf("unexpected JSON type %v", value) 7118 } 7119 7120 var sv *types.ResourceNotFoundException 7121 if *v == nil { 7122 sv = &types.ResourceNotFoundException{} 7123 } else { 7124 sv = *v 7125 } 7126 7127 for key, value := range shape { 7128 switch key { 7129 case "Message": 7130 if value != nil { 7131 jtv, ok := value.(string) 7132 if !ok { 7133 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 7134 } 7135 sv.Message = ptr.String(jtv) 7136 } 7137 7138 default: 7139 _, _ = key, value 7140 7141 } 7142 } 7143 *v = sv 7144 return nil 7145} 7146 7147func awsAwsjson11_deserializeDocumentResourceTag(v **types.ResourceTag, value interface{}) error { 7148 if v == nil { 7149 return fmt.Errorf("unexpected nil of type %T", v) 7150 } 7151 if value == nil { 7152 return nil 7153 } 7154 7155 shape, ok := value.(map[string]interface{}) 7156 if !ok { 7157 return fmt.Errorf("unexpected JSON type %v", value) 7158 } 7159 7160 var sv *types.ResourceTag 7161 if *v == nil { 7162 sv = &types.ResourceTag{} 7163 } else { 7164 sv = *v 7165 } 7166 7167 for key, value := range shape { 7168 switch key { 7169 case "Key": 7170 if value != nil { 7171 jtv, ok := value.(string) 7172 if !ok { 7173 return fmt.Errorf("expected ResourceTagKey to be of type string, got %T instead", value) 7174 } 7175 sv.Key = ptr.String(jtv) 7176 } 7177 7178 case "Value": 7179 if value != nil { 7180 jtv, ok := value.(string) 7181 if !ok { 7182 return fmt.Errorf("expected ResourceTagValue to be of type string, got %T instead", value) 7183 } 7184 sv.Value = ptr.String(jtv) 7185 } 7186 7187 default: 7188 _, _ = key, value 7189 7190 } 7191 } 7192 *v = sv 7193 return nil 7194} 7195 7196func awsAwsjson11_deserializeDocumentResourceTags(v *[]types.ResourceTag, value interface{}) error { 7197 if v == nil { 7198 return fmt.Errorf("unexpected nil of type %T", v) 7199 } 7200 if value == nil { 7201 return nil 7202 } 7203 7204 shape, ok := value.([]interface{}) 7205 if !ok { 7206 return fmt.Errorf("unexpected JSON type %v", value) 7207 } 7208 7209 var cv []types.ResourceTag 7210 if *v == nil { 7211 cv = []types.ResourceTag{} 7212 } else { 7213 cv = *v 7214 } 7215 7216 for _, value := range shape { 7217 var col types.ResourceTag 7218 destAddr := &col 7219 if err := awsAwsjson11_deserializeDocumentResourceTag(&destAddr, value); err != nil { 7220 return err 7221 } 7222 col = *destAddr 7223 cv = append(cv, col) 7224 7225 } 7226 *v = cv 7227 return nil 7228} 7229 7230func awsAwsjson11_deserializeDocumentResourceTypeList(v *[]string, value interface{}) error { 7231 if v == nil { 7232 return fmt.Errorf("unexpected nil of type %T", v) 7233 } 7234 if value == nil { 7235 return nil 7236 } 7237 7238 shape, ok := value.([]interface{}) 7239 if !ok { 7240 return fmt.Errorf("unexpected JSON type %v", value) 7241 } 7242 7243 var cv []string 7244 if *v == nil { 7245 cv = []string{} 7246 } else { 7247 cv = *v 7248 } 7249 7250 for _, value := range shape { 7251 var col string 7252 if value != nil { 7253 jtv, ok := value.(string) 7254 if !ok { 7255 return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value) 7256 } 7257 col = jtv 7258 } 7259 cv = append(cv, col) 7260 7261 } 7262 *v = cv 7263 return nil 7264} 7265 7266func awsAwsjson11_deserializeDocumentResourceViolation(v **types.ResourceViolation, value interface{}) error { 7267 if v == nil { 7268 return fmt.Errorf("unexpected nil of type %T", v) 7269 } 7270 if value == nil { 7271 return nil 7272 } 7273 7274 shape, ok := value.(map[string]interface{}) 7275 if !ok { 7276 return fmt.Errorf("unexpected JSON type %v", value) 7277 } 7278 7279 var sv *types.ResourceViolation 7280 if *v == nil { 7281 sv = &types.ResourceViolation{} 7282 } else { 7283 sv = *v 7284 } 7285 7286 for key, value := range shape { 7287 switch key { 7288 case "AwsEc2InstanceViolation": 7289 if err := awsAwsjson11_deserializeDocumentAwsEc2InstanceViolation(&sv.AwsEc2InstanceViolation, value); err != nil { 7290 return err 7291 } 7292 7293 case "AwsEc2NetworkInterfaceViolation": 7294 if err := awsAwsjson11_deserializeDocumentAwsEc2NetworkInterfaceViolation(&sv.AwsEc2NetworkInterfaceViolation, value); err != nil { 7295 return err 7296 } 7297 7298 case "AwsVPCSecurityGroupViolation": 7299 if err := awsAwsjson11_deserializeDocumentAwsVPCSecurityGroupViolation(&sv.AwsVPCSecurityGroupViolation, value); err != nil { 7300 return err 7301 } 7302 7303 case "DnsDuplicateRuleGroupViolation": 7304 if err := awsAwsjson11_deserializeDocumentDnsDuplicateRuleGroupViolation(&sv.DnsDuplicateRuleGroupViolation, value); err != nil { 7305 return err 7306 } 7307 7308 case "DnsRuleGroupLimitExceededViolation": 7309 if err := awsAwsjson11_deserializeDocumentDnsRuleGroupLimitExceededViolation(&sv.DnsRuleGroupLimitExceededViolation, value); err != nil { 7310 return err 7311 } 7312 7313 case "DnsRuleGroupPriorityConflictViolation": 7314 if err := awsAwsjson11_deserializeDocumentDnsRuleGroupPriorityConflictViolation(&sv.DnsRuleGroupPriorityConflictViolation, value); err != nil { 7315 return err 7316 } 7317 7318 case "NetworkFirewallBlackHoleRouteDetectedViolation": 7319 if err := awsAwsjson11_deserializeDocumentNetworkFirewallBlackHoleRouteDetectedViolation(&sv.NetworkFirewallBlackHoleRouteDetectedViolation, value); err != nil { 7320 return err 7321 } 7322 7323 case "NetworkFirewallInternetTrafficNotInspectedViolation": 7324 if err := awsAwsjson11_deserializeDocumentNetworkFirewallInternetTrafficNotInspectedViolation(&sv.NetworkFirewallInternetTrafficNotInspectedViolation, value); err != nil { 7325 return err 7326 } 7327 7328 case "NetworkFirewallInvalidRouteConfigurationViolation": 7329 if err := awsAwsjson11_deserializeDocumentNetworkFirewallInvalidRouteConfigurationViolation(&sv.NetworkFirewallInvalidRouteConfigurationViolation, value); err != nil { 7330 return err 7331 } 7332 7333 case "NetworkFirewallMissingExpectedRoutesViolation": 7334 if err := awsAwsjson11_deserializeDocumentNetworkFirewallMissingExpectedRoutesViolation(&sv.NetworkFirewallMissingExpectedRoutesViolation, value); err != nil { 7335 return err 7336 } 7337 7338 case "NetworkFirewallMissingExpectedRTViolation": 7339 if err := awsAwsjson11_deserializeDocumentNetworkFirewallMissingExpectedRTViolation(&sv.NetworkFirewallMissingExpectedRTViolation, value); err != nil { 7340 return err 7341 } 7342 7343 case "NetworkFirewallMissingFirewallViolation": 7344 if err := awsAwsjson11_deserializeDocumentNetworkFirewallMissingFirewallViolation(&sv.NetworkFirewallMissingFirewallViolation, value); err != nil { 7345 return err 7346 } 7347 7348 case "NetworkFirewallMissingSubnetViolation": 7349 if err := awsAwsjson11_deserializeDocumentNetworkFirewallMissingSubnetViolation(&sv.NetworkFirewallMissingSubnetViolation, value); err != nil { 7350 return err 7351 } 7352 7353 case "NetworkFirewallPolicyModifiedViolation": 7354 if err := awsAwsjson11_deserializeDocumentNetworkFirewallPolicyModifiedViolation(&sv.NetworkFirewallPolicyModifiedViolation, value); err != nil { 7355 return err 7356 } 7357 7358 case "NetworkFirewallUnexpectedFirewallRoutesViolation": 7359 if err := awsAwsjson11_deserializeDocumentNetworkFirewallUnexpectedFirewallRoutesViolation(&sv.NetworkFirewallUnexpectedFirewallRoutesViolation, value); err != nil { 7360 return err 7361 } 7362 7363 case "NetworkFirewallUnexpectedGatewayRoutesViolation": 7364 if err := awsAwsjson11_deserializeDocumentNetworkFirewallUnexpectedGatewayRoutesViolation(&sv.NetworkFirewallUnexpectedGatewayRoutesViolation, value); err != nil { 7365 return err 7366 } 7367 7368 case "PossibleRemediationActions": 7369 if err := awsAwsjson11_deserializeDocumentPossibleRemediationActions(&sv.PossibleRemediationActions, value); err != nil { 7370 return err 7371 } 7372 7373 default: 7374 _, _ = key, value 7375 7376 } 7377 } 7378 *v = sv 7379 return nil 7380} 7381 7382func awsAwsjson11_deserializeDocumentResourceViolations(v *[]types.ResourceViolation, value interface{}) error { 7383 if v == nil { 7384 return fmt.Errorf("unexpected nil of type %T", v) 7385 } 7386 if value == nil { 7387 return nil 7388 } 7389 7390 shape, ok := value.([]interface{}) 7391 if !ok { 7392 return fmt.Errorf("unexpected JSON type %v", value) 7393 } 7394 7395 var cv []types.ResourceViolation 7396 if *v == nil { 7397 cv = []types.ResourceViolation{} 7398 } else { 7399 cv = *v 7400 } 7401 7402 for _, value := range shape { 7403 var col types.ResourceViolation 7404 destAddr := &col 7405 if err := awsAwsjson11_deserializeDocumentResourceViolation(&destAddr, value); err != nil { 7406 return err 7407 } 7408 col = *destAddr 7409 cv = append(cv, col) 7410 7411 } 7412 *v = cv 7413 return nil 7414} 7415 7416func awsAwsjson11_deserializeDocumentRoute(v **types.Route, value interface{}) error { 7417 if v == nil { 7418 return fmt.Errorf("unexpected nil of type %T", v) 7419 } 7420 if value == nil { 7421 return nil 7422 } 7423 7424 shape, ok := value.(map[string]interface{}) 7425 if !ok { 7426 return fmt.Errorf("unexpected JSON type %v", value) 7427 } 7428 7429 var sv *types.Route 7430 if *v == nil { 7431 sv = &types.Route{} 7432 } else { 7433 sv = *v 7434 } 7435 7436 for key, value := range shape { 7437 switch key { 7438 case "Destination": 7439 if value != nil { 7440 jtv, ok := value.(string) 7441 if !ok { 7442 return fmt.Errorf("expected LengthBoundedString to be of type string, got %T instead", value) 7443 } 7444 sv.Destination = ptr.String(jtv) 7445 } 7446 7447 case "DestinationType": 7448 if value != nil { 7449 jtv, ok := value.(string) 7450 if !ok { 7451 return fmt.Errorf("expected DestinationType to be of type string, got %T instead", value) 7452 } 7453 sv.DestinationType = types.DestinationType(jtv) 7454 } 7455 7456 case "Target": 7457 if value != nil { 7458 jtv, ok := value.(string) 7459 if !ok { 7460 return fmt.Errorf("expected LengthBoundedString to be of type string, got %T instead", value) 7461 } 7462 sv.Target = ptr.String(jtv) 7463 } 7464 7465 case "TargetType": 7466 if value != nil { 7467 jtv, ok := value.(string) 7468 if !ok { 7469 return fmt.Errorf("expected TargetType to be of type string, got %T instead", value) 7470 } 7471 sv.TargetType = types.TargetType(jtv) 7472 } 7473 7474 default: 7475 _, _ = key, value 7476 7477 } 7478 } 7479 *v = sv 7480 return nil 7481} 7482 7483func awsAwsjson11_deserializeDocumentRoutes(v *[]types.Route, value interface{}) error { 7484 if v == nil { 7485 return fmt.Errorf("unexpected nil of type %T", v) 7486 } 7487 if value == nil { 7488 return nil 7489 } 7490 7491 shape, ok := value.([]interface{}) 7492 if !ok { 7493 return fmt.Errorf("unexpected JSON type %v", value) 7494 } 7495 7496 var cv []types.Route 7497 if *v == nil { 7498 cv = []types.Route{} 7499 } else { 7500 cv = *v 7501 } 7502 7503 for _, value := range shape { 7504 var col types.Route 7505 destAddr := &col 7506 if err := awsAwsjson11_deserializeDocumentRoute(&destAddr, value); err != nil { 7507 return err 7508 } 7509 col = *destAddr 7510 cv = append(cv, col) 7511 7512 } 7513 *v = cv 7514 return nil 7515} 7516 7517func awsAwsjson11_deserializeDocumentSecurityGroupRemediationAction(v **types.SecurityGroupRemediationAction, value interface{}) error { 7518 if v == nil { 7519 return fmt.Errorf("unexpected nil of type %T", v) 7520 } 7521 if value == nil { 7522 return nil 7523 } 7524 7525 shape, ok := value.(map[string]interface{}) 7526 if !ok { 7527 return fmt.Errorf("unexpected JSON type %v", value) 7528 } 7529 7530 var sv *types.SecurityGroupRemediationAction 7531 if *v == nil { 7532 sv = &types.SecurityGroupRemediationAction{} 7533 } else { 7534 sv = *v 7535 } 7536 7537 for key, value := range shape { 7538 switch key { 7539 case "Description": 7540 if value != nil { 7541 jtv, ok := value.(string) 7542 if !ok { 7543 return fmt.Errorf("expected RemediationActionDescription to be of type string, got %T instead", value) 7544 } 7545 sv.Description = ptr.String(jtv) 7546 } 7547 7548 case "IsDefaultAction": 7549 if value != nil { 7550 jtv, ok := value.(bool) 7551 if !ok { 7552 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 7553 } 7554 sv.IsDefaultAction = jtv 7555 } 7556 7557 case "RemediationActionType": 7558 if value != nil { 7559 jtv, ok := value.(string) 7560 if !ok { 7561 return fmt.Errorf("expected RemediationActionType to be of type string, got %T instead", value) 7562 } 7563 sv.RemediationActionType = types.RemediationActionType(jtv) 7564 } 7565 7566 case "RemediationResult": 7567 if err := awsAwsjson11_deserializeDocumentSecurityGroupRuleDescription(&sv.RemediationResult, value); err != nil { 7568 return err 7569 } 7570 7571 default: 7572 _, _ = key, value 7573 7574 } 7575 } 7576 *v = sv 7577 return nil 7578} 7579 7580func awsAwsjson11_deserializeDocumentSecurityGroupRemediationActions(v *[]types.SecurityGroupRemediationAction, value interface{}) error { 7581 if v == nil { 7582 return fmt.Errorf("unexpected nil of type %T", v) 7583 } 7584 if value == nil { 7585 return nil 7586 } 7587 7588 shape, ok := value.([]interface{}) 7589 if !ok { 7590 return fmt.Errorf("unexpected JSON type %v", value) 7591 } 7592 7593 var cv []types.SecurityGroupRemediationAction 7594 if *v == nil { 7595 cv = []types.SecurityGroupRemediationAction{} 7596 } else { 7597 cv = *v 7598 } 7599 7600 for _, value := range shape { 7601 var col types.SecurityGroupRemediationAction 7602 destAddr := &col 7603 if err := awsAwsjson11_deserializeDocumentSecurityGroupRemediationAction(&destAddr, value); err != nil { 7604 return err 7605 } 7606 col = *destAddr 7607 cv = append(cv, col) 7608 7609 } 7610 *v = cv 7611 return nil 7612} 7613 7614func awsAwsjson11_deserializeDocumentSecurityGroupRuleDescription(v **types.SecurityGroupRuleDescription, value interface{}) error { 7615 if v == nil { 7616 return fmt.Errorf("unexpected nil of type %T", v) 7617 } 7618 if value == nil { 7619 return nil 7620 } 7621 7622 shape, ok := value.(map[string]interface{}) 7623 if !ok { 7624 return fmt.Errorf("unexpected JSON type %v", value) 7625 } 7626 7627 var sv *types.SecurityGroupRuleDescription 7628 if *v == nil { 7629 sv = &types.SecurityGroupRuleDescription{} 7630 } else { 7631 sv = *v 7632 } 7633 7634 for key, value := range shape { 7635 switch key { 7636 case "FromPort": 7637 if value != nil { 7638 jtv, ok := value.(json.Number) 7639 if !ok { 7640 return fmt.Errorf("expected IPPortNumber to be json.Number, got %T instead", value) 7641 } 7642 i64, err := jtv.Int64() 7643 if err != nil { 7644 return err 7645 } 7646 sv.FromPort = ptr.Int64(i64) 7647 } 7648 7649 case "IPV4Range": 7650 if value != nil { 7651 jtv, ok := value.(string) 7652 if !ok { 7653 return fmt.Errorf("expected CIDR to be of type string, got %T instead", value) 7654 } 7655 sv.IPV4Range = ptr.String(jtv) 7656 } 7657 7658 case "IPV6Range": 7659 if value != nil { 7660 jtv, ok := value.(string) 7661 if !ok { 7662 return fmt.Errorf("expected CIDR to be of type string, got %T instead", value) 7663 } 7664 sv.IPV6Range = ptr.String(jtv) 7665 } 7666 7667 case "PrefixListId": 7668 if value != nil { 7669 jtv, ok := value.(string) 7670 if !ok { 7671 return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value) 7672 } 7673 sv.PrefixListId = ptr.String(jtv) 7674 } 7675 7676 case "Protocol": 7677 if value != nil { 7678 jtv, ok := value.(string) 7679 if !ok { 7680 return fmt.Errorf("expected LengthBoundedString to be of type string, got %T instead", value) 7681 } 7682 sv.Protocol = ptr.String(jtv) 7683 } 7684 7685 case "ToPort": 7686 if value != nil { 7687 jtv, ok := value.(json.Number) 7688 if !ok { 7689 return fmt.Errorf("expected IPPortNumber to be json.Number, got %T instead", value) 7690 } 7691 i64, err := jtv.Int64() 7692 if err != nil { 7693 return err 7694 } 7695 sv.ToPort = ptr.Int64(i64) 7696 } 7697 7698 default: 7699 _, _ = key, value 7700 7701 } 7702 } 7703 *v = sv 7704 return nil 7705} 7706 7707func awsAwsjson11_deserializeDocumentSecurityServicePolicyData(v **types.SecurityServicePolicyData, value interface{}) error { 7708 if v == nil { 7709 return fmt.Errorf("unexpected nil of type %T", v) 7710 } 7711 if value == nil { 7712 return nil 7713 } 7714 7715 shape, ok := value.(map[string]interface{}) 7716 if !ok { 7717 return fmt.Errorf("unexpected JSON type %v", value) 7718 } 7719 7720 var sv *types.SecurityServicePolicyData 7721 if *v == nil { 7722 sv = &types.SecurityServicePolicyData{} 7723 } else { 7724 sv = *v 7725 } 7726 7727 for key, value := range shape { 7728 switch key { 7729 case "ManagedServiceData": 7730 if value != nil { 7731 jtv, ok := value.(string) 7732 if !ok { 7733 return fmt.Errorf("expected ManagedServiceData to be of type string, got %T instead", value) 7734 } 7735 sv.ManagedServiceData = ptr.String(jtv) 7736 } 7737 7738 case "Type": 7739 if value != nil { 7740 jtv, ok := value.(string) 7741 if !ok { 7742 return fmt.Errorf("expected SecurityServiceType to be of type string, got %T instead", value) 7743 } 7744 sv.Type = types.SecurityServiceType(jtv) 7745 } 7746 7747 default: 7748 _, _ = key, value 7749 7750 } 7751 } 7752 *v = sv 7753 return nil 7754} 7755 7756func awsAwsjson11_deserializeDocumentStatefulRuleGroup(v **types.StatefulRuleGroup, value interface{}) error { 7757 if v == nil { 7758 return fmt.Errorf("unexpected nil of type %T", v) 7759 } 7760 if value == nil { 7761 return nil 7762 } 7763 7764 shape, ok := value.(map[string]interface{}) 7765 if !ok { 7766 return fmt.Errorf("unexpected JSON type %v", value) 7767 } 7768 7769 var sv *types.StatefulRuleGroup 7770 if *v == nil { 7771 sv = &types.StatefulRuleGroup{} 7772 } else { 7773 sv = *v 7774 } 7775 7776 for key, value := range shape { 7777 switch key { 7778 case "ResourceId": 7779 if value != nil { 7780 jtv, ok := value.(string) 7781 if !ok { 7782 return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value) 7783 } 7784 sv.ResourceId = ptr.String(jtv) 7785 } 7786 7787 case "RuleGroupName": 7788 if value != nil { 7789 jtv, ok := value.(string) 7790 if !ok { 7791 return fmt.Errorf("expected NetworkFirewallResourceName to be of type string, got %T instead", value) 7792 } 7793 sv.RuleGroupName = ptr.String(jtv) 7794 } 7795 7796 default: 7797 _, _ = key, value 7798 7799 } 7800 } 7801 *v = sv 7802 return nil 7803} 7804 7805func awsAwsjson11_deserializeDocumentStatefulRuleGroupList(v *[]types.StatefulRuleGroup, value interface{}) error { 7806 if v == nil { 7807 return fmt.Errorf("unexpected nil of type %T", v) 7808 } 7809 if value == nil { 7810 return nil 7811 } 7812 7813 shape, ok := value.([]interface{}) 7814 if !ok { 7815 return fmt.Errorf("unexpected JSON type %v", value) 7816 } 7817 7818 var cv []types.StatefulRuleGroup 7819 if *v == nil { 7820 cv = []types.StatefulRuleGroup{} 7821 } else { 7822 cv = *v 7823 } 7824 7825 for _, value := range shape { 7826 var col types.StatefulRuleGroup 7827 destAddr := &col 7828 if err := awsAwsjson11_deserializeDocumentStatefulRuleGroup(&destAddr, value); err != nil { 7829 return err 7830 } 7831 col = *destAddr 7832 cv = append(cv, col) 7833 7834 } 7835 *v = cv 7836 return nil 7837} 7838 7839func awsAwsjson11_deserializeDocumentStatelessRuleGroup(v **types.StatelessRuleGroup, value interface{}) error { 7840 if v == nil { 7841 return fmt.Errorf("unexpected nil of type %T", v) 7842 } 7843 if value == nil { 7844 return nil 7845 } 7846 7847 shape, ok := value.(map[string]interface{}) 7848 if !ok { 7849 return fmt.Errorf("unexpected JSON type %v", value) 7850 } 7851 7852 var sv *types.StatelessRuleGroup 7853 if *v == nil { 7854 sv = &types.StatelessRuleGroup{} 7855 } else { 7856 sv = *v 7857 } 7858 7859 for key, value := range shape { 7860 switch key { 7861 case "Priority": 7862 if value != nil { 7863 jtv, ok := value.(json.Number) 7864 if !ok { 7865 return fmt.Errorf("expected StatelessRuleGroupPriority to be json.Number, got %T instead", value) 7866 } 7867 i64, err := jtv.Int64() 7868 if err != nil { 7869 return err 7870 } 7871 sv.Priority = int32(i64) 7872 } 7873 7874 case "ResourceId": 7875 if value != nil { 7876 jtv, ok := value.(string) 7877 if !ok { 7878 return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value) 7879 } 7880 sv.ResourceId = ptr.String(jtv) 7881 } 7882 7883 case "RuleGroupName": 7884 if value != nil { 7885 jtv, ok := value.(string) 7886 if !ok { 7887 return fmt.Errorf("expected NetworkFirewallResourceName to be of type string, got %T instead", value) 7888 } 7889 sv.RuleGroupName = ptr.String(jtv) 7890 } 7891 7892 default: 7893 _, _ = key, value 7894 7895 } 7896 } 7897 *v = sv 7898 return nil 7899} 7900 7901func awsAwsjson11_deserializeDocumentStatelessRuleGroupList(v *[]types.StatelessRuleGroup, value interface{}) error { 7902 if v == nil { 7903 return fmt.Errorf("unexpected nil of type %T", v) 7904 } 7905 if value == nil { 7906 return nil 7907 } 7908 7909 shape, ok := value.([]interface{}) 7910 if !ok { 7911 return fmt.Errorf("unexpected JSON type %v", value) 7912 } 7913 7914 var cv []types.StatelessRuleGroup 7915 if *v == nil { 7916 cv = []types.StatelessRuleGroup{} 7917 } else { 7918 cv = *v 7919 } 7920 7921 for _, value := range shape { 7922 var col types.StatelessRuleGroup 7923 destAddr := &col 7924 if err := awsAwsjson11_deserializeDocumentStatelessRuleGroup(&destAddr, value); err != nil { 7925 return err 7926 } 7927 col = *destAddr 7928 cv = append(cv, col) 7929 7930 } 7931 *v = cv 7932 return nil 7933} 7934 7935func awsAwsjson11_deserializeDocumentTag(v **types.Tag, value interface{}) error { 7936 if v == nil { 7937 return fmt.Errorf("unexpected nil of type %T", v) 7938 } 7939 if value == nil { 7940 return nil 7941 } 7942 7943 shape, ok := value.(map[string]interface{}) 7944 if !ok { 7945 return fmt.Errorf("unexpected JSON type %v", value) 7946 } 7947 7948 var sv *types.Tag 7949 if *v == nil { 7950 sv = &types.Tag{} 7951 } else { 7952 sv = *v 7953 } 7954 7955 for key, value := range shape { 7956 switch key { 7957 case "Key": 7958 if value != nil { 7959 jtv, ok := value.(string) 7960 if !ok { 7961 return fmt.Errorf("expected TagKey to be of type string, got %T instead", value) 7962 } 7963 sv.Key = ptr.String(jtv) 7964 } 7965 7966 case "Value": 7967 if value != nil { 7968 jtv, ok := value.(string) 7969 if !ok { 7970 return fmt.Errorf("expected TagValue to be of type string, got %T instead", value) 7971 } 7972 sv.Value = ptr.String(jtv) 7973 } 7974 7975 default: 7976 _, _ = key, value 7977 7978 } 7979 } 7980 *v = sv 7981 return nil 7982} 7983 7984func awsAwsjson11_deserializeDocumentTagList(v *[]types.Tag, value interface{}) error { 7985 if v == nil { 7986 return fmt.Errorf("unexpected nil of type %T", v) 7987 } 7988 if value == nil { 7989 return nil 7990 } 7991 7992 shape, ok := value.([]interface{}) 7993 if !ok { 7994 return fmt.Errorf("unexpected JSON type %v", value) 7995 } 7996 7997 var cv []types.Tag 7998 if *v == nil { 7999 cv = []types.Tag{} 8000 } else { 8001 cv = *v 8002 } 8003 8004 for _, value := range shape { 8005 var col types.Tag 8006 destAddr := &col 8007 if err := awsAwsjson11_deserializeDocumentTag(&destAddr, value); err != nil { 8008 return err 8009 } 8010 col = *destAddr 8011 cv = append(cv, col) 8012 8013 } 8014 *v = cv 8015 return nil 8016} 8017 8018func awsAwsjson11_deserializeDocumentTargetViolationReasons(v *[]string, value interface{}) error { 8019 if v == nil { 8020 return fmt.Errorf("unexpected nil of type %T", v) 8021 } 8022 if value == nil { 8023 return nil 8024 } 8025 8026 shape, ok := value.([]interface{}) 8027 if !ok { 8028 return fmt.Errorf("unexpected JSON type %v", value) 8029 } 8030 8031 var cv []string 8032 if *v == nil { 8033 cv = []string{} 8034 } else { 8035 cv = *v 8036 } 8037 8038 for _, value := range shape { 8039 var col string 8040 if value != nil { 8041 jtv, ok := value.(string) 8042 if !ok { 8043 return fmt.Errorf("expected TargetViolationReason to be of type string, got %T instead", value) 8044 } 8045 col = jtv 8046 } 8047 cv = append(cv, col) 8048 8049 } 8050 *v = cv 8051 return nil 8052} 8053 8054func awsAwsjson11_deserializeDocumentViolationDetail(v **types.ViolationDetail, value interface{}) error { 8055 if v == nil { 8056 return fmt.Errorf("unexpected nil of type %T", v) 8057 } 8058 if value == nil { 8059 return nil 8060 } 8061 8062 shape, ok := value.(map[string]interface{}) 8063 if !ok { 8064 return fmt.Errorf("unexpected JSON type %v", value) 8065 } 8066 8067 var sv *types.ViolationDetail 8068 if *v == nil { 8069 sv = &types.ViolationDetail{} 8070 } else { 8071 sv = *v 8072 } 8073 8074 for key, value := range shape { 8075 switch key { 8076 case "MemberAccount": 8077 if value != nil { 8078 jtv, ok := value.(string) 8079 if !ok { 8080 return fmt.Errorf("expected AWSAccountId to be of type string, got %T instead", value) 8081 } 8082 sv.MemberAccount = ptr.String(jtv) 8083 } 8084 8085 case "PolicyId": 8086 if value != nil { 8087 jtv, ok := value.(string) 8088 if !ok { 8089 return fmt.Errorf("expected PolicyId to be of type string, got %T instead", value) 8090 } 8091 sv.PolicyId = ptr.String(jtv) 8092 } 8093 8094 case "ResourceDescription": 8095 if value != nil { 8096 jtv, ok := value.(string) 8097 if !ok { 8098 return fmt.Errorf("expected LengthBoundedString to be of type string, got %T instead", value) 8099 } 8100 sv.ResourceDescription = ptr.String(jtv) 8101 } 8102 8103 case "ResourceId": 8104 if value != nil { 8105 jtv, ok := value.(string) 8106 if !ok { 8107 return fmt.Errorf("expected ResourceId to be of type string, got %T instead", value) 8108 } 8109 sv.ResourceId = ptr.String(jtv) 8110 } 8111 8112 case "ResourceTags": 8113 if err := awsAwsjson11_deserializeDocumentTagList(&sv.ResourceTags, value); err != nil { 8114 return err 8115 } 8116 8117 case "ResourceType": 8118 if value != nil { 8119 jtv, ok := value.(string) 8120 if !ok { 8121 return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value) 8122 } 8123 sv.ResourceType = ptr.String(jtv) 8124 } 8125 8126 case "ResourceViolations": 8127 if err := awsAwsjson11_deserializeDocumentResourceViolations(&sv.ResourceViolations, value); err != nil { 8128 return err 8129 } 8130 8131 default: 8132 _, _ = key, value 8133 8134 } 8135 } 8136 *v = sv 8137 return nil 8138} 8139 8140func awsAwsjson11_deserializeOpDocumentGetAdminAccountOutput(v **GetAdminAccountOutput, value interface{}) error { 8141 if v == nil { 8142 return fmt.Errorf("unexpected nil of type %T", v) 8143 } 8144 if value == nil { 8145 return nil 8146 } 8147 8148 shape, ok := value.(map[string]interface{}) 8149 if !ok { 8150 return fmt.Errorf("unexpected JSON type %v", value) 8151 } 8152 8153 var sv *GetAdminAccountOutput 8154 if *v == nil { 8155 sv = &GetAdminAccountOutput{} 8156 } else { 8157 sv = *v 8158 } 8159 8160 for key, value := range shape { 8161 switch key { 8162 case "AdminAccount": 8163 if value != nil { 8164 jtv, ok := value.(string) 8165 if !ok { 8166 return fmt.Errorf("expected AWSAccountId to be of type string, got %T instead", value) 8167 } 8168 sv.AdminAccount = ptr.String(jtv) 8169 } 8170 8171 case "RoleStatus": 8172 if value != nil { 8173 jtv, ok := value.(string) 8174 if !ok { 8175 return fmt.Errorf("expected AccountRoleStatus to be of type string, got %T instead", value) 8176 } 8177 sv.RoleStatus = types.AccountRoleStatus(jtv) 8178 } 8179 8180 default: 8181 _, _ = key, value 8182 8183 } 8184 } 8185 *v = sv 8186 return nil 8187} 8188 8189func awsAwsjson11_deserializeOpDocumentGetAppsListOutput(v **GetAppsListOutput, value interface{}) error { 8190 if v == nil { 8191 return fmt.Errorf("unexpected nil of type %T", v) 8192 } 8193 if value == nil { 8194 return nil 8195 } 8196 8197 shape, ok := value.(map[string]interface{}) 8198 if !ok { 8199 return fmt.Errorf("unexpected JSON type %v", value) 8200 } 8201 8202 var sv *GetAppsListOutput 8203 if *v == nil { 8204 sv = &GetAppsListOutput{} 8205 } else { 8206 sv = *v 8207 } 8208 8209 for key, value := range shape { 8210 switch key { 8211 case "AppsList": 8212 if err := awsAwsjson11_deserializeDocumentAppsListData(&sv.AppsList, value); err != nil { 8213 return err 8214 } 8215 8216 case "AppsListArn": 8217 if value != nil { 8218 jtv, ok := value.(string) 8219 if !ok { 8220 return fmt.Errorf("expected ResourceArn to be of type string, got %T instead", value) 8221 } 8222 sv.AppsListArn = ptr.String(jtv) 8223 } 8224 8225 default: 8226 _, _ = key, value 8227 8228 } 8229 } 8230 *v = sv 8231 return nil 8232} 8233 8234func awsAwsjson11_deserializeOpDocumentGetComplianceDetailOutput(v **GetComplianceDetailOutput, value interface{}) error { 8235 if v == nil { 8236 return fmt.Errorf("unexpected nil of type %T", v) 8237 } 8238 if value == nil { 8239 return nil 8240 } 8241 8242 shape, ok := value.(map[string]interface{}) 8243 if !ok { 8244 return fmt.Errorf("unexpected JSON type %v", value) 8245 } 8246 8247 var sv *GetComplianceDetailOutput 8248 if *v == nil { 8249 sv = &GetComplianceDetailOutput{} 8250 } else { 8251 sv = *v 8252 } 8253 8254 for key, value := range shape { 8255 switch key { 8256 case "PolicyComplianceDetail": 8257 if err := awsAwsjson11_deserializeDocumentPolicyComplianceDetail(&sv.PolicyComplianceDetail, value); err != nil { 8258 return err 8259 } 8260 8261 default: 8262 _, _ = key, value 8263 8264 } 8265 } 8266 *v = sv 8267 return nil 8268} 8269 8270func awsAwsjson11_deserializeOpDocumentGetNotificationChannelOutput(v **GetNotificationChannelOutput, value interface{}) error { 8271 if v == nil { 8272 return fmt.Errorf("unexpected nil of type %T", v) 8273 } 8274 if value == nil { 8275 return nil 8276 } 8277 8278 shape, ok := value.(map[string]interface{}) 8279 if !ok { 8280 return fmt.Errorf("unexpected JSON type %v", value) 8281 } 8282 8283 var sv *GetNotificationChannelOutput 8284 if *v == nil { 8285 sv = &GetNotificationChannelOutput{} 8286 } else { 8287 sv = *v 8288 } 8289 8290 for key, value := range shape { 8291 switch key { 8292 case "SnsRoleName": 8293 if value != nil { 8294 jtv, ok := value.(string) 8295 if !ok { 8296 return fmt.Errorf("expected ResourceArn to be of type string, got %T instead", value) 8297 } 8298 sv.SnsRoleName = ptr.String(jtv) 8299 } 8300 8301 case "SnsTopicArn": 8302 if value != nil { 8303 jtv, ok := value.(string) 8304 if !ok { 8305 return fmt.Errorf("expected ResourceArn to be of type string, got %T instead", value) 8306 } 8307 sv.SnsTopicArn = ptr.String(jtv) 8308 } 8309 8310 default: 8311 _, _ = key, value 8312 8313 } 8314 } 8315 *v = sv 8316 return nil 8317} 8318 8319func awsAwsjson11_deserializeOpDocumentGetPolicyOutput(v **GetPolicyOutput, value interface{}) error { 8320 if v == nil { 8321 return fmt.Errorf("unexpected nil of type %T", v) 8322 } 8323 if value == nil { 8324 return nil 8325 } 8326 8327 shape, ok := value.(map[string]interface{}) 8328 if !ok { 8329 return fmt.Errorf("unexpected JSON type %v", value) 8330 } 8331 8332 var sv *GetPolicyOutput 8333 if *v == nil { 8334 sv = &GetPolicyOutput{} 8335 } else { 8336 sv = *v 8337 } 8338 8339 for key, value := range shape { 8340 switch key { 8341 case "Policy": 8342 if err := awsAwsjson11_deserializeDocumentPolicy(&sv.Policy, value); err != nil { 8343 return err 8344 } 8345 8346 case "PolicyArn": 8347 if value != nil { 8348 jtv, ok := value.(string) 8349 if !ok { 8350 return fmt.Errorf("expected ResourceArn to be of type string, got %T instead", value) 8351 } 8352 sv.PolicyArn = ptr.String(jtv) 8353 } 8354 8355 default: 8356 _, _ = key, value 8357 8358 } 8359 } 8360 *v = sv 8361 return nil 8362} 8363 8364func awsAwsjson11_deserializeOpDocumentGetProtectionStatusOutput(v **GetProtectionStatusOutput, value interface{}) error { 8365 if v == nil { 8366 return fmt.Errorf("unexpected nil of type %T", v) 8367 } 8368 if value == nil { 8369 return nil 8370 } 8371 8372 shape, ok := value.(map[string]interface{}) 8373 if !ok { 8374 return fmt.Errorf("unexpected JSON type %v", value) 8375 } 8376 8377 var sv *GetProtectionStatusOutput 8378 if *v == nil { 8379 sv = &GetProtectionStatusOutput{} 8380 } else { 8381 sv = *v 8382 } 8383 8384 for key, value := range shape { 8385 switch key { 8386 case "AdminAccountId": 8387 if value != nil { 8388 jtv, ok := value.(string) 8389 if !ok { 8390 return fmt.Errorf("expected AWSAccountId to be of type string, got %T instead", value) 8391 } 8392 sv.AdminAccountId = ptr.String(jtv) 8393 } 8394 8395 case "Data": 8396 if value != nil { 8397 jtv, ok := value.(string) 8398 if !ok { 8399 return fmt.Errorf("expected ProtectionData to be of type string, got %T instead", value) 8400 } 8401 sv.Data = ptr.String(jtv) 8402 } 8403 8404 case "NextToken": 8405 if value != nil { 8406 jtv, ok := value.(string) 8407 if !ok { 8408 return fmt.Errorf("expected PaginationToken to be of type string, got %T instead", value) 8409 } 8410 sv.NextToken = ptr.String(jtv) 8411 } 8412 8413 case "ServiceType": 8414 if value != nil { 8415 jtv, ok := value.(string) 8416 if !ok { 8417 return fmt.Errorf("expected SecurityServiceType to be of type string, got %T instead", value) 8418 } 8419 sv.ServiceType = types.SecurityServiceType(jtv) 8420 } 8421 8422 default: 8423 _, _ = key, value 8424 8425 } 8426 } 8427 *v = sv 8428 return nil 8429} 8430 8431func awsAwsjson11_deserializeOpDocumentGetProtocolsListOutput(v **GetProtocolsListOutput, value interface{}) error { 8432 if v == nil { 8433 return fmt.Errorf("unexpected nil of type %T", v) 8434 } 8435 if value == nil { 8436 return nil 8437 } 8438 8439 shape, ok := value.(map[string]interface{}) 8440 if !ok { 8441 return fmt.Errorf("unexpected JSON type %v", value) 8442 } 8443 8444 var sv *GetProtocolsListOutput 8445 if *v == nil { 8446 sv = &GetProtocolsListOutput{} 8447 } else { 8448 sv = *v 8449 } 8450 8451 for key, value := range shape { 8452 switch key { 8453 case "ProtocolsList": 8454 if err := awsAwsjson11_deserializeDocumentProtocolsListData(&sv.ProtocolsList, value); err != nil { 8455 return err 8456 } 8457 8458 case "ProtocolsListArn": 8459 if value != nil { 8460 jtv, ok := value.(string) 8461 if !ok { 8462 return fmt.Errorf("expected ResourceArn to be of type string, got %T instead", value) 8463 } 8464 sv.ProtocolsListArn = ptr.String(jtv) 8465 } 8466 8467 default: 8468 _, _ = key, value 8469 8470 } 8471 } 8472 *v = sv 8473 return nil 8474} 8475 8476func awsAwsjson11_deserializeOpDocumentGetViolationDetailsOutput(v **GetViolationDetailsOutput, value interface{}) error { 8477 if v == nil { 8478 return fmt.Errorf("unexpected nil of type %T", v) 8479 } 8480 if value == nil { 8481 return nil 8482 } 8483 8484 shape, ok := value.(map[string]interface{}) 8485 if !ok { 8486 return fmt.Errorf("unexpected JSON type %v", value) 8487 } 8488 8489 var sv *GetViolationDetailsOutput 8490 if *v == nil { 8491 sv = &GetViolationDetailsOutput{} 8492 } else { 8493 sv = *v 8494 } 8495 8496 for key, value := range shape { 8497 switch key { 8498 case "ViolationDetail": 8499 if err := awsAwsjson11_deserializeDocumentViolationDetail(&sv.ViolationDetail, value); err != nil { 8500 return err 8501 } 8502 8503 default: 8504 _, _ = key, value 8505 8506 } 8507 } 8508 *v = sv 8509 return nil 8510} 8511 8512func awsAwsjson11_deserializeOpDocumentListAppsListsOutput(v **ListAppsListsOutput, value interface{}) error { 8513 if v == nil { 8514 return fmt.Errorf("unexpected nil of type %T", v) 8515 } 8516 if value == nil { 8517 return nil 8518 } 8519 8520 shape, ok := value.(map[string]interface{}) 8521 if !ok { 8522 return fmt.Errorf("unexpected JSON type %v", value) 8523 } 8524 8525 var sv *ListAppsListsOutput 8526 if *v == nil { 8527 sv = &ListAppsListsOutput{} 8528 } else { 8529 sv = *v 8530 } 8531 8532 for key, value := range shape { 8533 switch key { 8534 case "AppsLists": 8535 if err := awsAwsjson11_deserializeDocumentAppsListsData(&sv.AppsLists, value); err != nil { 8536 return err 8537 } 8538 8539 case "NextToken": 8540 if value != nil { 8541 jtv, ok := value.(string) 8542 if !ok { 8543 return fmt.Errorf("expected PaginationToken to be of type string, got %T instead", value) 8544 } 8545 sv.NextToken = ptr.String(jtv) 8546 } 8547 8548 default: 8549 _, _ = key, value 8550 8551 } 8552 } 8553 *v = sv 8554 return nil 8555} 8556 8557func awsAwsjson11_deserializeOpDocumentListComplianceStatusOutput(v **ListComplianceStatusOutput, value interface{}) error { 8558 if v == nil { 8559 return fmt.Errorf("unexpected nil of type %T", v) 8560 } 8561 if value == nil { 8562 return nil 8563 } 8564 8565 shape, ok := value.(map[string]interface{}) 8566 if !ok { 8567 return fmt.Errorf("unexpected JSON type %v", value) 8568 } 8569 8570 var sv *ListComplianceStatusOutput 8571 if *v == nil { 8572 sv = &ListComplianceStatusOutput{} 8573 } else { 8574 sv = *v 8575 } 8576 8577 for key, value := range shape { 8578 switch key { 8579 case "NextToken": 8580 if value != nil { 8581 jtv, ok := value.(string) 8582 if !ok { 8583 return fmt.Errorf("expected PaginationToken to be of type string, got %T instead", value) 8584 } 8585 sv.NextToken = ptr.String(jtv) 8586 } 8587 8588 case "PolicyComplianceStatusList": 8589 if err := awsAwsjson11_deserializeDocumentPolicyComplianceStatusList(&sv.PolicyComplianceStatusList, value); err != nil { 8590 return err 8591 } 8592 8593 default: 8594 _, _ = key, value 8595 8596 } 8597 } 8598 *v = sv 8599 return nil 8600} 8601 8602func awsAwsjson11_deserializeOpDocumentListMemberAccountsOutput(v **ListMemberAccountsOutput, value interface{}) error { 8603 if v == nil { 8604 return fmt.Errorf("unexpected nil of type %T", v) 8605 } 8606 if value == nil { 8607 return nil 8608 } 8609 8610 shape, ok := value.(map[string]interface{}) 8611 if !ok { 8612 return fmt.Errorf("unexpected JSON type %v", value) 8613 } 8614 8615 var sv *ListMemberAccountsOutput 8616 if *v == nil { 8617 sv = &ListMemberAccountsOutput{} 8618 } else { 8619 sv = *v 8620 } 8621 8622 for key, value := range shape { 8623 switch key { 8624 case "MemberAccounts": 8625 if err := awsAwsjson11_deserializeDocumentMemberAccounts(&sv.MemberAccounts, value); err != nil { 8626 return err 8627 } 8628 8629 case "NextToken": 8630 if value != nil { 8631 jtv, ok := value.(string) 8632 if !ok { 8633 return fmt.Errorf("expected PaginationToken to be of type string, got %T instead", value) 8634 } 8635 sv.NextToken = ptr.String(jtv) 8636 } 8637 8638 default: 8639 _, _ = key, value 8640 8641 } 8642 } 8643 *v = sv 8644 return nil 8645} 8646 8647func awsAwsjson11_deserializeOpDocumentListPoliciesOutput(v **ListPoliciesOutput, value interface{}) error { 8648 if v == nil { 8649 return fmt.Errorf("unexpected nil of type %T", v) 8650 } 8651 if value == nil { 8652 return nil 8653 } 8654 8655 shape, ok := value.(map[string]interface{}) 8656 if !ok { 8657 return fmt.Errorf("unexpected JSON type %v", value) 8658 } 8659 8660 var sv *ListPoliciesOutput 8661 if *v == nil { 8662 sv = &ListPoliciesOutput{} 8663 } else { 8664 sv = *v 8665 } 8666 8667 for key, value := range shape { 8668 switch key { 8669 case "NextToken": 8670 if value != nil { 8671 jtv, ok := value.(string) 8672 if !ok { 8673 return fmt.Errorf("expected PaginationToken to be of type string, got %T instead", value) 8674 } 8675 sv.NextToken = ptr.String(jtv) 8676 } 8677 8678 case "PolicyList": 8679 if err := awsAwsjson11_deserializeDocumentPolicySummaryList(&sv.PolicyList, value); err != nil { 8680 return err 8681 } 8682 8683 default: 8684 _, _ = key, value 8685 8686 } 8687 } 8688 *v = sv 8689 return nil 8690} 8691 8692func awsAwsjson11_deserializeOpDocumentListProtocolsListsOutput(v **ListProtocolsListsOutput, value interface{}) error { 8693 if v == nil { 8694 return fmt.Errorf("unexpected nil of type %T", v) 8695 } 8696 if value == nil { 8697 return nil 8698 } 8699 8700 shape, ok := value.(map[string]interface{}) 8701 if !ok { 8702 return fmt.Errorf("unexpected JSON type %v", value) 8703 } 8704 8705 var sv *ListProtocolsListsOutput 8706 if *v == nil { 8707 sv = &ListProtocolsListsOutput{} 8708 } else { 8709 sv = *v 8710 } 8711 8712 for key, value := range shape { 8713 switch key { 8714 case "NextToken": 8715 if value != nil { 8716 jtv, ok := value.(string) 8717 if !ok { 8718 return fmt.Errorf("expected PaginationToken to be of type string, got %T instead", value) 8719 } 8720 sv.NextToken = ptr.String(jtv) 8721 } 8722 8723 case "ProtocolsLists": 8724 if err := awsAwsjson11_deserializeDocumentProtocolsListsData(&sv.ProtocolsLists, value); err != nil { 8725 return err 8726 } 8727 8728 default: 8729 _, _ = key, value 8730 8731 } 8732 } 8733 *v = sv 8734 return nil 8735} 8736 8737func awsAwsjson11_deserializeOpDocumentListTagsForResourceOutput(v **ListTagsForResourceOutput, value interface{}) error { 8738 if v == nil { 8739 return fmt.Errorf("unexpected nil of type %T", v) 8740 } 8741 if value == nil { 8742 return nil 8743 } 8744 8745 shape, ok := value.(map[string]interface{}) 8746 if !ok { 8747 return fmt.Errorf("unexpected JSON type %v", value) 8748 } 8749 8750 var sv *ListTagsForResourceOutput 8751 if *v == nil { 8752 sv = &ListTagsForResourceOutput{} 8753 } else { 8754 sv = *v 8755 } 8756 8757 for key, value := range shape { 8758 switch key { 8759 case "TagList": 8760 if err := awsAwsjson11_deserializeDocumentTagList(&sv.TagList, value); err != nil { 8761 return err 8762 } 8763 8764 default: 8765 _, _ = key, value 8766 8767 } 8768 } 8769 *v = sv 8770 return nil 8771} 8772 8773func awsAwsjson11_deserializeOpDocumentPutAppsListOutput(v **PutAppsListOutput, value interface{}) error { 8774 if v == nil { 8775 return fmt.Errorf("unexpected nil of type %T", v) 8776 } 8777 if value == nil { 8778 return nil 8779 } 8780 8781 shape, ok := value.(map[string]interface{}) 8782 if !ok { 8783 return fmt.Errorf("unexpected JSON type %v", value) 8784 } 8785 8786 var sv *PutAppsListOutput 8787 if *v == nil { 8788 sv = &PutAppsListOutput{} 8789 } else { 8790 sv = *v 8791 } 8792 8793 for key, value := range shape { 8794 switch key { 8795 case "AppsList": 8796 if err := awsAwsjson11_deserializeDocumentAppsListData(&sv.AppsList, value); err != nil { 8797 return err 8798 } 8799 8800 case "AppsListArn": 8801 if value != nil { 8802 jtv, ok := value.(string) 8803 if !ok { 8804 return fmt.Errorf("expected ResourceArn to be of type string, got %T instead", value) 8805 } 8806 sv.AppsListArn = ptr.String(jtv) 8807 } 8808 8809 default: 8810 _, _ = key, value 8811 8812 } 8813 } 8814 *v = sv 8815 return nil 8816} 8817 8818func awsAwsjson11_deserializeOpDocumentPutPolicyOutput(v **PutPolicyOutput, value interface{}) error { 8819 if v == nil { 8820 return fmt.Errorf("unexpected nil of type %T", v) 8821 } 8822 if value == nil { 8823 return nil 8824 } 8825 8826 shape, ok := value.(map[string]interface{}) 8827 if !ok { 8828 return fmt.Errorf("unexpected JSON type %v", value) 8829 } 8830 8831 var sv *PutPolicyOutput 8832 if *v == nil { 8833 sv = &PutPolicyOutput{} 8834 } else { 8835 sv = *v 8836 } 8837 8838 for key, value := range shape { 8839 switch key { 8840 case "Policy": 8841 if err := awsAwsjson11_deserializeDocumentPolicy(&sv.Policy, value); err != nil { 8842 return err 8843 } 8844 8845 case "PolicyArn": 8846 if value != nil { 8847 jtv, ok := value.(string) 8848 if !ok { 8849 return fmt.Errorf("expected ResourceArn to be of type string, got %T instead", value) 8850 } 8851 sv.PolicyArn = ptr.String(jtv) 8852 } 8853 8854 default: 8855 _, _ = key, value 8856 8857 } 8858 } 8859 *v = sv 8860 return nil 8861} 8862 8863func awsAwsjson11_deserializeOpDocumentPutProtocolsListOutput(v **PutProtocolsListOutput, value interface{}) error { 8864 if v == nil { 8865 return fmt.Errorf("unexpected nil of type %T", v) 8866 } 8867 if value == nil { 8868 return nil 8869 } 8870 8871 shape, ok := value.(map[string]interface{}) 8872 if !ok { 8873 return fmt.Errorf("unexpected JSON type %v", value) 8874 } 8875 8876 var sv *PutProtocolsListOutput 8877 if *v == nil { 8878 sv = &PutProtocolsListOutput{} 8879 } else { 8880 sv = *v 8881 } 8882 8883 for key, value := range shape { 8884 switch key { 8885 case "ProtocolsList": 8886 if err := awsAwsjson11_deserializeDocumentProtocolsListData(&sv.ProtocolsList, value); err != nil { 8887 return err 8888 } 8889 8890 case "ProtocolsListArn": 8891 if value != nil { 8892 jtv, ok := value.(string) 8893 if !ok { 8894 return fmt.Errorf("expected ResourceArn to be of type string, got %T instead", value) 8895 } 8896 sv.ProtocolsListArn = ptr.String(jtv) 8897 } 8898 8899 default: 8900 _, _ = key, value 8901 8902 } 8903 } 8904 *v = sv 8905 return nil 8906} 8907 8908func awsAwsjson11_deserializeOpDocumentTagResourceOutput(v **TagResourceOutput, value interface{}) error { 8909 if v == nil { 8910 return fmt.Errorf("unexpected nil of type %T", v) 8911 } 8912 if value == nil { 8913 return nil 8914 } 8915 8916 shape, ok := value.(map[string]interface{}) 8917 if !ok { 8918 return fmt.Errorf("unexpected JSON type %v", value) 8919 } 8920 8921 var sv *TagResourceOutput 8922 if *v == nil { 8923 sv = &TagResourceOutput{} 8924 } else { 8925 sv = *v 8926 } 8927 8928 for key, value := range shape { 8929 switch key { 8930 default: 8931 _, _ = key, value 8932 8933 } 8934 } 8935 *v = sv 8936 return nil 8937} 8938 8939func awsAwsjson11_deserializeOpDocumentUntagResourceOutput(v **UntagResourceOutput, value interface{}) error { 8940 if v == nil { 8941 return fmt.Errorf("unexpected nil of type %T", v) 8942 } 8943 if value == nil { 8944 return nil 8945 } 8946 8947 shape, ok := value.(map[string]interface{}) 8948 if !ok { 8949 return fmt.Errorf("unexpected JSON type %v", value) 8950 } 8951 8952 var sv *UntagResourceOutput 8953 if *v == nil { 8954 sv = &UntagResourceOutput{} 8955 } else { 8956 sv = *v 8957 } 8958 8959 for key, value := range shape { 8960 switch key { 8961 default: 8962 _, _ = key, value 8963 8964 } 8965 } 8966 *v = sv 8967 return nil 8968} 8969