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