1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package organizations 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/organizations/types" 12 smithy "github.com/aws/smithy-go" 13 smithyio "github.com/aws/smithy-go/io" 14 "github.com/aws/smithy-go/middleware" 15 "github.com/aws/smithy-go/ptr" 16 smithytime "github.com/aws/smithy-go/time" 17 smithyhttp "github.com/aws/smithy-go/transport/http" 18 "io" 19 "io/ioutil" 20 "strings" 21) 22 23type awsAwsjson11_deserializeOpAcceptHandshake struct { 24} 25 26func (*awsAwsjson11_deserializeOpAcceptHandshake) ID() string { 27 return "OperationDeserializer" 28} 29 30func (m *awsAwsjson11_deserializeOpAcceptHandshake) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 31 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 32) { 33 out, metadata, err = next.HandleDeserialize(ctx, in) 34 if err != nil { 35 return out, metadata, err 36 } 37 38 response, ok := out.RawResponse.(*smithyhttp.Response) 39 if !ok { 40 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 41 } 42 43 if response.StatusCode < 200 || response.StatusCode >= 300 { 44 return out, metadata, awsAwsjson11_deserializeOpErrorAcceptHandshake(response, &metadata) 45 } 46 output := &AcceptHandshakeOutput{} 47 out.Result = output 48 49 var buff [1024]byte 50 ringBuffer := smithyio.NewRingBuffer(buff[:]) 51 52 body := io.TeeReader(response.Body, ringBuffer) 53 decoder := json.NewDecoder(body) 54 decoder.UseNumber() 55 var shape interface{} 56 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 57 var snapshot bytes.Buffer 58 io.Copy(&snapshot, ringBuffer) 59 err = &smithy.DeserializationError{ 60 Err: fmt.Errorf("failed to decode response body, %w", err), 61 Snapshot: snapshot.Bytes(), 62 } 63 return out, metadata, err 64 } 65 66 err = awsAwsjson11_deserializeOpDocumentAcceptHandshakeOutput(&output, shape) 67 if err != nil { 68 var snapshot bytes.Buffer 69 io.Copy(&snapshot, ringBuffer) 70 err = &smithy.DeserializationError{ 71 Err: fmt.Errorf("failed to decode response body, %w", err), 72 Snapshot: snapshot.Bytes(), 73 } 74 return out, metadata, err 75 } 76 77 return out, metadata, err 78} 79 80func awsAwsjson11_deserializeOpErrorAcceptHandshake(response *smithyhttp.Response, metadata *middleware.Metadata) error { 81 var errorBuffer bytes.Buffer 82 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 83 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 84 } 85 errorBody := bytes.NewReader(errorBuffer.Bytes()) 86 87 errorCode := "UnknownError" 88 errorMessage := errorCode 89 90 code := response.Header.Get("X-Amzn-ErrorType") 91 if len(code) != 0 { 92 errorCode = restjson.SanitizeErrorCode(code) 93 } 94 95 var buff [1024]byte 96 ringBuffer := smithyio.NewRingBuffer(buff[:]) 97 98 body := io.TeeReader(errorBody, ringBuffer) 99 decoder := json.NewDecoder(body) 100 decoder.UseNumber() 101 code, message, err := restjson.GetErrorInfo(decoder) 102 if err != nil { 103 var snapshot bytes.Buffer 104 io.Copy(&snapshot, ringBuffer) 105 err = &smithy.DeserializationError{ 106 Err: fmt.Errorf("failed to decode response body, %w", err), 107 Snapshot: snapshot.Bytes(), 108 } 109 return err 110 } 111 112 errorBody.Seek(0, io.SeekStart) 113 if len(code) != 0 { 114 errorCode = restjson.SanitizeErrorCode(code) 115 } 116 if len(message) != 0 { 117 errorMessage = message 118 } 119 120 switch { 121 case strings.EqualFold("AccessDeniedException", errorCode): 122 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 123 124 case strings.EqualFold("AccessDeniedForDependencyException", errorCode): 125 return awsAwsjson11_deserializeErrorAccessDeniedForDependencyException(response, errorBody) 126 127 case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode): 128 return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody) 129 130 case strings.EqualFold("ConcurrentModificationException", errorCode): 131 return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody) 132 133 case strings.EqualFold("HandshakeAlreadyInStateException", errorCode): 134 return awsAwsjson11_deserializeErrorHandshakeAlreadyInStateException(response, errorBody) 135 136 case strings.EqualFold("HandshakeConstraintViolationException", errorCode): 137 return awsAwsjson11_deserializeErrorHandshakeConstraintViolationException(response, errorBody) 138 139 case strings.EqualFold("HandshakeNotFoundException", errorCode): 140 return awsAwsjson11_deserializeErrorHandshakeNotFoundException(response, errorBody) 141 142 case strings.EqualFold("InvalidHandshakeTransitionException", errorCode): 143 return awsAwsjson11_deserializeErrorInvalidHandshakeTransitionException(response, errorBody) 144 145 case strings.EqualFold("InvalidInputException", errorCode): 146 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 147 148 case strings.EqualFold("ServiceException", errorCode): 149 return awsAwsjson11_deserializeErrorServiceException(response, errorBody) 150 151 case strings.EqualFold("TooManyRequestsException", errorCode): 152 return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody) 153 154 default: 155 genericError := &smithy.GenericAPIError{ 156 Code: errorCode, 157 Message: errorMessage, 158 } 159 return genericError 160 161 } 162} 163 164type awsAwsjson11_deserializeOpAttachPolicy struct { 165} 166 167func (*awsAwsjson11_deserializeOpAttachPolicy) ID() string { 168 return "OperationDeserializer" 169} 170 171func (m *awsAwsjson11_deserializeOpAttachPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 172 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 173) { 174 out, metadata, err = next.HandleDeserialize(ctx, in) 175 if err != nil { 176 return out, metadata, err 177 } 178 179 response, ok := out.RawResponse.(*smithyhttp.Response) 180 if !ok { 181 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 182 } 183 184 if response.StatusCode < 200 || response.StatusCode >= 300 { 185 return out, metadata, awsAwsjson11_deserializeOpErrorAttachPolicy(response, &metadata) 186 } 187 output := &AttachPolicyOutput{} 188 out.Result = output 189 190 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 191 return out, metadata, &smithy.DeserializationError{ 192 Err: fmt.Errorf("failed to discard response body, %w", err), 193 } 194 } 195 196 return out, metadata, err 197} 198 199func awsAwsjson11_deserializeOpErrorAttachPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { 200 var errorBuffer bytes.Buffer 201 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 202 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 203 } 204 errorBody := bytes.NewReader(errorBuffer.Bytes()) 205 206 errorCode := "UnknownError" 207 errorMessage := errorCode 208 209 code := response.Header.Get("X-Amzn-ErrorType") 210 if len(code) != 0 { 211 errorCode = restjson.SanitizeErrorCode(code) 212 } 213 214 var buff [1024]byte 215 ringBuffer := smithyio.NewRingBuffer(buff[:]) 216 217 body := io.TeeReader(errorBody, ringBuffer) 218 decoder := json.NewDecoder(body) 219 decoder.UseNumber() 220 code, message, err := restjson.GetErrorInfo(decoder) 221 if err != nil { 222 var snapshot bytes.Buffer 223 io.Copy(&snapshot, ringBuffer) 224 err = &smithy.DeserializationError{ 225 Err: fmt.Errorf("failed to decode response body, %w", err), 226 Snapshot: snapshot.Bytes(), 227 } 228 return err 229 } 230 231 errorBody.Seek(0, io.SeekStart) 232 if len(code) != 0 { 233 errorCode = restjson.SanitizeErrorCode(code) 234 } 235 if len(message) != 0 { 236 errorMessage = message 237 } 238 239 switch { 240 case strings.EqualFold("AccessDeniedException", errorCode): 241 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 242 243 case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode): 244 return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody) 245 246 case strings.EqualFold("ConcurrentModificationException", errorCode): 247 return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody) 248 249 case strings.EqualFold("ConstraintViolationException", errorCode): 250 return awsAwsjson11_deserializeErrorConstraintViolationException(response, errorBody) 251 252 case strings.EqualFold("DuplicatePolicyAttachmentException", errorCode): 253 return awsAwsjson11_deserializeErrorDuplicatePolicyAttachmentException(response, errorBody) 254 255 case strings.EqualFold("InvalidInputException", errorCode): 256 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 257 258 case strings.EqualFold("PolicyChangesInProgressException", errorCode): 259 return awsAwsjson11_deserializeErrorPolicyChangesInProgressException(response, errorBody) 260 261 case strings.EqualFold("PolicyNotFoundException", errorCode): 262 return awsAwsjson11_deserializeErrorPolicyNotFoundException(response, errorBody) 263 264 case strings.EqualFold("PolicyTypeNotEnabledException", errorCode): 265 return awsAwsjson11_deserializeErrorPolicyTypeNotEnabledException(response, errorBody) 266 267 case strings.EqualFold("ServiceException", errorCode): 268 return awsAwsjson11_deserializeErrorServiceException(response, errorBody) 269 270 case strings.EqualFold("TargetNotFoundException", errorCode): 271 return awsAwsjson11_deserializeErrorTargetNotFoundException(response, errorBody) 272 273 case strings.EqualFold("TooManyRequestsException", errorCode): 274 return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody) 275 276 case strings.EqualFold("UnsupportedAPIEndpointException", errorCode): 277 return awsAwsjson11_deserializeErrorUnsupportedAPIEndpointException(response, errorBody) 278 279 default: 280 genericError := &smithy.GenericAPIError{ 281 Code: errorCode, 282 Message: errorMessage, 283 } 284 return genericError 285 286 } 287} 288 289type awsAwsjson11_deserializeOpCancelHandshake struct { 290} 291 292func (*awsAwsjson11_deserializeOpCancelHandshake) ID() string { 293 return "OperationDeserializer" 294} 295 296func (m *awsAwsjson11_deserializeOpCancelHandshake) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 297 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 298) { 299 out, metadata, err = next.HandleDeserialize(ctx, in) 300 if err != nil { 301 return out, metadata, err 302 } 303 304 response, ok := out.RawResponse.(*smithyhttp.Response) 305 if !ok { 306 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 307 } 308 309 if response.StatusCode < 200 || response.StatusCode >= 300 { 310 return out, metadata, awsAwsjson11_deserializeOpErrorCancelHandshake(response, &metadata) 311 } 312 output := &CancelHandshakeOutput{} 313 out.Result = output 314 315 var buff [1024]byte 316 ringBuffer := smithyio.NewRingBuffer(buff[:]) 317 318 body := io.TeeReader(response.Body, ringBuffer) 319 decoder := json.NewDecoder(body) 320 decoder.UseNumber() 321 var shape interface{} 322 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 323 var snapshot bytes.Buffer 324 io.Copy(&snapshot, ringBuffer) 325 err = &smithy.DeserializationError{ 326 Err: fmt.Errorf("failed to decode response body, %w", err), 327 Snapshot: snapshot.Bytes(), 328 } 329 return out, metadata, err 330 } 331 332 err = awsAwsjson11_deserializeOpDocumentCancelHandshakeOutput(&output, shape) 333 if err != nil { 334 var snapshot bytes.Buffer 335 io.Copy(&snapshot, ringBuffer) 336 err = &smithy.DeserializationError{ 337 Err: fmt.Errorf("failed to decode response body, %w", err), 338 Snapshot: snapshot.Bytes(), 339 } 340 return out, metadata, err 341 } 342 343 return out, metadata, err 344} 345 346func awsAwsjson11_deserializeOpErrorCancelHandshake(response *smithyhttp.Response, metadata *middleware.Metadata) error { 347 var errorBuffer bytes.Buffer 348 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 349 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 350 } 351 errorBody := bytes.NewReader(errorBuffer.Bytes()) 352 353 errorCode := "UnknownError" 354 errorMessage := errorCode 355 356 code := response.Header.Get("X-Amzn-ErrorType") 357 if len(code) != 0 { 358 errorCode = restjson.SanitizeErrorCode(code) 359 } 360 361 var buff [1024]byte 362 ringBuffer := smithyio.NewRingBuffer(buff[:]) 363 364 body := io.TeeReader(errorBody, ringBuffer) 365 decoder := json.NewDecoder(body) 366 decoder.UseNumber() 367 code, message, err := restjson.GetErrorInfo(decoder) 368 if err != nil { 369 var snapshot bytes.Buffer 370 io.Copy(&snapshot, ringBuffer) 371 err = &smithy.DeserializationError{ 372 Err: fmt.Errorf("failed to decode response body, %w", err), 373 Snapshot: snapshot.Bytes(), 374 } 375 return err 376 } 377 378 errorBody.Seek(0, io.SeekStart) 379 if len(code) != 0 { 380 errorCode = restjson.SanitizeErrorCode(code) 381 } 382 if len(message) != 0 { 383 errorMessage = message 384 } 385 386 switch { 387 case strings.EqualFold("AccessDeniedException", errorCode): 388 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 389 390 case strings.EqualFold("ConcurrentModificationException", errorCode): 391 return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody) 392 393 case strings.EqualFold("HandshakeAlreadyInStateException", errorCode): 394 return awsAwsjson11_deserializeErrorHandshakeAlreadyInStateException(response, errorBody) 395 396 case strings.EqualFold("HandshakeNotFoundException", errorCode): 397 return awsAwsjson11_deserializeErrorHandshakeNotFoundException(response, errorBody) 398 399 case strings.EqualFold("InvalidHandshakeTransitionException", errorCode): 400 return awsAwsjson11_deserializeErrorInvalidHandshakeTransitionException(response, errorBody) 401 402 case strings.EqualFold("InvalidInputException", errorCode): 403 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 404 405 case strings.EqualFold("ServiceException", errorCode): 406 return awsAwsjson11_deserializeErrorServiceException(response, errorBody) 407 408 case strings.EqualFold("TooManyRequestsException", errorCode): 409 return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody) 410 411 default: 412 genericError := &smithy.GenericAPIError{ 413 Code: errorCode, 414 Message: errorMessage, 415 } 416 return genericError 417 418 } 419} 420 421type awsAwsjson11_deserializeOpCreateAccount struct { 422} 423 424func (*awsAwsjson11_deserializeOpCreateAccount) ID() string { 425 return "OperationDeserializer" 426} 427 428func (m *awsAwsjson11_deserializeOpCreateAccount) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 429 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 430) { 431 out, metadata, err = next.HandleDeserialize(ctx, in) 432 if err != nil { 433 return out, metadata, err 434 } 435 436 response, ok := out.RawResponse.(*smithyhttp.Response) 437 if !ok { 438 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 439 } 440 441 if response.StatusCode < 200 || response.StatusCode >= 300 { 442 return out, metadata, awsAwsjson11_deserializeOpErrorCreateAccount(response, &metadata) 443 } 444 output := &CreateAccountOutput{} 445 out.Result = output 446 447 var buff [1024]byte 448 ringBuffer := smithyio.NewRingBuffer(buff[:]) 449 450 body := io.TeeReader(response.Body, ringBuffer) 451 decoder := json.NewDecoder(body) 452 decoder.UseNumber() 453 var shape interface{} 454 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 455 var snapshot bytes.Buffer 456 io.Copy(&snapshot, ringBuffer) 457 err = &smithy.DeserializationError{ 458 Err: fmt.Errorf("failed to decode response body, %w", err), 459 Snapshot: snapshot.Bytes(), 460 } 461 return out, metadata, err 462 } 463 464 err = awsAwsjson11_deserializeOpDocumentCreateAccountOutput(&output, shape) 465 if err != nil { 466 var snapshot bytes.Buffer 467 io.Copy(&snapshot, ringBuffer) 468 err = &smithy.DeserializationError{ 469 Err: fmt.Errorf("failed to decode response body, %w", err), 470 Snapshot: snapshot.Bytes(), 471 } 472 return out, metadata, err 473 } 474 475 return out, metadata, err 476} 477 478func awsAwsjson11_deserializeOpErrorCreateAccount(response *smithyhttp.Response, metadata *middleware.Metadata) error { 479 var errorBuffer bytes.Buffer 480 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 481 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 482 } 483 errorBody := bytes.NewReader(errorBuffer.Bytes()) 484 485 errorCode := "UnknownError" 486 errorMessage := errorCode 487 488 code := response.Header.Get("X-Amzn-ErrorType") 489 if len(code) != 0 { 490 errorCode = restjson.SanitizeErrorCode(code) 491 } 492 493 var buff [1024]byte 494 ringBuffer := smithyio.NewRingBuffer(buff[:]) 495 496 body := io.TeeReader(errorBody, ringBuffer) 497 decoder := json.NewDecoder(body) 498 decoder.UseNumber() 499 code, message, err := restjson.GetErrorInfo(decoder) 500 if err != nil { 501 var snapshot bytes.Buffer 502 io.Copy(&snapshot, ringBuffer) 503 err = &smithy.DeserializationError{ 504 Err: fmt.Errorf("failed to decode response body, %w", err), 505 Snapshot: snapshot.Bytes(), 506 } 507 return err 508 } 509 510 errorBody.Seek(0, io.SeekStart) 511 if len(code) != 0 { 512 errorCode = restjson.SanitizeErrorCode(code) 513 } 514 if len(message) != 0 { 515 errorMessage = message 516 } 517 518 switch { 519 case strings.EqualFold("AccessDeniedException", errorCode): 520 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 521 522 case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode): 523 return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody) 524 525 case strings.EqualFold("ConcurrentModificationException", errorCode): 526 return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody) 527 528 case strings.EqualFold("ConstraintViolationException", errorCode): 529 return awsAwsjson11_deserializeErrorConstraintViolationException(response, errorBody) 530 531 case strings.EqualFold("FinalizingOrganizationException", errorCode): 532 return awsAwsjson11_deserializeErrorFinalizingOrganizationException(response, errorBody) 533 534 case strings.EqualFold("InvalidInputException", errorCode): 535 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 536 537 case strings.EqualFold("ServiceException", errorCode): 538 return awsAwsjson11_deserializeErrorServiceException(response, errorBody) 539 540 case strings.EqualFold("TooManyRequestsException", errorCode): 541 return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody) 542 543 case strings.EqualFold("UnsupportedAPIEndpointException", errorCode): 544 return awsAwsjson11_deserializeErrorUnsupportedAPIEndpointException(response, errorBody) 545 546 default: 547 genericError := &smithy.GenericAPIError{ 548 Code: errorCode, 549 Message: errorMessage, 550 } 551 return genericError 552 553 } 554} 555 556type awsAwsjson11_deserializeOpCreateGovCloudAccount struct { 557} 558 559func (*awsAwsjson11_deserializeOpCreateGovCloudAccount) ID() string { 560 return "OperationDeserializer" 561} 562 563func (m *awsAwsjson11_deserializeOpCreateGovCloudAccount) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 564 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 565) { 566 out, metadata, err = next.HandleDeserialize(ctx, in) 567 if err != nil { 568 return out, metadata, err 569 } 570 571 response, ok := out.RawResponse.(*smithyhttp.Response) 572 if !ok { 573 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 574 } 575 576 if response.StatusCode < 200 || response.StatusCode >= 300 { 577 return out, metadata, awsAwsjson11_deserializeOpErrorCreateGovCloudAccount(response, &metadata) 578 } 579 output := &CreateGovCloudAccountOutput{} 580 out.Result = output 581 582 var buff [1024]byte 583 ringBuffer := smithyio.NewRingBuffer(buff[:]) 584 585 body := io.TeeReader(response.Body, ringBuffer) 586 decoder := json.NewDecoder(body) 587 decoder.UseNumber() 588 var shape interface{} 589 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 590 var snapshot bytes.Buffer 591 io.Copy(&snapshot, ringBuffer) 592 err = &smithy.DeserializationError{ 593 Err: fmt.Errorf("failed to decode response body, %w", err), 594 Snapshot: snapshot.Bytes(), 595 } 596 return out, metadata, err 597 } 598 599 err = awsAwsjson11_deserializeOpDocumentCreateGovCloudAccountOutput(&output, shape) 600 if err != nil { 601 var snapshot bytes.Buffer 602 io.Copy(&snapshot, ringBuffer) 603 err = &smithy.DeserializationError{ 604 Err: fmt.Errorf("failed to decode response body, %w", err), 605 Snapshot: snapshot.Bytes(), 606 } 607 return out, metadata, err 608 } 609 610 return out, metadata, err 611} 612 613func awsAwsjson11_deserializeOpErrorCreateGovCloudAccount(response *smithyhttp.Response, metadata *middleware.Metadata) error { 614 var errorBuffer bytes.Buffer 615 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 616 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 617 } 618 errorBody := bytes.NewReader(errorBuffer.Bytes()) 619 620 errorCode := "UnknownError" 621 errorMessage := errorCode 622 623 code := response.Header.Get("X-Amzn-ErrorType") 624 if len(code) != 0 { 625 errorCode = restjson.SanitizeErrorCode(code) 626 } 627 628 var buff [1024]byte 629 ringBuffer := smithyio.NewRingBuffer(buff[:]) 630 631 body := io.TeeReader(errorBody, ringBuffer) 632 decoder := json.NewDecoder(body) 633 decoder.UseNumber() 634 code, message, err := restjson.GetErrorInfo(decoder) 635 if err != nil { 636 var snapshot bytes.Buffer 637 io.Copy(&snapshot, ringBuffer) 638 err = &smithy.DeserializationError{ 639 Err: fmt.Errorf("failed to decode response body, %w", err), 640 Snapshot: snapshot.Bytes(), 641 } 642 return err 643 } 644 645 errorBody.Seek(0, io.SeekStart) 646 if len(code) != 0 { 647 errorCode = restjson.SanitizeErrorCode(code) 648 } 649 if len(message) != 0 { 650 errorMessage = message 651 } 652 653 switch { 654 case strings.EqualFold("AccessDeniedException", errorCode): 655 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 656 657 case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode): 658 return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody) 659 660 case strings.EqualFold("ConcurrentModificationException", errorCode): 661 return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody) 662 663 case strings.EqualFold("ConstraintViolationException", errorCode): 664 return awsAwsjson11_deserializeErrorConstraintViolationException(response, errorBody) 665 666 case strings.EqualFold("FinalizingOrganizationException", errorCode): 667 return awsAwsjson11_deserializeErrorFinalizingOrganizationException(response, errorBody) 668 669 case strings.EqualFold("InvalidInputException", errorCode): 670 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 671 672 case strings.EqualFold("ServiceException", errorCode): 673 return awsAwsjson11_deserializeErrorServiceException(response, errorBody) 674 675 case strings.EqualFold("TooManyRequestsException", errorCode): 676 return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody) 677 678 case strings.EqualFold("UnsupportedAPIEndpointException", errorCode): 679 return awsAwsjson11_deserializeErrorUnsupportedAPIEndpointException(response, errorBody) 680 681 default: 682 genericError := &smithy.GenericAPIError{ 683 Code: errorCode, 684 Message: errorMessage, 685 } 686 return genericError 687 688 } 689} 690 691type awsAwsjson11_deserializeOpCreateOrganization struct { 692} 693 694func (*awsAwsjson11_deserializeOpCreateOrganization) ID() string { 695 return "OperationDeserializer" 696} 697 698func (m *awsAwsjson11_deserializeOpCreateOrganization) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 699 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 700) { 701 out, metadata, err = next.HandleDeserialize(ctx, in) 702 if err != nil { 703 return out, metadata, err 704 } 705 706 response, ok := out.RawResponse.(*smithyhttp.Response) 707 if !ok { 708 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 709 } 710 711 if response.StatusCode < 200 || response.StatusCode >= 300 { 712 return out, metadata, awsAwsjson11_deserializeOpErrorCreateOrganization(response, &metadata) 713 } 714 output := &CreateOrganizationOutput{} 715 out.Result = output 716 717 var buff [1024]byte 718 ringBuffer := smithyio.NewRingBuffer(buff[:]) 719 720 body := io.TeeReader(response.Body, ringBuffer) 721 decoder := json.NewDecoder(body) 722 decoder.UseNumber() 723 var shape interface{} 724 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 725 var snapshot bytes.Buffer 726 io.Copy(&snapshot, ringBuffer) 727 err = &smithy.DeserializationError{ 728 Err: fmt.Errorf("failed to decode response body, %w", err), 729 Snapshot: snapshot.Bytes(), 730 } 731 return out, metadata, err 732 } 733 734 err = awsAwsjson11_deserializeOpDocumentCreateOrganizationOutput(&output, shape) 735 if err != nil { 736 var snapshot bytes.Buffer 737 io.Copy(&snapshot, ringBuffer) 738 err = &smithy.DeserializationError{ 739 Err: fmt.Errorf("failed to decode response body, %w", err), 740 Snapshot: snapshot.Bytes(), 741 } 742 return out, metadata, err 743 } 744 745 return out, metadata, err 746} 747 748func awsAwsjson11_deserializeOpErrorCreateOrganization(response *smithyhttp.Response, metadata *middleware.Metadata) error { 749 var errorBuffer bytes.Buffer 750 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 751 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 752 } 753 errorBody := bytes.NewReader(errorBuffer.Bytes()) 754 755 errorCode := "UnknownError" 756 errorMessage := errorCode 757 758 code := response.Header.Get("X-Amzn-ErrorType") 759 if len(code) != 0 { 760 errorCode = restjson.SanitizeErrorCode(code) 761 } 762 763 var buff [1024]byte 764 ringBuffer := smithyio.NewRingBuffer(buff[:]) 765 766 body := io.TeeReader(errorBody, ringBuffer) 767 decoder := json.NewDecoder(body) 768 decoder.UseNumber() 769 code, message, err := restjson.GetErrorInfo(decoder) 770 if err != nil { 771 var snapshot bytes.Buffer 772 io.Copy(&snapshot, ringBuffer) 773 err = &smithy.DeserializationError{ 774 Err: fmt.Errorf("failed to decode response body, %w", err), 775 Snapshot: snapshot.Bytes(), 776 } 777 return err 778 } 779 780 errorBody.Seek(0, io.SeekStart) 781 if len(code) != 0 { 782 errorCode = restjson.SanitizeErrorCode(code) 783 } 784 if len(message) != 0 { 785 errorMessage = message 786 } 787 788 switch { 789 case strings.EqualFold("AccessDeniedException", errorCode): 790 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 791 792 case strings.EqualFold("AccessDeniedForDependencyException", errorCode): 793 return awsAwsjson11_deserializeErrorAccessDeniedForDependencyException(response, errorBody) 794 795 case strings.EqualFold("AlreadyInOrganizationException", errorCode): 796 return awsAwsjson11_deserializeErrorAlreadyInOrganizationException(response, errorBody) 797 798 case strings.EqualFold("ConcurrentModificationException", errorCode): 799 return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody) 800 801 case strings.EqualFold("ConstraintViolationException", errorCode): 802 return awsAwsjson11_deserializeErrorConstraintViolationException(response, errorBody) 803 804 case strings.EqualFold("InvalidInputException", errorCode): 805 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 806 807 case strings.EqualFold("ServiceException", errorCode): 808 return awsAwsjson11_deserializeErrorServiceException(response, errorBody) 809 810 case strings.EqualFold("TooManyRequestsException", errorCode): 811 return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody) 812 813 default: 814 genericError := &smithy.GenericAPIError{ 815 Code: errorCode, 816 Message: errorMessage, 817 } 818 return genericError 819 820 } 821} 822 823type awsAwsjson11_deserializeOpCreateOrganizationalUnit struct { 824} 825 826func (*awsAwsjson11_deserializeOpCreateOrganizationalUnit) ID() string { 827 return "OperationDeserializer" 828} 829 830func (m *awsAwsjson11_deserializeOpCreateOrganizationalUnit) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 831 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 832) { 833 out, metadata, err = next.HandleDeserialize(ctx, in) 834 if err != nil { 835 return out, metadata, err 836 } 837 838 response, ok := out.RawResponse.(*smithyhttp.Response) 839 if !ok { 840 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 841 } 842 843 if response.StatusCode < 200 || response.StatusCode >= 300 { 844 return out, metadata, awsAwsjson11_deserializeOpErrorCreateOrganizationalUnit(response, &metadata) 845 } 846 output := &CreateOrganizationalUnitOutput{} 847 out.Result = output 848 849 var buff [1024]byte 850 ringBuffer := smithyio.NewRingBuffer(buff[:]) 851 852 body := io.TeeReader(response.Body, ringBuffer) 853 decoder := json.NewDecoder(body) 854 decoder.UseNumber() 855 var shape interface{} 856 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 857 var snapshot bytes.Buffer 858 io.Copy(&snapshot, ringBuffer) 859 err = &smithy.DeserializationError{ 860 Err: fmt.Errorf("failed to decode response body, %w", err), 861 Snapshot: snapshot.Bytes(), 862 } 863 return out, metadata, err 864 } 865 866 err = awsAwsjson11_deserializeOpDocumentCreateOrganizationalUnitOutput(&output, shape) 867 if err != nil { 868 var snapshot bytes.Buffer 869 io.Copy(&snapshot, ringBuffer) 870 err = &smithy.DeserializationError{ 871 Err: fmt.Errorf("failed to decode response body, %w", err), 872 Snapshot: snapshot.Bytes(), 873 } 874 return out, metadata, err 875 } 876 877 return out, metadata, err 878} 879 880func awsAwsjson11_deserializeOpErrorCreateOrganizationalUnit(response *smithyhttp.Response, metadata *middleware.Metadata) error { 881 var errorBuffer bytes.Buffer 882 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 883 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 884 } 885 errorBody := bytes.NewReader(errorBuffer.Bytes()) 886 887 errorCode := "UnknownError" 888 errorMessage := errorCode 889 890 code := response.Header.Get("X-Amzn-ErrorType") 891 if len(code) != 0 { 892 errorCode = restjson.SanitizeErrorCode(code) 893 } 894 895 var buff [1024]byte 896 ringBuffer := smithyio.NewRingBuffer(buff[:]) 897 898 body := io.TeeReader(errorBody, ringBuffer) 899 decoder := json.NewDecoder(body) 900 decoder.UseNumber() 901 code, message, err := restjson.GetErrorInfo(decoder) 902 if err != nil { 903 var snapshot bytes.Buffer 904 io.Copy(&snapshot, ringBuffer) 905 err = &smithy.DeserializationError{ 906 Err: fmt.Errorf("failed to decode response body, %w", err), 907 Snapshot: snapshot.Bytes(), 908 } 909 return err 910 } 911 912 errorBody.Seek(0, io.SeekStart) 913 if len(code) != 0 { 914 errorCode = restjson.SanitizeErrorCode(code) 915 } 916 if len(message) != 0 { 917 errorMessage = message 918 } 919 920 switch { 921 case strings.EqualFold("AccessDeniedException", errorCode): 922 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 923 924 case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode): 925 return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody) 926 927 case strings.EqualFold("ConcurrentModificationException", errorCode): 928 return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody) 929 930 case strings.EqualFold("ConstraintViolationException", errorCode): 931 return awsAwsjson11_deserializeErrorConstraintViolationException(response, errorBody) 932 933 case strings.EqualFold("DuplicateOrganizationalUnitException", errorCode): 934 return awsAwsjson11_deserializeErrorDuplicateOrganizationalUnitException(response, errorBody) 935 936 case strings.EqualFold("InvalidInputException", errorCode): 937 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 938 939 case strings.EqualFold("ParentNotFoundException", errorCode): 940 return awsAwsjson11_deserializeErrorParentNotFoundException(response, errorBody) 941 942 case strings.EqualFold("ServiceException", errorCode): 943 return awsAwsjson11_deserializeErrorServiceException(response, errorBody) 944 945 case strings.EqualFold("TooManyRequestsException", errorCode): 946 return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody) 947 948 default: 949 genericError := &smithy.GenericAPIError{ 950 Code: errorCode, 951 Message: errorMessage, 952 } 953 return genericError 954 955 } 956} 957 958type awsAwsjson11_deserializeOpCreatePolicy struct { 959} 960 961func (*awsAwsjson11_deserializeOpCreatePolicy) ID() string { 962 return "OperationDeserializer" 963} 964 965func (m *awsAwsjson11_deserializeOpCreatePolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 966 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 967) { 968 out, metadata, err = next.HandleDeserialize(ctx, in) 969 if err != nil { 970 return out, metadata, err 971 } 972 973 response, ok := out.RawResponse.(*smithyhttp.Response) 974 if !ok { 975 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 976 } 977 978 if response.StatusCode < 200 || response.StatusCode >= 300 { 979 return out, metadata, awsAwsjson11_deserializeOpErrorCreatePolicy(response, &metadata) 980 } 981 output := &CreatePolicyOutput{} 982 out.Result = output 983 984 var buff [1024]byte 985 ringBuffer := smithyio.NewRingBuffer(buff[:]) 986 987 body := io.TeeReader(response.Body, ringBuffer) 988 decoder := json.NewDecoder(body) 989 decoder.UseNumber() 990 var shape interface{} 991 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 992 var snapshot bytes.Buffer 993 io.Copy(&snapshot, ringBuffer) 994 err = &smithy.DeserializationError{ 995 Err: fmt.Errorf("failed to decode response body, %w", err), 996 Snapshot: snapshot.Bytes(), 997 } 998 return out, metadata, err 999 } 1000 1001 err = awsAwsjson11_deserializeOpDocumentCreatePolicyOutput(&output, shape) 1002 if err != nil { 1003 var snapshot bytes.Buffer 1004 io.Copy(&snapshot, ringBuffer) 1005 err = &smithy.DeserializationError{ 1006 Err: fmt.Errorf("failed to decode response body, %w", err), 1007 Snapshot: snapshot.Bytes(), 1008 } 1009 return out, metadata, err 1010 } 1011 1012 return out, metadata, err 1013} 1014 1015func awsAwsjson11_deserializeOpErrorCreatePolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1016 var errorBuffer bytes.Buffer 1017 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1018 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1019 } 1020 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1021 1022 errorCode := "UnknownError" 1023 errorMessage := errorCode 1024 1025 code := response.Header.Get("X-Amzn-ErrorType") 1026 if len(code) != 0 { 1027 errorCode = restjson.SanitizeErrorCode(code) 1028 } 1029 1030 var buff [1024]byte 1031 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1032 1033 body := io.TeeReader(errorBody, ringBuffer) 1034 decoder := json.NewDecoder(body) 1035 decoder.UseNumber() 1036 code, message, err := restjson.GetErrorInfo(decoder) 1037 if err != nil { 1038 var snapshot bytes.Buffer 1039 io.Copy(&snapshot, ringBuffer) 1040 err = &smithy.DeserializationError{ 1041 Err: fmt.Errorf("failed to decode response body, %w", err), 1042 Snapshot: snapshot.Bytes(), 1043 } 1044 return err 1045 } 1046 1047 errorBody.Seek(0, io.SeekStart) 1048 if len(code) != 0 { 1049 errorCode = restjson.SanitizeErrorCode(code) 1050 } 1051 if len(message) != 0 { 1052 errorMessage = message 1053 } 1054 1055 switch { 1056 case strings.EqualFold("AccessDeniedException", errorCode): 1057 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 1058 1059 case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode): 1060 return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody) 1061 1062 case strings.EqualFold("ConcurrentModificationException", errorCode): 1063 return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody) 1064 1065 case strings.EqualFold("ConstraintViolationException", errorCode): 1066 return awsAwsjson11_deserializeErrorConstraintViolationException(response, errorBody) 1067 1068 case strings.EqualFold("DuplicatePolicyException", errorCode): 1069 return awsAwsjson11_deserializeErrorDuplicatePolicyException(response, errorBody) 1070 1071 case strings.EqualFold("InvalidInputException", errorCode): 1072 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 1073 1074 case strings.EqualFold("MalformedPolicyDocumentException", errorCode): 1075 return awsAwsjson11_deserializeErrorMalformedPolicyDocumentException(response, errorBody) 1076 1077 case strings.EqualFold("PolicyTypeNotAvailableForOrganizationException", errorCode): 1078 return awsAwsjson11_deserializeErrorPolicyTypeNotAvailableForOrganizationException(response, errorBody) 1079 1080 case strings.EqualFold("ServiceException", errorCode): 1081 return awsAwsjson11_deserializeErrorServiceException(response, errorBody) 1082 1083 case strings.EqualFold("TooManyRequestsException", errorCode): 1084 return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody) 1085 1086 case strings.EqualFold("UnsupportedAPIEndpointException", errorCode): 1087 return awsAwsjson11_deserializeErrorUnsupportedAPIEndpointException(response, errorBody) 1088 1089 default: 1090 genericError := &smithy.GenericAPIError{ 1091 Code: errorCode, 1092 Message: errorMessage, 1093 } 1094 return genericError 1095 1096 } 1097} 1098 1099type awsAwsjson11_deserializeOpDeclineHandshake struct { 1100} 1101 1102func (*awsAwsjson11_deserializeOpDeclineHandshake) ID() string { 1103 return "OperationDeserializer" 1104} 1105 1106func (m *awsAwsjson11_deserializeOpDeclineHandshake) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1107 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1108) { 1109 out, metadata, err = next.HandleDeserialize(ctx, in) 1110 if err != nil { 1111 return out, metadata, err 1112 } 1113 1114 response, ok := out.RawResponse.(*smithyhttp.Response) 1115 if !ok { 1116 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1117 } 1118 1119 if response.StatusCode < 200 || response.StatusCode >= 300 { 1120 return out, metadata, awsAwsjson11_deserializeOpErrorDeclineHandshake(response, &metadata) 1121 } 1122 output := &DeclineHandshakeOutput{} 1123 out.Result = output 1124 1125 var buff [1024]byte 1126 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1127 1128 body := io.TeeReader(response.Body, ringBuffer) 1129 decoder := json.NewDecoder(body) 1130 decoder.UseNumber() 1131 var shape interface{} 1132 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1133 var snapshot bytes.Buffer 1134 io.Copy(&snapshot, ringBuffer) 1135 err = &smithy.DeserializationError{ 1136 Err: fmt.Errorf("failed to decode response body, %w", err), 1137 Snapshot: snapshot.Bytes(), 1138 } 1139 return out, metadata, err 1140 } 1141 1142 err = awsAwsjson11_deserializeOpDocumentDeclineHandshakeOutput(&output, shape) 1143 if err != nil { 1144 var snapshot bytes.Buffer 1145 io.Copy(&snapshot, ringBuffer) 1146 err = &smithy.DeserializationError{ 1147 Err: fmt.Errorf("failed to decode response body, %w", err), 1148 Snapshot: snapshot.Bytes(), 1149 } 1150 return out, metadata, err 1151 } 1152 1153 return out, metadata, err 1154} 1155 1156func awsAwsjson11_deserializeOpErrorDeclineHandshake(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1157 var errorBuffer bytes.Buffer 1158 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1159 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1160 } 1161 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1162 1163 errorCode := "UnknownError" 1164 errorMessage := errorCode 1165 1166 code := response.Header.Get("X-Amzn-ErrorType") 1167 if len(code) != 0 { 1168 errorCode = restjson.SanitizeErrorCode(code) 1169 } 1170 1171 var buff [1024]byte 1172 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1173 1174 body := io.TeeReader(errorBody, ringBuffer) 1175 decoder := json.NewDecoder(body) 1176 decoder.UseNumber() 1177 code, message, err := restjson.GetErrorInfo(decoder) 1178 if err != nil { 1179 var snapshot bytes.Buffer 1180 io.Copy(&snapshot, ringBuffer) 1181 err = &smithy.DeserializationError{ 1182 Err: fmt.Errorf("failed to decode response body, %w", err), 1183 Snapshot: snapshot.Bytes(), 1184 } 1185 return err 1186 } 1187 1188 errorBody.Seek(0, io.SeekStart) 1189 if len(code) != 0 { 1190 errorCode = restjson.SanitizeErrorCode(code) 1191 } 1192 if len(message) != 0 { 1193 errorMessage = message 1194 } 1195 1196 switch { 1197 case strings.EqualFold("AccessDeniedException", errorCode): 1198 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 1199 1200 case strings.EqualFold("ConcurrentModificationException", errorCode): 1201 return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody) 1202 1203 case strings.EqualFold("HandshakeAlreadyInStateException", errorCode): 1204 return awsAwsjson11_deserializeErrorHandshakeAlreadyInStateException(response, errorBody) 1205 1206 case strings.EqualFold("HandshakeNotFoundException", errorCode): 1207 return awsAwsjson11_deserializeErrorHandshakeNotFoundException(response, errorBody) 1208 1209 case strings.EqualFold("InvalidHandshakeTransitionException", errorCode): 1210 return awsAwsjson11_deserializeErrorInvalidHandshakeTransitionException(response, errorBody) 1211 1212 case strings.EqualFold("InvalidInputException", errorCode): 1213 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 1214 1215 case strings.EqualFold("ServiceException", errorCode): 1216 return awsAwsjson11_deserializeErrorServiceException(response, errorBody) 1217 1218 case strings.EqualFold("TooManyRequestsException", errorCode): 1219 return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody) 1220 1221 default: 1222 genericError := &smithy.GenericAPIError{ 1223 Code: errorCode, 1224 Message: errorMessage, 1225 } 1226 return genericError 1227 1228 } 1229} 1230 1231type awsAwsjson11_deserializeOpDeleteOrganization struct { 1232} 1233 1234func (*awsAwsjson11_deserializeOpDeleteOrganization) ID() string { 1235 return "OperationDeserializer" 1236} 1237 1238func (m *awsAwsjson11_deserializeOpDeleteOrganization) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1239 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1240) { 1241 out, metadata, err = next.HandleDeserialize(ctx, in) 1242 if err != nil { 1243 return out, metadata, err 1244 } 1245 1246 response, ok := out.RawResponse.(*smithyhttp.Response) 1247 if !ok { 1248 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1249 } 1250 1251 if response.StatusCode < 200 || response.StatusCode >= 300 { 1252 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteOrganization(response, &metadata) 1253 } 1254 output := &DeleteOrganizationOutput{} 1255 out.Result = output 1256 1257 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 1258 return out, metadata, &smithy.DeserializationError{ 1259 Err: fmt.Errorf("failed to discard response body, %w", err), 1260 } 1261 } 1262 1263 return out, metadata, err 1264} 1265 1266func awsAwsjson11_deserializeOpErrorDeleteOrganization(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1267 var errorBuffer bytes.Buffer 1268 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1269 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1270 } 1271 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1272 1273 errorCode := "UnknownError" 1274 errorMessage := errorCode 1275 1276 code := response.Header.Get("X-Amzn-ErrorType") 1277 if len(code) != 0 { 1278 errorCode = restjson.SanitizeErrorCode(code) 1279 } 1280 1281 var buff [1024]byte 1282 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1283 1284 body := io.TeeReader(errorBody, ringBuffer) 1285 decoder := json.NewDecoder(body) 1286 decoder.UseNumber() 1287 code, message, err := restjson.GetErrorInfo(decoder) 1288 if err != nil { 1289 var snapshot bytes.Buffer 1290 io.Copy(&snapshot, ringBuffer) 1291 err = &smithy.DeserializationError{ 1292 Err: fmt.Errorf("failed to decode response body, %w", err), 1293 Snapshot: snapshot.Bytes(), 1294 } 1295 return err 1296 } 1297 1298 errorBody.Seek(0, io.SeekStart) 1299 if len(code) != 0 { 1300 errorCode = restjson.SanitizeErrorCode(code) 1301 } 1302 if len(message) != 0 { 1303 errorMessage = message 1304 } 1305 1306 switch { 1307 case strings.EqualFold("AccessDeniedException", errorCode): 1308 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 1309 1310 case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode): 1311 return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody) 1312 1313 case strings.EqualFold("ConcurrentModificationException", errorCode): 1314 return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody) 1315 1316 case strings.EqualFold("InvalidInputException", errorCode): 1317 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 1318 1319 case strings.EqualFold("OrganizationNotEmptyException", errorCode): 1320 return awsAwsjson11_deserializeErrorOrganizationNotEmptyException(response, errorBody) 1321 1322 case strings.EqualFold("ServiceException", errorCode): 1323 return awsAwsjson11_deserializeErrorServiceException(response, errorBody) 1324 1325 case strings.EqualFold("TooManyRequestsException", errorCode): 1326 return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody) 1327 1328 default: 1329 genericError := &smithy.GenericAPIError{ 1330 Code: errorCode, 1331 Message: errorMessage, 1332 } 1333 return genericError 1334 1335 } 1336} 1337 1338type awsAwsjson11_deserializeOpDeleteOrganizationalUnit struct { 1339} 1340 1341func (*awsAwsjson11_deserializeOpDeleteOrganizationalUnit) ID() string { 1342 return "OperationDeserializer" 1343} 1344 1345func (m *awsAwsjson11_deserializeOpDeleteOrganizationalUnit) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1346 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1347) { 1348 out, metadata, err = next.HandleDeserialize(ctx, in) 1349 if err != nil { 1350 return out, metadata, err 1351 } 1352 1353 response, ok := out.RawResponse.(*smithyhttp.Response) 1354 if !ok { 1355 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1356 } 1357 1358 if response.StatusCode < 200 || response.StatusCode >= 300 { 1359 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteOrganizationalUnit(response, &metadata) 1360 } 1361 output := &DeleteOrganizationalUnitOutput{} 1362 out.Result = output 1363 1364 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 1365 return out, metadata, &smithy.DeserializationError{ 1366 Err: fmt.Errorf("failed to discard response body, %w", err), 1367 } 1368 } 1369 1370 return out, metadata, err 1371} 1372 1373func awsAwsjson11_deserializeOpErrorDeleteOrganizationalUnit(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1374 var errorBuffer bytes.Buffer 1375 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1376 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1377 } 1378 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1379 1380 errorCode := "UnknownError" 1381 errorMessage := errorCode 1382 1383 code := response.Header.Get("X-Amzn-ErrorType") 1384 if len(code) != 0 { 1385 errorCode = restjson.SanitizeErrorCode(code) 1386 } 1387 1388 var buff [1024]byte 1389 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1390 1391 body := io.TeeReader(errorBody, ringBuffer) 1392 decoder := json.NewDecoder(body) 1393 decoder.UseNumber() 1394 code, message, err := restjson.GetErrorInfo(decoder) 1395 if err != nil { 1396 var snapshot bytes.Buffer 1397 io.Copy(&snapshot, ringBuffer) 1398 err = &smithy.DeserializationError{ 1399 Err: fmt.Errorf("failed to decode response body, %w", err), 1400 Snapshot: snapshot.Bytes(), 1401 } 1402 return err 1403 } 1404 1405 errorBody.Seek(0, io.SeekStart) 1406 if len(code) != 0 { 1407 errorCode = restjson.SanitizeErrorCode(code) 1408 } 1409 if len(message) != 0 { 1410 errorMessage = message 1411 } 1412 1413 switch { 1414 case strings.EqualFold("AccessDeniedException", errorCode): 1415 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 1416 1417 case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode): 1418 return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody) 1419 1420 case strings.EqualFold("ConcurrentModificationException", errorCode): 1421 return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody) 1422 1423 case strings.EqualFold("InvalidInputException", errorCode): 1424 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 1425 1426 case strings.EqualFold("OrganizationalUnitNotEmptyException", errorCode): 1427 return awsAwsjson11_deserializeErrorOrganizationalUnitNotEmptyException(response, errorBody) 1428 1429 case strings.EqualFold("OrganizationalUnitNotFoundException", errorCode): 1430 return awsAwsjson11_deserializeErrorOrganizationalUnitNotFoundException(response, errorBody) 1431 1432 case strings.EqualFold("ServiceException", errorCode): 1433 return awsAwsjson11_deserializeErrorServiceException(response, errorBody) 1434 1435 case strings.EqualFold("TooManyRequestsException", errorCode): 1436 return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody) 1437 1438 default: 1439 genericError := &smithy.GenericAPIError{ 1440 Code: errorCode, 1441 Message: errorMessage, 1442 } 1443 return genericError 1444 1445 } 1446} 1447 1448type awsAwsjson11_deserializeOpDeletePolicy struct { 1449} 1450 1451func (*awsAwsjson11_deserializeOpDeletePolicy) ID() string { 1452 return "OperationDeserializer" 1453} 1454 1455func (m *awsAwsjson11_deserializeOpDeletePolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1456 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1457) { 1458 out, metadata, err = next.HandleDeserialize(ctx, in) 1459 if err != nil { 1460 return out, metadata, err 1461 } 1462 1463 response, ok := out.RawResponse.(*smithyhttp.Response) 1464 if !ok { 1465 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1466 } 1467 1468 if response.StatusCode < 200 || response.StatusCode >= 300 { 1469 return out, metadata, awsAwsjson11_deserializeOpErrorDeletePolicy(response, &metadata) 1470 } 1471 output := &DeletePolicyOutput{} 1472 out.Result = output 1473 1474 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 1475 return out, metadata, &smithy.DeserializationError{ 1476 Err: fmt.Errorf("failed to discard response body, %w", err), 1477 } 1478 } 1479 1480 return out, metadata, err 1481} 1482 1483func awsAwsjson11_deserializeOpErrorDeletePolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1484 var errorBuffer bytes.Buffer 1485 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1486 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1487 } 1488 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1489 1490 errorCode := "UnknownError" 1491 errorMessage := errorCode 1492 1493 code := response.Header.Get("X-Amzn-ErrorType") 1494 if len(code) != 0 { 1495 errorCode = restjson.SanitizeErrorCode(code) 1496 } 1497 1498 var buff [1024]byte 1499 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1500 1501 body := io.TeeReader(errorBody, ringBuffer) 1502 decoder := json.NewDecoder(body) 1503 decoder.UseNumber() 1504 code, message, err := restjson.GetErrorInfo(decoder) 1505 if err != nil { 1506 var snapshot bytes.Buffer 1507 io.Copy(&snapshot, ringBuffer) 1508 err = &smithy.DeserializationError{ 1509 Err: fmt.Errorf("failed to decode response body, %w", err), 1510 Snapshot: snapshot.Bytes(), 1511 } 1512 return err 1513 } 1514 1515 errorBody.Seek(0, io.SeekStart) 1516 if len(code) != 0 { 1517 errorCode = restjson.SanitizeErrorCode(code) 1518 } 1519 if len(message) != 0 { 1520 errorMessage = message 1521 } 1522 1523 switch { 1524 case strings.EqualFold("AccessDeniedException", errorCode): 1525 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 1526 1527 case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode): 1528 return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody) 1529 1530 case strings.EqualFold("ConcurrentModificationException", errorCode): 1531 return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody) 1532 1533 case strings.EqualFold("InvalidInputException", errorCode): 1534 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 1535 1536 case strings.EqualFold("PolicyInUseException", errorCode): 1537 return awsAwsjson11_deserializeErrorPolicyInUseException(response, errorBody) 1538 1539 case strings.EqualFold("PolicyNotFoundException", errorCode): 1540 return awsAwsjson11_deserializeErrorPolicyNotFoundException(response, errorBody) 1541 1542 case strings.EqualFold("ServiceException", errorCode): 1543 return awsAwsjson11_deserializeErrorServiceException(response, errorBody) 1544 1545 case strings.EqualFold("TooManyRequestsException", errorCode): 1546 return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody) 1547 1548 case strings.EqualFold("UnsupportedAPIEndpointException", errorCode): 1549 return awsAwsjson11_deserializeErrorUnsupportedAPIEndpointException(response, errorBody) 1550 1551 default: 1552 genericError := &smithy.GenericAPIError{ 1553 Code: errorCode, 1554 Message: errorMessage, 1555 } 1556 return genericError 1557 1558 } 1559} 1560 1561type awsAwsjson11_deserializeOpDeregisterDelegatedAdministrator struct { 1562} 1563 1564func (*awsAwsjson11_deserializeOpDeregisterDelegatedAdministrator) ID() string { 1565 return "OperationDeserializer" 1566} 1567 1568func (m *awsAwsjson11_deserializeOpDeregisterDelegatedAdministrator) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1569 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1570) { 1571 out, metadata, err = next.HandleDeserialize(ctx, in) 1572 if err != nil { 1573 return out, metadata, err 1574 } 1575 1576 response, ok := out.RawResponse.(*smithyhttp.Response) 1577 if !ok { 1578 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1579 } 1580 1581 if response.StatusCode < 200 || response.StatusCode >= 300 { 1582 return out, metadata, awsAwsjson11_deserializeOpErrorDeregisterDelegatedAdministrator(response, &metadata) 1583 } 1584 output := &DeregisterDelegatedAdministratorOutput{} 1585 out.Result = output 1586 1587 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 1588 return out, metadata, &smithy.DeserializationError{ 1589 Err: fmt.Errorf("failed to discard response body, %w", err), 1590 } 1591 } 1592 1593 return out, metadata, err 1594} 1595 1596func awsAwsjson11_deserializeOpErrorDeregisterDelegatedAdministrator(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1597 var errorBuffer bytes.Buffer 1598 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1599 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1600 } 1601 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1602 1603 errorCode := "UnknownError" 1604 errorMessage := errorCode 1605 1606 code := response.Header.Get("X-Amzn-ErrorType") 1607 if len(code) != 0 { 1608 errorCode = restjson.SanitizeErrorCode(code) 1609 } 1610 1611 var buff [1024]byte 1612 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1613 1614 body := io.TeeReader(errorBody, ringBuffer) 1615 decoder := json.NewDecoder(body) 1616 decoder.UseNumber() 1617 code, message, err := restjson.GetErrorInfo(decoder) 1618 if err != nil { 1619 var snapshot bytes.Buffer 1620 io.Copy(&snapshot, ringBuffer) 1621 err = &smithy.DeserializationError{ 1622 Err: fmt.Errorf("failed to decode response body, %w", err), 1623 Snapshot: snapshot.Bytes(), 1624 } 1625 return err 1626 } 1627 1628 errorBody.Seek(0, io.SeekStart) 1629 if len(code) != 0 { 1630 errorCode = restjson.SanitizeErrorCode(code) 1631 } 1632 if len(message) != 0 { 1633 errorMessage = message 1634 } 1635 1636 switch { 1637 case strings.EqualFold("AccessDeniedException", errorCode): 1638 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 1639 1640 case strings.EqualFold("AccountNotFoundException", errorCode): 1641 return awsAwsjson11_deserializeErrorAccountNotFoundException(response, errorBody) 1642 1643 case strings.EqualFold("AccountNotRegisteredException", errorCode): 1644 return awsAwsjson11_deserializeErrorAccountNotRegisteredException(response, errorBody) 1645 1646 case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode): 1647 return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody) 1648 1649 case strings.EqualFold("ConcurrentModificationException", errorCode): 1650 return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody) 1651 1652 case strings.EqualFold("ConstraintViolationException", errorCode): 1653 return awsAwsjson11_deserializeErrorConstraintViolationException(response, errorBody) 1654 1655 case strings.EqualFold("InvalidInputException", errorCode): 1656 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 1657 1658 case strings.EqualFold("ServiceException", errorCode): 1659 return awsAwsjson11_deserializeErrorServiceException(response, errorBody) 1660 1661 case strings.EqualFold("TooManyRequestsException", errorCode): 1662 return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody) 1663 1664 case strings.EqualFold("UnsupportedAPIEndpointException", errorCode): 1665 return awsAwsjson11_deserializeErrorUnsupportedAPIEndpointException(response, errorBody) 1666 1667 default: 1668 genericError := &smithy.GenericAPIError{ 1669 Code: errorCode, 1670 Message: errorMessage, 1671 } 1672 return genericError 1673 1674 } 1675} 1676 1677type awsAwsjson11_deserializeOpDescribeAccount struct { 1678} 1679 1680func (*awsAwsjson11_deserializeOpDescribeAccount) ID() string { 1681 return "OperationDeserializer" 1682} 1683 1684func (m *awsAwsjson11_deserializeOpDescribeAccount) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1685 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1686) { 1687 out, metadata, err = next.HandleDeserialize(ctx, in) 1688 if err != nil { 1689 return out, metadata, err 1690 } 1691 1692 response, ok := out.RawResponse.(*smithyhttp.Response) 1693 if !ok { 1694 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1695 } 1696 1697 if response.StatusCode < 200 || response.StatusCode >= 300 { 1698 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeAccount(response, &metadata) 1699 } 1700 output := &DescribeAccountOutput{} 1701 out.Result = output 1702 1703 var buff [1024]byte 1704 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1705 1706 body := io.TeeReader(response.Body, ringBuffer) 1707 decoder := json.NewDecoder(body) 1708 decoder.UseNumber() 1709 var shape interface{} 1710 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1711 var snapshot bytes.Buffer 1712 io.Copy(&snapshot, ringBuffer) 1713 err = &smithy.DeserializationError{ 1714 Err: fmt.Errorf("failed to decode response body, %w", err), 1715 Snapshot: snapshot.Bytes(), 1716 } 1717 return out, metadata, err 1718 } 1719 1720 err = awsAwsjson11_deserializeOpDocumentDescribeAccountOutput(&output, shape) 1721 if err != nil { 1722 var snapshot bytes.Buffer 1723 io.Copy(&snapshot, ringBuffer) 1724 err = &smithy.DeserializationError{ 1725 Err: fmt.Errorf("failed to decode response body, %w", err), 1726 Snapshot: snapshot.Bytes(), 1727 } 1728 return out, metadata, err 1729 } 1730 1731 return out, metadata, err 1732} 1733 1734func awsAwsjson11_deserializeOpErrorDescribeAccount(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1735 var errorBuffer bytes.Buffer 1736 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1737 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1738 } 1739 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1740 1741 errorCode := "UnknownError" 1742 errorMessage := errorCode 1743 1744 code := response.Header.Get("X-Amzn-ErrorType") 1745 if len(code) != 0 { 1746 errorCode = restjson.SanitizeErrorCode(code) 1747 } 1748 1749 var buff [1024]byte 1750 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1751 1752 body := io.TeeReader(errorBody, ringBuffer) 1753 decoder := json.NewDecoder(body) 1754 decoder.UseNumber() 1755 code, message, err := restjson.GetErrorInfo(decoder) 1756 if err != nil { 1757 var snapshot bytes.Buffer 1758 io.Copy(&snapshot, ringBuffer) 1759 err = &smithy.DeserializationError{ 1760 Err: fmt.Errorf("failed to decode response body, %w", err), 1761 Snapshot: snapshot.Bytes(), 1762 } 1763 return err 1764 } 1765 1766 errorBody.Seek(0, io.SeekStart) 1767 if len(code) != 0 { 1768 errorCode = restjson.SanitizeErrorCode(code) 1769 } 1770 if len(message) != 0 { 1771 errorMessage = message 1772 } 1773 1774 switch { 1775 case strings.EqualFold("AccessDeniedException", errorCode): 1776 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 1777 1778 case strings.EqualFold("AccountNotFoundException", errorCode): 1779 return awsAwsjson11_deserializeErrorAccountNotFoundException(response, errorBody) 1780 1781 case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode): 1782 return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody) 1783 1784 case strings.EqualFold("InvalidInputException", errorCode): 1785 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 1786 1787 case strings.EqualFold("ServiceException", errorCode): 1788 return awsAwsjson11_deserializeErrorServiceException(response, errorBody) 1789 1790 case strings.EqualFold("TooManyRequestsException", errorCode): 1791 return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody) 1792 1793 default: 1794 genericError := &smithy.GenericAPIError{ 1795 Code: errorCode, 1796 Message: errorMessage, 1797 } 1798 return genericError 1799 1800 } 1801} 1802 1803type awsAwsjson11_deserializeOpDescribeCreateAccountStatus struct { 1804} 1805 1806func (*awsAwsjson11_deserializeOpDescribeCreateAccountStatus) ID() string { 1807 return "OperationDeserializer" 1808} 1809 1810func (m *awsAwsjson11_deserializeOpDescribeCreateAccountStatus) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1811 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1812) { 1813 out, metadata, err = next.HandleDeserialize(ctx, in) 1814 if err != nil { 1815 return out, metadata, err 1816 } 1817 1818 response, ok := out.RawResponse.(*smithyhttp.Response) 1819 if !ok { 1820 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1821 } 1822 1823 if response.StatusCode < 200 || response.StatusCode >= 300 { 1824 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeCreateAccountStatus(response, &metadata) 1825 } 1826 output := &DescribeCreateAccountStatusOutput{} 1827 out.Result = output 1828 1829 var buff [1024]byte 1830 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1831 1832 body := io.TeeReader(response.Body, ringBuffer) 1833 decoder := json.NewDecoder(body) 1834 decoder.UseNumber() 1835 var shape interface{} 1836 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1837 var snapshot bytes.Buffer 1838 io.Copy(&snapshot, ringBuffer) 1839 err = &smithy.DeserializationError{ 1840 Err: fmt.Errorf("failed to decode response body, %w", err), 1841 Snapshot: snapshot.Bytes(), 1842 } 1843 return out, metadata, err 1844 } 1845 1846 err = awsAwsjson11_deserializeOpDocumentDescribeCreateAccountStatusOutput(&output, shape) 1847 if err != nil { 1848 var snapshot bytes.Buffer 1849 io.Copy(&snapshot, ringBuffer) 1850 err = &smithy.DeserializationError{ 1851 Err: fmt.Errorf("failed to decode response body, %w", err), 1852 Snapshot: snapshot.Bytes(), 1853 } 1854 return out, metadata, err 1855 } 1856 1857 return out, metadata, err 1858} 1859 1860func awsAwsjson11_deserializeOpErrorDescribeCreateAccountStatus(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1861 var errorBuffer bytes.Buffer 1862 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1863 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1864 } 1865 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1866 1867 errorCode := "UnknownError" 1868 errorMessage := errorCode 1869 1870 code := response.Header.Get("X-Amzn-ErrorType") 1871 if len(code) != 0 { 1872 errorCode = restjson.SanitizeErrorCode(code) 1873 } 1874 1875 var buff [1024]byte 1876 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1877 1878 body := io.TeeReader(errorBody, ringBuffer) 1879 decoder := json.NewDecoder(body) 1880 decoder.UseNumber() 1881 code, message, err := restjson.GetErrorInfo(decoder) 1882 if err != nil { 1883 var snapshot bytes.Buffer 1884 io.Copy(&snapshot, ringBuffer) 1885 err = &smithy.DeserializationError{ 1886 Err: fmt.Errorf("failed to decode response body, %w", err), 1887 Snapshot: snapshot.Bytes(), 1888 } 1889 return err 1890 } 1891 1892 errorBody.Seek(0, io.SeekStart) 1893 if len(code) != 0 { 1894 errorCode = restjson.SanitizeErrorCode(code) 1895 } 1896 if len(message) != 0 { 1897 errorMessage = message 1898 } 1899 1900 switch { 1901 case strings.EqualFold("AccessDeniedException", errorCode): 1902 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 1903 1904 case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode): 1905 return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody) 1906 1907 case strings.EqualFold("CreateAccountStatusNotFoundException", errorCode): 1908 return awsAwsjson11_deserializeErrorCreateAccountStatusNotFoundException(response, errorBody) 1909 1910 case strings.EqualFold("InvalidInputException", errorCode): 1911 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 1912 1913 case strings.EqualFold("ServiceException", errorCode): 1914 return awsAwsjson11_deserializeErrorServiceException(response, errorBody) 1915 1916 case strings.EqualFold("TooManyRequestsException", errorCode): 1917 return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody) 1918 1919 case strings.EqualFold("UnsupportedAPIEndpointException", errorCode): 1920 return awsAwsjson11_deserializeErrorUnsupportedAPIEndpointException(response, errorBody) 1921 1922 default: 1923 genericError := &smithy.GenericAPIError{ 1924 Code: errorCode, 1925 Message: errorMessage, 1926 } 1927 return genericError 1928 1929 } 1930} 1931 1932type awsAwsjson11_deserializeOpDescribeEffectivePolicy struct { 1933} 1934 1935func (*awsAwsjson11_deserializeOpDescribeEffectivePolicy) ID() string { 1936 return "OperationDeserializer" 1937} 1938 1939func (m *awsAwsjson11_deserializeOpDescribeEffectivePolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1940 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1941) { 1942 out, metadata, err = next.HandleDeserialize(ctx, in) 1943 if err != nil { 1944 return out, metadata, err 1945 } 1946 1947 response, ok := out.RawResponse.(*smithyhttp.Response) 1948 if !ok { 1949 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1950 } 1951 1952 if response.StatusCode < 200 || response.StatusCode >= 300 { 1953 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeEffectivePolicy(response, &metadata) 1954 } 1955 output := &DescribeEffectivePolicyOutput{} 1956 out.Result = output 1957 1958 var buff [1024]byte 1959 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1960 1961 body := io.TeeReader(response.Body, ringBuffer) 1962 decoder := json.NewDecoder(body) 1963 decoder.UseNumber() 1964 var shape interface{} 1965 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1966 var snapshot bytes.Buffer 1967 io.Copy(&snapshot, ringBuffer) 1968 err = &smithy.DeserializationError{ 1969 Err: fmt.Errorf("failed to decode response body, %w", err), 1970 Snapshot: snapshot.Bytes(), 1971 } 1972 return out, metadata, err 1973 } 1974 1975 err = awsAwsjson11_deserializeOpDocumentDescribeEffectivePolicyOutput(&output, shape) 1976 if err != nil { 1977 var snapshot bytes.Buffer 1978 io.Copy(&snapshot, ringBuffer) 1979 err = &smithy.DeserializationError{ 1980 Err: fmt.Errorf("failed to decode response body, %w", err), 1981 Snapshot: snapshot.Bytes(), 1982 } 1983 return out, metadata, err 1984 } 1985 1986 return out, metadata, err 1987} 1988 1989func awsAwsjson11_deserializeOpErrorDescribeEffectivePolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1990 var errorBuffer bytes.Buffer 1991 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1992 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1993 } 1994 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1995 1996 errorCode := "UnknownError" 1997 errorMessage := errorCode 1998 1999 code := response.Header.Get("X-Amzn-ErrorType") 2000 if len(code) != 0 { 2001 errorCode = restjson.SanitizeErrorCode(code) 2002 } 2003 2004 var buff [1024]byte 2005 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2006 2007 body := io.TeeReader(errorBody, ringBuffer) 2008 decoder := json.NewDecoder(body) 2009 decoder.UseNumber() 2010 code, message, err := restjson.GetErrorInfo(decoder) 2011 if err != nil { 2012 var snapshot bytes.Buffer 2013 io.Copy(&snapshot, ringBuffer) 2014 err = &smithy.DeserializationError{ 2015 Err: fmt.Errorf("failed to decode response body, %w", err), 2016 Snapshot: snapshot.Bytes(), 2017 } 2018 return err 2019 } 2020 2021 errorBody.Seek(0, io.SeekStart) 2022 if len(code) != 0 { 2023 errorCode = restjson.SanitizeErrorCode(code) 2024 } 2025 if len(message) != 0 { 2026 errorMessage = message 2027 } 2028 2029 switch { 2030 case strings.EqualFold("AccessDeniedException", errorCode): 2031 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 2032 2033 case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode): 2034 return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody) 2035 2036 case strings.EqualFold("ConstraintViolationException", errorCode): 2037 return awsAwsjson11_deserializeErrorConstraintViolationException(response, errorBody) 2038 2039 case strings.EqualFold("EffectivePolicyNotFoundException", errorCode): 2040 return awsAwsjson11_deserializeErrorEffectivePolicyNotFoundException(response, errorBody) 2041 2042 case strings.EqualFold("InvalidInputException", errorCode): 2043 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 2044 2045 case strings.EqualFold("ServiceException", errorCode): 2046 return awsAwsjson11_deserializeErrorServiceException(response, errorBody) 2047 2048 case strings.EqualFold("TargetNotFoundException", errorCode): 2049 return awsAwsjson11_deserializeErrorTargetNotFoundException(response, errorBody) 2050 2051 case strings.EqualFold("TooManyRequestsException", errorCode): 2052 return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody) 2053 2054 case strings.EqualFold("UnsupportedAPIEndpointException", errorCode): 2055 return awsAwsjson11_deserializeErrorUnsupportedAPIEndpointException(response, errorBody) 2056 2057 default: 2058 genericError := &smithy.GenericAPIError{ 2059 Code: errorCode, 2060 Message: errorMessage, 2061 } 2062 return genericError 2063 2064 } 2065} 2066 2067type awsAwsjson11_deserializeOpDescribeHandshake struct { 2068} 2069 2070func (*awsAwsjson11_deserializeOpDescribeHandshake) ID() string { 2071 return "OperationDeserializer" 2072} 2073 2074func (m *awsAwsjson11_deserializeOpDescribeHandshake) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2075 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2076) { 2077 out, metadata, err = next.HandleDeserialize(ctx, in) 2078 if err != nil { 2079 return out, metadata, err 2080 } 2081 2082 response, ok := out.RawResponse.(*smithyhttp.Response) 2083 if !ok { 2084 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2085 } 2086 2087 if response.StatusCode < 200 || response.StatusCode >= 300 { 2088 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeHandshake(response, &metadata) 2089 } 2090 output := &DescribeHandshakeOutput{} 2091 out.Result = output 2092 2093 var buff [1024]byte 2094 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2095 2096 body := io.TeeReader(response.Body, ringBuffer) 2097 decoder := json.NewDecoder(body) 2098 decoder.UseNumber() 2099 var shape interface{} 2100 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2101 var snapshot bytes.Buffer 2102 io.Copy(&snapshot, ringBuffer) 2103 err = &smithy.DeserializationError{ 2104 Err: fmt.Errorf("failed to decode response body, %w", err), 2105 Snapshot: snapshot.Bytes(), 2106 } 2107 return out, metadata, err 2108 } 2109 2110 err = awsAwsjson11_deserializeOpDocumentDescribeHandshakeOutput(&output, shape) 2111 if err != nil { 2112 var snapshot bytes.Buffer 2113 io.Copy(&snapshot, ringBuffer) 2114 err = &smithy.DeserializationError{ 2115 Err: fmt.Errorf("failed to decode response body, %w", err), 2116 Snapshot: snapshot.Bytes(), 2117 } 2118 return out, metadata, err 2119 } 2120 2121 return out, metadata, err 2122} 2123 2124func awsAwsjson11_deserializeOpErrorDescribeHandshake(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2125 var errorBuffer bytes.Buffer 2126 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2127 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2128 } 2129 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2130 2131 errorCode := "UnknownError" 2132 errorMessage := errorCode 2133 2134 code := response.Header.Get("X-Amzn-ErrorType") 2135 if len(code) != 0 { 2136 errorCode = restjson.SanitizeErrorCode(code) 2137 } 2138 2139 var buff [1024]byte 2140 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2141 2142 body := io.TeeReader(errorBody, ringBuffer) 2143 decoder := json.NewDecoder(body) 2144 decoder.UseNumber() 2145 code, message, err := restjson.GetErrorInfo(decoder) 2146 if err != nil { 2147 var snapshot bytes.Buffer 2148 io.Copy(&snapshot, ringBuffer) 2149 err = &smithy.DeserializationError{ 2150 Err: fmt.Errorf("failed to decode response body, %w", err), 2151 Snapshot: snapshot.Bytes(), 2152 } 2153 return err 2154 } 2155 2156 errorBody.Seek(0, io.SeekStart) 2157 if len(code) != 0 { 2158 errorCode = restjson.SanitizeErrorCode(code) 2159 } 2160 if len(message) != 0 { 2161 errorMessage = message 2162 } 2163 2164 switch { 2165 case strings.EqualFold("AccessDeniedException", errorCode): 2166 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 2167 2168 case strings.EqualFold("ConcurrentModificationException", errorCode): 2169 return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody) 2170 2171 case strings.EqualFold("HandshakeNotFoundException", errorCode): 2172 return awsAwsjson11_deserializeErrorHandshakeNotFoundException(response, errorBody) 2173 2174 case strings.EqualFold("InvalidInputException", errorCode): 2175 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 2176 2177 case strings.EqualFold("ServiceException", errorCode): 2178 return awsAwsjson11_deserializeErrorServiceException(response, errorBody) 2179 2180 case strings.EqualFold("TooManyRequestsException", errorCode): 2181 return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody) 2182 2183 default: 2184 genericError := &smithy.GenericAPIError{ 2185 Code: errorCode, 2186 Message: errorMessage, 2187 } 2188 return genericError 2189 2190 } 2191} 2192 2193type awsAwsjson11_deserializeOpDescribeOrganization struct { 2194} 2195 2196func (*awsAwsjson11_deserializeOpDescribeOrganization) ID() string { 2197 return "OperationDeserializer" 2198} 2199 2200func (m *awsAwsjson11_deserializeOpDescribeOrganization) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2201 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2202) { 2203 out, metadata, err = next.HandleDeserialize(ctx, in) 2204 if err != nil { 2205 return out, metadata, err 2206 } 2207 2208 response, ok := out.RawResponse.(*smithyhttp.Response) 2209 if !ok { 2210 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2211 } 2212 2213 if response.StatusCode < 200 || response.StatusCode >= 300 { 2214 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeOrganization(response, &metadata) 2215 } 2216 output := &DescribeOrganizationOutput{} 2217 out.Result = output 2218 2219 var buff [1024]byte 2220 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2221 2222 body := io.TeeReader(response.Body, ringBuffer) 2223 decoder := json.NewDecoder(body) 2224 decoder.UseNumber() 2225 var shape interface{} 2226 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2227 var snapshot bytes.Buffer 2228 io.Copy(&snapshot, ringBuffer) 2229 err = &smithy.DeserializationError{ 2230 Err: fmt.Errorf("failed to decode response body, %w", err), 2231 Snapshot: snapshot.Bytes(), 2232 } 2233 return out, metadata, err 2234 } 2235 2236 err = awsAwsjson11_deserializeOpDocumentDescribeOrganizationOutput(&output, shape) 2237 if err != nil { 2238 var snapshot bytes.Buffer 2239 io.Copy(&snapshot, ringBuffer) 2240 err = &smithy.DeserializationError{ 2241 Err: fmt.Errorf("failed to decode response body, %w", err), 2242 Snapshot: snapshot.Bytes(), 2243 } 2244 return out, metadata, err 2245 } 2246 2247 return out, metadata, err 2248} 2249 2250func awsAwsjson11_deserializeOpErrorDescribeOrganization(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2251 var errorBuffer bytes.Buffer 2252 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2253 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2254 } 2255 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2256 2257 errorCode := "UnknownError" 2258 errorMessage := errorCode 2259 2260 code := response.Header.Get("X-Amzn-ErrorType") 2261 if len(code) != 0 { 2262 errorCode = restjson.SanitizeErrorCode(code) 2263 } 2264 2265 var buff [1024]byte 2266 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2267 2268 body := io.TeeReader(errorBody, ringBuffer) 2269 decoder := json.NewDecoder(body) 2270 decoder.UseNumber() 2271 code, message, err := restjson.GetErrorInfo(decoder) 2272 if err != nil { 2273 var snapshot bytes.Buffer 2274 io.Copy(&snapshot, ringBuffer) 2275 err = &smithy.DeserializationError{ 2276 Err: fmt.Errorf("failed to decode response body, %w", err), 2277 Snapshot: snapshot.Bytes(), 2278 } 2279 return err 2280 } 2281 2282 errorBody.Seek(0, io.SeekStart) 2283 if len(code) != 0 { 2284 errorCode = restjson.SanitizeErrorCode(code) 2285 } 2286 if len(message) != 0 { 2287 errorMessage = message 2288 } 2289 2290 switch { 2291 case strings.EqualFold("AccessDeniedException", errorCode): 2292 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 2293 2294 case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode): 2295 return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody) 2296 2297 case strings.EqualFold("ConcurrentModificationException", errorCode): 2298 return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody) 2299 2300 case strings.EqualFold("ServiceException", errorCode): 2301 return awsAwsjson11_deserializeErrorServiceException(response, errorBody) 2302 2303 case strings.EqualFold("TooManyRequestsException", errorCode): 2304 return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody) 2305 2306 default: 2307 genericError := &smithy.GenericAPIError{ 2308 Code: errorCode, 2309 Message: errorMessage, 2310 } 2311 return genericError 2312 2313 } 2314} 2315 2316type awsAwsjson11_deserializeOpDescribeOrganizationalUnit struct { 2317} 2318 2319func (*awsAwsjson11_deserializeOpDescribeOrganizationalUnit) ID() string { 2320 return "OperationDeserializer" 2321} 2322 2323func (m *awsAwsjson11_deserializeOpDescribeOrganizationalUnit) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2324 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2325) { 2326 out, metadata, err = next.HandleDeserialize(ctx, in) 2327 if err != nil { 2328 return out, metadata, err 2329 } 2330 2331 response, ok := out.RawResponse.(*smithyhttp.Response) 2332 if !ok { 2333 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2334 } 2335 2336 if response.StatusCode < 200 || response.StatusCode >= 300 { 2337 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeOrganizationalUnit(response, &metadata) 2338 } 2339 output := &DescribeOrganizationalUnitOutput{} 2340 out.Result = output 2341 2342 var buff [1024]byte 2343 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2344 2345 body := io.TeeReader(response.Body, ringBuffer) 2346 decoder := json.NewDecoder(body) 2347 decoder.UseNumber() 2348 var shape interface{} 2349 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2350 var snapshot bytes.Buffer 2351 io.Copy(&snapshot, ringBuffer) 2352 err = &smithy.DeserializationError{ 2353 Err: fmt.Errorf("failed to decode response body, %w", err), 2354 Snapshot: snapshot.Bytes(), 2355 } 2356 return out, metadata, err 2357 } 2358 2359 err = awsAwsjson11_deserializeOpDocumentDescribeOrganizationalUnitOutput(&output, shape) 2360 if err != nil { 2361 var snapshot bytes.Buffer 2362 io.Copy(&snapshot, ringBuffer) 2363 err = &smithy.DeserializationError{ 2364 Err: fmt.Errorf("failed to decode response body, %w", err), 2365 Snapshot: snapshot.Bytes(), 2366 } 2367 return out, metadata, err 2368 } 2369 2370 return out, metadata, err 2371} 2372 2373func awsAwsjson11_deserializeOpErrorDescribeOrganizationalUnit(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2374 var errorBuffer bytes.Buffer 2375 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2376 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2377 } 2378 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2379 2380 errorCode := "UnknownError" 2381 errorMessage := errorCode 2382 2383 code := response.Header.Get("X-Amzn-ErrorType") 2384 if len(code) != 0 { 2385 errorCode = restjson.SanitizeErrorCode(code) 2386 } 2387 2388 var buff [1024]byte 2389 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2390 2391 body := io.TeeReader(errorBody, ringBuffer) 2392 decoder := json.NewDecoder(body) 2393 decoder.UseNumber() 2394 code, message, err := restjson.GetErrorInfo(decoder) 2395 if err != nil { 2396 var snapshot bytes.Buffer 2397 io.Copy(&snapshot, ringBuffer) 2398 err = &smithy.DeserializationError{ 2399 Err: fmt.Errorf("failed to decode response body, %w", err), 2400 Snapshot: snapshot.Bytes(), 2401 } 2402 return err 2403 } 2404 2405 errorBody.Seek(0, io.SeekStart) 2406 if len(code) != 0 { 2407 errorCode = restjson.SanitizeErrorCode(code) 2408 } 2409 if len(message) != 0 { 2410 errorMessage = message 2411 } 2412 2413 switch { 2414 case strings.EqualFold("AccessDeniedException", errorCode): 2415 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 2416 2417 case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode): 2418 return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody) 2419 2420 case strings.EqualFold("InvalidInputException", errorCode): 2421 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 2422 2423 case strings.EqualFold("OrganizationalUnitNotFoundException", errorCode): 2424 return awsAwsjson11_deserializeErrorOrganizationalUnitNotFoundException(response, errorBody) 2425 2426 case strings.EqualFold("ServiceException", errorCode): 2427 return awsAwsjson11_deserializeErrorServiceException(response, errorBody) 2428 2429 case strings.EqualFold("TooManyRequestsException", errorCode): 2430 return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody) 2431 2432 default: 2433 genericError := &smithy.GenericAPIError{ 2434 Code: errorCode, 2435 Message: errorMessage, 2436 } 2437 return genericError 2438 2439 } 2440} 2441 2442type awsAwsjson11_deserializeOpDescribePolicy struct { 2443} 2444 2445func (*awsAwsjson11_deserializeOpDescribePolicy) ID() string { 2446 return "OperationDeserializer" 2447} 2448 2449func (m *awsAwsjson11_deserializeOpDescribePolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2450 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2451) { 2452 out, metadata, err = next.HandleDeserialize(ctx, in) 2453 if err != nil { 2454 return out, metadata, err 2455 } 2456 2457 response, ok := out.RawResponse.(*smithyhttp.Response) 2458 if !ok { 2459 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2460 } 2461 2462 if response.StatusCode < 200 || response.StatusCode >= 300 { 2463 return out, metadata, awsAwsjson11_deserializeOpErrorDescribePolicy(response, &metadata) 2464 } 2465 output := &DescribePolicyOutput{} 2466 out.Result = output 2467 2468 var buff [1024]byte 2469 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2470 2471 body := io.TeeReader(response.Body, ringBuffer) 2472 decoder := json.NewDecoder(body) 2473 decoder.UseNumber() 2474 var shape interface{} 2475 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2476 var snapshot bytes.Buffer 2477 io.Copy(&snapshot, ringBuffer) 2478 err = &smithy.DeserializationError{ 2479 Err: fmt.Errorf("failed to decode response body, %w", err), 2480 Snapshot: snapshot.Bytes(), 2481 } 2482 return out, metadata, err 2483 } 2484 2485 err = awsAwsjson11_deserializeOpDocumentDescribePolicyOutput(&output, shape) 2486 if err != nil { 2487 var snapshot bytes.Buffer 2488 io.Copy(&snapshot, ringBuffer) 2489 err = &smithy.DeserializationError{ 2490 Err: fmt.Errorf("failed to decode response body, %w", err), 2491 Snapshot: snapshot.Bytes(), 2492 } 2493 return out, metadata, err 2494 } 2495 2496 return out, metadata, err 2497} 2498 2499func awsAwsjson11_deserializeOpErrorDescribePolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2500 var errorBuffer bytes.Buffer 2501 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2502 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2503 } 2504 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2505 2506 errorCode := "UnknownError" 2507 errorMessage := errorCode 2508 2509 code := response.Header.Get("X-Amzn-ErrorType") 2510 if len(code) != 0 { 2511 errorCode = restjson.SanitizeErrorCode(code) 2512 } 2513 2514 var buff [1024]byte 2515 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2516 2517 body := io.TeeReader(errorBody, ringBuffer) 2518 decoder := json.NewDecoder(body) 2519 decoder.UseNumber() 2520 code, message, err := restjson.GetErrorInfo(decoder) 2521 if err != nil { 2522 var snapshot bytes.Buffer 2523 io.Copy(&snapshot, ringBuffer) 2524 err = &smithy.DeserializationError{ 2525 Err: fmt.Errorf("failed to decode response body, %w", err), 2526 Snapshot: snapshot.Bytes(), 2527 } 2528 return err 2529 } 2530 2531 errorBody.Seek(0, io.SeekStart) 2532 if len(code) != 0 { 2533 errorCode = restjson.SanitizeErrorCode(code) 2534 } 2535 if len(message) != 0 { 2536 errorMessage = message 2537 } 2538 2539 switch { 2540 case strings.EqualFold("AccessDeniedException", errorCode): 2541 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 2542 2543 case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode): 2544 return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody) 2545 2546 case strings.EqualFold("InvalidInputException", errorCode): 2547 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 2548 2549 case strings.EqualFold("PolicyNotFoundException", errorCode): 2550 return awsAwsjson11_deserializeErrorPolicyNotFoundException(response, errorBody) 2551 2552 case strings.EqualFold("ServiceException", errorCode): 2553 return awsAwsjson11_deserializeErrorServiceException(response, errorBody) 2554 2555 case strings.EqualFold("TooManyRequestsException", errorCode): 2556 return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody) 2557 2558 case strings.EqualFold("UnsupportedAPIEndpointException", errorCode): 2559 return awsAwsjson11_deserializeErrorUnsupportedAPIEndpointException(response, errorBody) 2560 2561 default: 2562 genericError := &smithy.GenericAPIError{ 2563 Code: errorCode, 2564 Message: errorMessage, 2565 } 2566 return genericError 2567 2568 } 2569} 2570 2571type awsAwsjson11_deserializeOpDetachPolicy struct { 2572} 2573 2574func (*awsAwsjson11_deserializeOpDetachPolicy) ID() string { 2575 return "OperationDeserializer" 2576} 2577 2578func (m *awsAwsjson11_deserializeOpDetachPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2579 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2580) { 2581 out, metadata, err = next.HandleDeserialize(ctx, in) 2582 if err != nil { 2583 return out, metadata, err 2584 } 2585 2586 response, ok := out.RawResponse.(*smithyhttp.Response) 2587 if !ok { 2588 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2589 } 2590 2591 if response.StatusCode < 200 || response.StatusCode >= 300 { 2592 return out, metadata, awsAwsjson11_deserializeOpErrorDetachPolicy(response, &metadata) 2593 } 2594 output := &DetachPolicyOutput{} 2595 out.Result = output 2596 2597 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 2598 return out, metadata, &smithy.DeserializationError{ 2599 Err: fmt.Errorf("failed to discard response body, %w", err), 2600 } 2601 } 2602 2603 return out, metadata, err 2604} 2605 2606func awsAwsjson11_deserializeOpErrorDetachPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2607 var errorBuffer bytes.Buffer 2608 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2609 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2610 } 2611 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2612 2613 errorCode := "UnknownError" 2614 errorMessage := errorCode 2615 2616 code := response.Header.Get("X-Amzn-ErrorType") 2617 if len(code) != 0 { 2618 errorCode = restjson.SanitizeErrorCode(code) 2619 } 2620 2621 var buff [1024]byte 2622 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2623 2624 body := io.TeeReader(errorBody, ringBuffer) 2625 decoder := json.NewDecoder(body) 2626 decoder.UseNumber() 2627 code, message, err := restjson.GetErrorInfo(decoder) 2628 if err != nil { 2629 var snapshot bytes.Buffer 2630 io.Copy(&snapshot, ringBuffer) 2631 err = &smithy.DeserializationError{ 2632 Err: fmt.Errorf("failed to decode response body, %w", err), 2633 Snapshot: snapshot.Bytes(), 2634 } 2635 return err 2636 } 2637 2638 errorBody.Seek(0, io.SeekStart) 2639 if len(code) != 0 { 2640 errorCode = restjson.SanitizeErrorCode(code) 2641 } 2642 if len(message) != 0 { 2643 errorMessage = message 2644 } 2645 2646 switch { 2647 case strings.EqualFold("AccessDeniedException", errorCode): 2648 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 2649 2650 case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode): 2651 return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody) 2652 2653 case strings.EqualFold("ConcurrentModificationException", errorCode): 2654 return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody) 2655 2656 case strings.EqualFold("ConstraintViolationException", errorCode): 2657 return awsAwsjson11_deserializeErrorConstraintViolationException(response, errorBody) 2658 2659 case strings.EqualFold("InvalidInputException", errorCode): 2660 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 2661 2662 case strings.EqualFold("PolicyChangesInProgressException", errorCode): 2663 return awsAwsjson11_deserializeErrorPolicyChangesInProgressException(response, errorBody) 2664 2665 case strings.EqualFold("PolicyNotAttachedException", errorCode): 2666 return awsAwsjson11_deserializeErrorPolicyNotAttachedException(response, errorBody) 2667 2668 case strings.EqualFold("PolicyNotFoundException", errorCode): 2669 return awsAwsjson11_deserializeErrorPolicyNotFoundException(response, errorBody) 2670 2671 case strings.EqualFold("ServiceException", errorCode): 2672 return awsAwsjson11_deserializeErrorServiceException(response, errorBody) 2673 2674 case strings.EqualFold("TargetNotFoundException", errorCode): 2675 return awsAwsjson11_deserializeErrorTargetNotFoundException(response, errorBody) 2676 2677 case strings.EqualFold("TooManyRequestsException", errorCode): 2678 return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody) 2679 2680 case strings.EqualFold("UnsupportedAPIEndpointException", errorCode): 2681 return awsAwsjson11_deserializeErrorUnsupportedAPIEndpointException(response, errorBody) 2682 2683 default: 2684 genericError := &smithy.GenericAPIError{ 2685 Code: errorCode, 2686 Message: errorMessage, 2687 } 2688 return genericError 2689 2690 } 2691} 2692 2693type awsAwsjson11_deserializeOpDisableAWSServiceAccess struct { 2694} 2695 2696func (*awsAwsjson11_deserializeOpDisableAWSServiceAccess) ID() string { 2697 return "OperationDeserializer" 2698} 2699 2700func (m *awsAwsjson11_deserializeOpDisableAWSServiceAccess) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2701 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2702) { 2703 out, metadata, err = next.HandleDeserialize(ctx, in) 2704 if err != nil { 2705 return out, metadata, err 2706 } 2707 2708 response, ok := out.RawResponse.(*smithyhttp.Response) 2709 if !ok { 2710 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2711 } 2712 2713 if response.StatusCode < 200 || response.StatusCode >= 300 { 2714 return out, metadata, awsAwsjson11_deserializeOpErrorDisableAWSServiceAccess(response, &metadata) 2715 } 2716 output := &DisableAWSServiceAccessOutput{} 2717 out.Result = output 2718 2719 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 2720 return out, metadata, &smithy.DeserializationError{ 2721 Err: fmt.Errorf("failed to discard response body, %w", err), 2722 } 2723 } 2724 2725 return out, metadata, err 2726} 2727 2728func awsAwsjson11_deserializeOpErrorDisableAWSServiceAccess(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2729 var errorBuffer bytes.Buffer 2730 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2731 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2732 } 2733 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2734 2735 errorCode := "UnknownError" 2736 errorMessage := errorCode 2737 2738 code := response.Header.Get("X-Amzn-ErrorType") 2739 if len(code) != 0 { 2740 errorCode = restjson.SanitizeErrorCode(code) 2741 } 2742 2743 var buff [1024]byte 2744 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2745 2746 body := io.TeeReader(errorBody, ringBuffer) 2747 decoder := json.NewDecoder(body) 2748 decoder.UseNumber() 2749 code, message, err := restjson.GetErrorInfo(decoder) 2750 if err != nil { 2751 var snapshot bytes.Buffer 2752 io.Copy(&snapshot, ringBuffer) 2753 err = &smithy.DeserializationError{ 2754 Err: fmt.Errorf("failed to decode response body, %w", err), 2755 Snapshot: snapshot.Bytes(), 2756 } 2757 return err 2758 } 2759 2760 errorBody.Seek(0, io.SeekStart) 2761 if len(code) != 0 { 2762 errorCode = restjson.SanitizeErrorCode(code) 2763 } 2764 if len(message) != 0 { 2765 errorMessage = message 2766 } 2767 2768 switch { 2769 case strings.EqualFold("AccessDeniedException", errorCode): 2770 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 2771 2772 case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode): 2773 return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody) 2774 2775 case strings.EqualFold("ConcurrentModificationException", errorCode): 2776 return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody) 2777 2778 case strings.EqualFold("ConstraintViolationException", errorCode): 2779 return awsAwsjson11_deserializeErrorConstraintViolationException(response, errorBody) 2780 2781 case strings.EqualFold("InvalidInputException", errorCode): 2782 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 2783 2784 case strings.EqualFold("ServiceException", errorCode): 2785 return awsAwsjson11_deserializeErrorServiceException(response, errorBody) 2786 2787 case strings.EqualFold("TooManyRequestsException", errorCode): 2788 return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody) 2789 2790 case strings.EqualFold("UnsupportedAPIEndpointException", errorCode): 2791 return awsAwsjson11_deserializeErrorUnsupportedAPIEndpointException(response, errorBody) 2792 2793 default: 2794 genericError := &smithy.GenericAPIError{ 2795 Code: errorCode, 2796 Message: errorMessage, 2797 } 2798 return genericError 2799 2800 } 2801} 2802 2803type awsAwsjson11_deserializeOpDisablePolicyType struct { 2804} 2805 2806func (*awsAwsjson11_deserializeOpDisablePolicyType) ID() string { 2807 return "OperationDeserializer" 2808} 2809 2810func (m *awsAwsjson11_deserializeOpDisablePolicyType) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2811 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2812) { 2813 out, metadata, err = next.HandleDeserialize(ctx, in) 2814 if err != nil { 2815 return out, metadata, err 2816 } 2817 2818 response, ok := out.RawResponse.(*smithyhttp.Response) 2819 if !ok { 2820 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2821 } 2822 2823 if response.StatusCode < 200 || response.StatusCode >= 300 { 2824 return out, metadata, awsAwsjson11_deserializeOpErrorDisablePolicyType(response, &metadata) 2825 } 2826 output := &DisablePolicyTypeOutput{} 2827 out.Result = output 2828 2829 var buff [1024]byte 2830 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2831 2832 body := io.TeeReader(response.Body, ringBuffer) 2833 decoder := json.NewDecoder(body) 2834 decoder.UseNumber() 2835 var shape interface{} 2836 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2837 var snapshot bytes.Buffer 2838 io.Copy(&snapshot, ringBuffer) 2839 err = &smithy.DeserializationError{ 2840 Err: fmt.Errorf("failed to decode response body, %w", err), 2841 Snapshot: snapshot.Bytes(), 2842 } 2843 return out, metadata, err 2844 } 2845 2846 err = awsAwsjson11_deserializeOpDocumentDisablePolicyTypeOutput(&output, shape) 2847 if err != nil { 2848 var snapshot bytes.Buffer 2849 io.Copy(&snapshot, ringBuffer) 2850 err = &smithy.DeserializationError{ 2851 Err: fmt.Errorf("failed to decode response body, %w", err), 2852 Snapshot: snapshot.Bytes(), 2853 } 2854 return out, metadata, err 2855 } 2856 2857 return out, metadata, err 2858} 2859 2860func awsAwsjson11_deserializeOpErrorDisablePolicyType(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2861 var errorBuffer bytes.Buffer 2862 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2863 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2864 } 2865 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2866 2867 errorCode := "UnknownError" 2868 errorMessage := errorCode 2869 2870 code := response.Header.Get("X-Amzn-ErrorType") 2871 if len(code) != 0 { 2872 errorCode = restjson.SanitizeErrorCode(code) 2873 } 2874 2875 var buff [1024]byte 2876 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2877 2878 body := io.TeeReader(errorBody, ringBuffer) 2879 decoder := json.NewDecoder(body) 2880 decoder.UseNumber() 2881 code, message, err := restjson.GetErrorInfo(decoder) 2882 if err != nil { 2883 var snapshot bytes.Buffer 2884 io.Copy(&snapshot, ringBuffer) 2885 err = &smithy.DeserializationError{ 2886 Err: fmt.Errorf("failed to decode response body, %w", err), 2887 Snapshot: snapshot.Bytes(), 2888 } 2889 return err 2890 } 2891 2892 errorBody.Seek(0, io.SeekStart) 2893 if len(code) != 0 { 2894 errorCode = restjson.SanitizeErrorCode(code) 2895 } 2896 if len(message) != 0 { 2897 errorMessage = message 2898 } 2899 2900 switch { 2901 case strings.EqualFold("AccessDeniedException", errorCode): 2902 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 2903 2904 case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode): 2905 return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody) 2906 2907 case strings.EqualFold("ConcurrentModificationException", errorCode): 2908 return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody) 2909 2910 case strings.EqualFold("ConstraintViolationException", errorCode): 2911 return awsAwsjson11_deserializeErrorConstraintViolationException(response, errorBody) 2912 2913 case strings.EqualFold("InvalidInputException", errorCode): 2914 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 2915 2916 case strings.EqualFold("PolicyChangesInProgressException", errorCode): 2917 return awsAwsjson11_deserializeErrorPolicyChangesInProgressException(response, errorBody) 2918 2919 case strings.EqualFold("PolicyTypeNotEnabledException", errorCode): 2920 return awsAwsjson11_deserializeErrorPolicyTypeNotEnabledException(response, errorBody) 2921 2922 case strings.EqualFold("RootNotFoundException", errorCode): 2923 return awsAwsjson11_deserializeErrorRootNotFoundException(response, errorBody) 2924 2925 case strings.EqualFold("ServiceException", errorCode): 2926 return awsAwsjson11_deserializeErrorServiceException(response, errorBody) 2927 2928 case strings.EqualFold("TooManyRequestsException", errorCode): 2929 return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody) 2930 2931 case strings.EqualFold("UnsupportedAPIEndpointException", errorCode): 2932 return awsAwsjson11_deserializeErrorUnsupportedAPIEndpointException(response, errorBody) 2933 2934 default: 2935 genericError := &smithy.GenericAPIError{ 2936 Code: errorCode, 2937 Message: errorMessage, 2938 } 2939 return genericError 2940 2941 } 2942} 2943 2944type awsAwsjson11_deserializeOpEnableAllFeatures struct { 2945} 2946 2947func (*awsAwsjson11_deserializeOpEnableAllFeatures) ID() string { 2948 return "OperationDeserializer" 2949} 2950 2951func (m *awsAwsjson11_deserializeOpEnableAllFeatures) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2952 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2953) { 2954 out, metadata, err = next.HandleDeserialize(ctx, in) 2955 if err != nil { 2956 return out, metadata, err 2957 } 2958 2959 response, ok := out.RawResponse.(*smithyhttp.Response) 2960 if !ok { 2961 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2962 } 2963 2964 if response.StatusCode < 200 || response.StatusCode >= 300 { 2965 return out, metadata, awsAwsjson11_deserializeOpErrorEnableAllFeatures(response, &metadata) 2966 } 2967 output := &EnableAllFeaturesOutput{} 2968 out.Result = output 2969 2970 var buff [1024]byte 2971 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2972 2973 body := io.TeeReader(response.Body, ringBuffer) 2974 decoder := json.NewDecoder(body) 2975 decoder.UseNumber() 2976 var shape interface{} 2977 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2978 var snapshot bytes.Buffer 2979 io.Copy(&snapshot, ringBuffer) 2980 err = &smithy.DeserializationError{ 2981 Err: fmt.Errorf("failed to decode response body, %w", err), 2982 Snapshot: snapshot.Bytes(), 2983 } 2984 return out, metadata, err 2985 } 2986 2987 err = awsAwsjson11_deserializeOpDocumentEnableAllFeaturesOutput(&output, shape) 2988 if err != nil { 2989 var snapshot bytes.Buffer 2990 io.Copy(&snapshot, ringBuffer) 2991 err = &smithy.DeserializationError{ 2992 Err: fmt.Errorf("failed to decode response body, %w", err), 2993 Snapshot: snapshot.Bytes(), 2994 } 2995 return out, metadata, err 2996 } 2997 2998 return out, metadata, err 2999} 3000 3001func awsAwsjson11_deserializeOpErrorEnableAllFeatures(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3002 var errorBuffer bytes.Buffer 3003 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3004 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3005 } 3006 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3007 3008 errorCode := "UnknownError" 3009 errorMessage := errorCode 3010 3011 code := response.Header.Get("X-Amzn-ErrorType") 3012 if len(code) != 0 { 3013 errorCode = restjson.SanitizeErrorCode(code) 3014 } 3015 3016 var buff [1024]byte 3017 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3018 3019 body := io.TeeReader(errorBody, ringBuffer) 3020 decoder := json.NewDecoder(body) 3021 decoder.UseNumber() 3022 code, message, err := restjson.GetErrorInfo(decoder) 3023 if err != nil { 3024 var snapshot bytes.Buffer 3025 io.Copy(&snapshot, ringBuffer) 3026 err = &smithy.DeserializationError{ 3027 Err: fmt.Errorf("failed to decode response body, %w", err), 3028 Snapshot: snapshot.Bytes(), 3029 } 3030 return err 3031 } 3032 3033 errorBody.Seek(0, io.SeekStart) 3034 if len(code) != 0 { 3035 errorCode = restjson.SanitizeErrorCode(code) 3036 } 3037 if len(message) != 0 { 3038 errorMessage = message 3039 } 3040 3041 switch { 3042 case strings.EqualFold("AccessDeniedException", errorCode): 3043 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 3044 3045 case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode): 3046 return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody) 3047 3048 case strings.EqualFold("ConcurrentModificationException", errorCode): 3049 return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody) 3050 3051 case strings.EqualFold("HandshakeConstraintViolationException", errorCode): 3052 return awsAwsjson11_deserializeErrorHandshakeConstraintViolationException(response, errorBody) 3053 3054 case strings.EqualFold("InvalidInputException", errorCode): 3055 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 3056 3057 case strings.EqualFold("ServiceException", errorCode): 3058 return awsAwsjson11_deserializeErrorServiceException(response, errorBody) 3059 3060 case strings.EqualFold("TooManyRequestsException", errorCode): 3061 return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody) 3062 3063 default: 3064 genericError := &smithy.GenericAPIError{ 3065 Code: errorCode, 3066 Message: errorMessage, 3067 } 3068 return genericError 3069 3070 } 3071} 3072 3073type awsAwsjson11_deserializeOpEnableAWSServiceAccess struct { 3074} 3075 3076func (*awsAwsjson11_deserializeOpEnableAWSServiceAccess) ID() string { 3077 return "OperationDeserializer" 3078} 3079 3080func (m *awsAwsjson11_deserializeOpEnableAWSServiceAccess) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3081 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3082) { 3083 out, metadata, err = next.HandleDeserialize(ctx, in) 3084 if err != nil { 3085 return out, metadata, err 3086 } 3087 3088 response, ok := out.RawResponse.(*smithyhttp.Response) 3089 if !ok { 3090 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3091 } 3092 3093 if response.StatusCode < 200 || response.StatusCode >= 300 { 3094 return out, metadata, awsAwsjson11_deserializeOpErrorEnableAWSServiceAccess(response, &metadata) 3095 } 3096 output := &EnableAWSServiceAccessOutput{} 3097 out.Result = output 3098 3099 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 3100 return out, metadata, &smithy.DeserializationError{ 3101 Err: fmt.Errorf("failed to discard response body, %w", err), 3102 } 3103 } 3104 3105 return out, metadata, err 3106} 3107 3108func awsAwsjson11_deserializeOpErrorEnableAWSServiceAccess(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3109 var errorBuffer bytes.Buffer 3110 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3111 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3112 } 3113 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3114 3115 errorCode := "UnknownError" 3116 errorMessage := errorCode 3117 3118 code := response.Header.Get("X-Amzn-ErrorType") 3119 if len(code) != 0 { 3120 errorCode = restjson.SanitizeErrorCode(code) 3121 } 3122 3123 var buff [1024]byte 3124 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3125 3126 body := io.TeeReader(errorBody, ringBuffer) 3127 decoder := json.NewDecoder(body) 3128 decoder.UseNumber() 3129 code, message, err := restjson.GetErrorInfo(decoder) 3130 if err != nil { 3131 var snapshot bytes.Buffer 3132 io.Copy(&snapshot, ringBuffer) 3133 err = &smithy.DeserializationError{ 3134 Err: fmt.Errorf("failed to decode response body, %w", err), 3135 Snapshot: snapshot.Bytes(), 3136 } 3137 return err 3138 } 3139 3140 errorBody.Seek(0, io.SeekStart) 3141 if len(code) != 0 { 3142 errorCode = restjson.SanitizeErrorCode(code) 3143 } 3144 if len(message) != 0 { 3145 errorMessage = message 3146 } 3147 3148 switch { 3149 case strings.EqualFold("AccessDeniedException", errorCode): 3150 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 3151 3152 case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode): 3153 return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody) 3154 3155 case strings.EqualFold("ConcurrentModificationException", errorCode): 3156 return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody) 3157 3158 case strings.EqualFold("ConstraintViolationException", errorCode): 3159 return awsAwsjson11_deserializeErrorConstraintViolationException(response, errorBody) 3160 3161 case strings.EqualFold("InvalidInputException", errorCode): 3162 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 3163 3164 case strings.EqualFold("ServiceException", errorCode): 3165 return awsAwsjson11_deserializeErrorServiceException(response, errorBody) 3166 3167 case strings.EqualFold("TooManyRequestsException", errorCode): 3168 return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody) 3169 3170 case strings.EqualFold("UnsupportedAPIEndpointException", errorCode): 3171 return awsAwsjson11_deserializeErrorUnsupportedAPIEndpointException(response, errorBody) 3172 3173 default: 3174 genericError := &smithy.GenericAPIError{ 3175 Code: errorCode, 3176 Message: errorMessage, 3177 } 3178 return genericError 3179 3180 } 3181} 3182 3183type awsAwsjson11_deserializeOpEnablePolicyType struct { 3184} 3185 3186func (*awsAwsjson11_deserializeOpEnablePolicyType) ID() string { 3187 return "OperationDeserializer" 3188} 3189 3190func (m *awsAwsjson11_deserializeOpEnablePolicyType) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3191 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3192) { 3193 out, metadata, err = next.HandleDeserialize(ctx, in) 3194 if err != nil { 3195 return out, metadata, err 3196 } 3197 3198 response, ok := out.RawResponse.(*smithyhttp.Response) 3199 if !ok { 3200 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3201 } 3202 3203 if response.StatusCode < 200 || response.StatusCode >= 300 { 3204 return out, metadata, awsAwsjson11_deserializeOpErrorEnablePolicyType(response, &metadata) 3205 } 3206 output := &EnablePolicyTypeOutput{} 3207 out.Result = output 3208 3209 var buff [1024]byte 3210 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3211 3212 body := io.TeeReader(response.Body, ringBuffer) 3213 decoder := json.NewDecoder(body) 3214 decoder.UseNumber() 3215 var shape interface{} 3216 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3217 var snapshot bytes.Buffer 3218 io.Copy(&snapshot, ringBuffer) 3219 err = &smithy.DeserializationError{ 3220 Err: fmt.Errorf("failed to decode response body, %w", err), 3221 Snapshot: snapshot.Bytes(), 3222 } 3223 return out, metadata, err 3224 } 3225 3226 err = awsAwsjson11_deserializeOpDocumentEnablePolicyTypeOutput(&output, shape) 3227 if err != nil { 3228 var snapshot bytes.Buffer 3229 io.Copy(&snapshot, ringBuffer) 3230 err = &smithy.DeserializationError{ 3231 Err: fmt.Errorf("failed to decode response body, %w", err), 3232 Snapshot: snapshot.Bytes(), 3233 } 3234 return out, metadata, err 3235 } 3236 3237 return out, metadata, err 3238} 3239 3240func awsAwsjson11_deserializeOpErrorEnablePolicyType(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3241 var errorBuffer bytes.Buffer 3242 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3243 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3244 } 3245 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3246 3247 errorCode := "UnknownError" 3248 errorMessage := errorCode 3249 3250 code := response.Header.Get("X-Amzn-ErrorType") 3251 if len(code) != 0 { 3252 errorCode = restjson.SanitizeErrorCode(code) 3253 } 3254 3255 var buff [1024]byte 3256 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3257 3258 body := io.TeeReader(errorBody, ringBuffer) 3259 decoder := json.NewDecoder(body) 3260 decoder.UseNumber() 3261 code, message, err := restjson.GetErrorInfo(decoder) 3262 if err != nil { 3263 var snapshot bytes.Buffer 3264 io.Copy(&snapshot, ringBuffer) 3265 err = &smithy.DeserializationError{ 3266 Err: fmt.Errorf("failed to decode response body, %w", err), 3267 Snapshot: snapshot.Bytes(), 3268 } 3269 return err 3270 } 3271 3272 errorBody.Seek(0, io.SeekStart) 3273 if len(code) != 0 { 3274 errorCode = restjson.SanitizeErrorCode(code) 3275 } 3276 if len(message) != 0 { 3277 errorMessage = message 3278 } 3279 3280 switch { 3281 case strings.EqualFold("AccessDeniedException", errorCode): 3282 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 3283 3284 case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode): 3285 return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody) 3286 3287 case strings.EqualFold("ConcurrentModificationException", errorCode): 3288 return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody) 3289 3290 case strings.EqualFold("ConstraintViolationException", errorCode): 3291 return awsAwsjson11_deserializeErrorConstraintViolationException(response, errorBody) 3292 3293 case strings.EqualFold("InvalidInputException", errorCode): 3294 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 3295 3296 case strings.EqualFold("PolicyChangesInProgressException", errorCode): 3297 return awsAwsjson11_deserializeErrorPolicyChangesInProgressException(response, errorBody) 3298 3299 case strings.EqualFold("PolicyTypeAlreadyEnabledException", errorCode): 3300 return awsAwsjson11_deserializeErrorPolicyTypeAlreadyEnabledException(response, errorBody) 3301 3302 case strings.EqualFold("PolicyTypeNotAvailableForOrganizationException", errorCode): 3303 return awsAwsjson11_deserializeErrorPolicyTypeNotAvailableForOrganizationException(response, errorBody) 3304 3305 case strings.EqualFold("RootNotFoundException", errorCode): 3306 return awsAwsjson11_deserializeErrorRootNotFoundException(response, errorBody) 3307 3308 case strings.EqualFold("ServiceException", errorCode): 3309 return awsAwsjson11_deserializeErrorServiceException(response, errorBody) 3310 3311 case strings.EqualFold("TooManyRequestsException", errorCode): 3312 return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody) 3313 3314 case strings.EqualFold("UnsupportedAPIEndpointException", errorCode): 3315 return awsAwsjson11_deserializeErrorUnsupportedAPIEndpointException(response, errorBody) 3316 3317 default: 3318 genericError := &smithy.GenericAPIError{ 3319 Code: errorCode, 3320 Message: errorMessage, 3321 } 3322 return genericError 3323 3324 } 3325} 3326 3327type awsAwsjson11_deserializeOpInviteAccountToOrganization struct { 3328} 3329 3330func (*awsAwsjson11_deserializeOpInviteAccountToOrganization) ID() string { 3331 return "OperationDeserializer" 3332} 3333 3334func (m *awsAwsjson11_deserializeOpInviteAccountToOrganization) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3335 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3336) { 3337 out, metadata, err = next.HandleDeserialize(ctx, in) 3338 if err != nil { 3339 return out, metadata, err 3340 } 3341 3342 response, ok := out.RawResponse.(*smithyhttp.Response) 3343 if !ok { 3344 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3345 } 3346 3347 if response.StatusCode < 200 || response.StatusCode >= 300 { 3348 return out, metadata, awsAwsjson11_deserializeOpErrorInviteAccountToOrganization(response, &metadata) 3349 } 3350 output := &InviteAccountToOrganizationOutput{} 3351 out.Result = output 3352 3353 var buff [1024]byte 3354 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3355 3356 body := io.TeeReader(response.Body, ringBuffer) 3357 decoder := json.NewDecoder(body) 3358 decoder.UseNumber() 3359 var shape interface{} 3360 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3361 var snapshot bytes.Buffer 3362 io.Copy(&snapshot, ringBuffer) 3363 err = &smithy.DeserializationError{ 3364 Err: fmt.Errorf("failed to decode response body, %w", err), 3365 Snapshot: snapshot.Bytes(), 3366 } 3367 return out, metadata, err 3368 } 3369 3370 err = awsAwsjson11_deserializeOpDocumentInviteAccountToOrganizationOutput(&output, shape) 3371 if err != nil { 3372 var snapshot bytes.Buffer 3373 io.Copy(&snapshot, ringBuffer) 3374 err = &smithy.DeserializationError{ 3375 Err: fmt.Errorf("failed to decode response body, %w", err), 3376 Snapshot: snapshot.Bytes(), 3377 } 3378 return out, metadata, err 3379 } 3380 3381 return out, metadata, err 3382} 3383 3384func awsAwsjson11_deserializeOpErrorInviteAccountToOrganization(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3385 var errorBuffer bytes.Buffer 3386 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3387 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3388 } 3389 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3390 3391 errorCode := "UnknownError" 3392 errorMessage := errorCode 3393 3394 code := response.Header.Get("X-Amzn-ErrorType") 3395 if len(code) != 0 { 3396 errorCode = restjson.SanitizeErrorCode(code) 3397 } 3398 3399 var buff [1024]byte 3400 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3401 3402 body := io.TeeReader(errorBody, ringBuffer) 3403 decoder := json.NewDecoder(body) 3404 decoder.UseNumber() 3405 code, message, err := restjson.GetErrorInfo(decoder) 3406 if err != nil { 3407 var snapshot bytes.Buffer 3408 io.Copy(&snapshot, ringBuffer) 3409 err = &smithy.DeserializationError{ 3410 Err: fmt.Errorf("failed to decode response body, %w", err), 3411 Snapshot: snapshot.Bytes(), 3412 } 3413 return err 3414 } 3415 3416 errorBody.Seek(0, io.SeekStart) 3417 if len(code) != 0 { 3418 errorCode = restjson.SanitizeErrorCode(code) 3419 } 3420 if len(message) != 0 { 3421 errorMessage = message 3422 } 3423 3424 switch { 3425 case strings.EqualFold("AccessDeniedException", errorCode): 3426 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 3427 3428 case strings.EqualFold("AccountOwnerNotVerifiedException", errorCode): 3429 return awsAwsjson11_deserializeErrorAccountOwnerNotVerifiedException(response, errorBody) 3430 3431 case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode): 3432 return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody) 3433 3434 case strings.EqualFold("ConcurrentModificationException", errorCode): 3435 return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody) 3436 3437 case strings.EqualFold("ConstraintViolationException", errorCode): 3438 return awsAwsjson11_deserializeErrorConstraintViolationException(response, errorBody) 3439 3440 case strings.EqualFold("DuplicateHandshakeException", errorCode): 3441 return awsAwsjson11_deserializeErrorDuplicateHandshakeException(response, errorBody) 3442 3443 case strings.EqualFold("FinalizingOrganizationException", errorCode): 3444 return awsAwsjson11_deserializeErrorFinalizingOrganizationException(response, errorBody) 3445 3446 case strings.EqualFold("HandshakeConstraintViolationException", errorCode): 3447 return awsAwsjson11_deserializeErrorHandshakeConstraintViolationException(response, errorBody) 3448 3449 case strings.EqualFold("InvalidInputException", errorCode): 3450 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 3451 3452 case strings.EqualFold("ServiceException", errorCode): 3453 return awsAwsjson11_deserializeErrorServiceException(response, errorBody) 3454 3455 case strings.EqualFold("TooManyRequestsException", errorCode): 3456 return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody) 3457 3458 default: 3459 genericError := &smithy.GenericAPIError{ 3460 Code: errorCode, 3461 Message: errorMessage, 3462 } 3463 return genericError 3464 3465 } 3466} 3467 3468type awsAwsjson11_deserializeOpLeaveOrganization struct { 3469} 3470 3471func (*awsAwsjson11_deserializeOpLeaveOrganization) ID() string { 3472 return "OperationDeserializer" 3473} 3474 3475func (m *awsAwsjson11_deserializeOpLeaveOrganization) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3476 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3477) { 3478 out, metadata, err = next.HandleDeserialize(ctx, in) 3479 if err != nil { 3480 return out, metadata, err 3481 } 3482 3483 response, ok := out.RawResponse.(*smithyhttp.Response) 3484 if !ok { 3485 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3486 } 3487 3488 if response.StatusCode < 200 || response.StatusCode >= 300 { 3489 return out, metadata, awsAwsjson11_deserializeOpErrorLeaveOrganization(response, &metadata) 3490 } 3491 output := &LeaveOrganizationOutput{} 3492 out.Result = output 3493 3494 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 3495 return out, metadata, &smithy.DeserializationError{ 3496 Err: fmt.Errorf("failed to discard response body, %w", err), 3497 } 3498 } 3499 3500 return out, metadata, err 3501} 3502 3503func awsAwsjson11_deserializeOpErrorLeaveOrganization(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3504 var errorBuffer bytes.Buffer 3505 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3506 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3507 } 3508 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3509 3510 errorCode := "UnknownError" 3511 errorMessage := errorCode 3512 3513 code := response.Header.Get("X-Amzn-ErrorType") 3514 if len(code) != 0 { 3515 errorCode = restjson.SanitizeErrorCode(code) 3516 } 3517 3518 var buff [1024]byte 3519 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3520 3521 body := io.TeeReader(errorBody, ringBuffer) 3522 decoder := json.NewDecoder(body) 3523 decoder.UseNumber() 3524 code, message, err := restjson.GetErrorInfo(decoder) 3525 if err != nil { 3526 var snapshot bytes.Buffer 3527 io.Copy(&snapshot, ringBuffer) 3528 err = &smithy.DeserializationError{ 3529 Err: fmt.Errorf("failed to decode response body, %w", err), 3530 Snapshot: snapshot.Bytes(), 3531 } 3532 return err 3533 } 3534 3535 errorBody.Seek(0, io.SeekStart) 3536 if len(code) != 0 { 3537 errorCode = restjson.SanitizeErrorCode(code) 3538 } 3539 if len(message) != 0 { 3540 errorMessage = message 3541 } 3542 3543 switch { 3544 case strings.EqualFold("AccessDeniedException", errorCode): 3545 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 3546 3547 case strings.EqualFold("AccountNotFoundException", errorCode): 3548 return awsAwsjson11_deserializeErrorAccountNotFoundException(response, errorBody) 3549 3550 case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode): 3551 return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody) 3552 3553 case strings.EqualFold("ConcurrentModificationException", errorCode): 3554 return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody) 3555 3556 case strings.EqualFold("ConstraintViolationException", errorCode): 3557 return awsAwsjson11_deserializeErrorConstraintViolationException(response, errorBody) 3558 3559 case strings.EqualFold("InvalidInputException", errorCode): 3560 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 3561 3562 case strings.EqualFold("MasterCannotLeaveOrganizationException", errorCode): 3563 return awsAwsjson11_deserializeErrorMasterCannotLeaveOrganizationException(response, errorBody) 3564 3565 case strings.EqualFold("ServiceException", errorCode): 3566 return awsAwsjson11_deserializeErrorServiceException(response, errorBody) 3567 3568 case strings.EqualFold("TooManyRequestsException", errorCode): 3569 return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody) 3570 3571 default: 3572 genericError := &smithy.GenericAPIError{ 3573 Code: errorCode, 3574 Message: errorMessage, 3575 } 3576 return genericError 3577 3578 } 3579} 3580 3581type awsAwsjson11_deserializeOpListAccounts struct { 3582} 3583 3584func (*awsAwsjson11_deserializeOpListAccounts) ID() string { 3585 return "OperationDeserializer" 3586} 3587 3588func (m *awsAwsjson11_deserializeOpListAccounts) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3589 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3590) { 3591 out, metadata, err = next.HandleDeserialize(ctx, in) 3592 if err != nil { 3593 return out, metadata, err 3594 } 3595 3596 response, ok := out.RawResponse.(*smithyhttp.Response) 3597 if !ok { 3598 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3599 } 3600 3601 if response.StatusCode < 200 || response.StatusCode >= 300 { 3602 return out, metadata, awsAwsjson11_deserializeOpErrorListAccounts(response, &metadata) 3603 } 3604 output := &ListAccountsOutput{} 3605 out.Result = output 3606 3607 var buff [1024]byte 3608 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3609 3610 body := io.TeeReader(response.Body, ringBuffer) 3611 decoder := json.NewDecoder(body) 3612 decoder.UseNumber() 3613 var shape interface{} 3614 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3615 var snapshot bytes.Buffer 3616 io.Copy(&snapshot, ringBuffer) 3617 err = &smithy.DeserializationError{ 3618 Err: fmt.Errorf("failed to decode response body, %w", err), 3619 Snapshot: snapshot.Bytes(), 3620 } 3621 return out, metadata, err 3622 } 3623 3624 err = awsAwsjson11_deserializeOpDocumentListAccountsOutput(&output, shape) 3625 if err != nil { 3626 var snapshot bytes.Buffer 3627 io.Copy(&snapshot, ringBuffer) 3628 err = &smithy.DeserializationError{ 3629 Err: fmt.Errorf("failed to decode response body, %w", err), 3630 Snapshot: snapshot.Bytes(), 3631 } 3632 return out, metadata, err 3633 } 3634 3635 return out, metadata, err 3636} 3637 3638func awsAwsjson11_deserializeOpErrorListAccounts(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3639 var errorBuffer bytes.Buffer 3640 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3641 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3642 } 3643 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3644 3645 errorCode := "UnknownError" 3646 errorMessage := errorCode 3647 3648 code := response.Header.Get("X-Amzn-ErrorType") 3649 if len(code) != 0 { 3650 errorCode = restjson.SanitizeErrorCode(code) 3651 } 3652 3653 var buff [1024]byte 3654 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3655 3656 body := io.TeeReader(errorBody, ringBuffer) 3657 decoder := json.NewDecoder(body) 3658 decoder.UseNumber() 3659 code, message, err := restjson.GetErrorInfo(decoder) 3660 if err != nil { 3661 var snapshot bytes.Buffer 3662 io.Copy(&snapshot, ringBuffer) 3663 err = &smithy.DeserializationError{ 3664 Err: fmt.Errorf("failed to decode response body, %w", err), 3665 Snapshot: snapshot.Bytes(), 3666 } 3667 return err 3668 } 3669 3670 errorBody.Seek(0, io.SeekStart) 3671 if len(code) != 0 { 3672 errorCode = restjson.SanitizeErrorCode(code) 3673 } 3674 if len(message) != 0 { 3675 errorMessage = message 3676 } 3677 3678 switch { 3679 case strings.EqualFold("AccessDeniedException", errorCode): 3680 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 3681 3682 case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode): 3683 return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody) 3684 3685 case strings.EqualFold("InvalidInputException", errorCode): 3686 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 3687 3688 case strings.EqualFold("ServiceException", errorCode): 3689 return awsAwsjson11_deserializeErrorServiceException(response, errorBody) 3690 3691 case strings.EqualFold("TooManyRequestsException", errorCode): 3692 return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody) 3693 3694 default: 3695 genericError := &smithy.GenericAPIError{ 3696 Code: errorCode, 3697 Message: errorMessage, 3698 } 3699 return genericError 3700 3701 } 3702} 3703 3704type awsAwsjson11_deserializeOpListAccountsForParent struct { 3705} 3706 3707func (*awsAwsjson11_deserializeOpListAccountsForParent) ID() string { 3708 return "OperationDeserializer" 3709} 3710 3711func (m *awsAwsjson11_deserializeOpListAccountsForParent) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3712 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3713) { 3714 out, metadata, err = next.HandleDeserialize(ctx, in) 3715 if err != nil { 3716 return out, metadata, err 3717 } 3718 3719 response, ok := out.RawResponse.(*smithyhttp.Response) 3720 if !ok { 3721 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3722 } 3723 3724 if response.StatusCode < 200 || response.StatusCode >= 300 { 3725 return out, metadata, awsAwsjson11_deserializeOpErrorListAccountsForParent(response, &metadata) 3726 } 3727 output := &ListAccountsForParentOutput{} 3728 out.Result = output 3729 3730 var buff [1024]byte 3731 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3732 3733 body := io.TeeReader(response.Body, ringBuffer) 3734 decoder := json.NewDecoder(body) 3735 decoder.UseNumber() 3736 var shape interface{} 3737 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3738 var snapshot bytes.Buffer 3739 io.Copy(&snapshot, ringBuffer) 3740 err = &smithy.DeserializationError{ 3741 Err: fmt.Errorf("failed to decode response body, %w", err), 3742 Snapshot: snapshot.Bytes(), 3743 } 3744 return out, metadata, err 3745 } 3746 3747 err = awsAwsjson11_deserializeOpDocumentListAccountsForParentOutput(&output, shape) 3748 if err != nil { 3749 var snapshot bytes.Buffer 3750 io.Copy(&snapshot, ringBuffer) 3751 err = &smithy.DeserializationError{ 3752 Err: fmt.Errorf("failed to decode response body, %w", err), 3753 Snapshot: snapshot.Bytes(), 3754 } 3755 return out, metadata, err 3756 } 3757 3758 return out, metadata, err 3759} 3760 3761func awsAwsjson11_deserializeOpErrorListAccountsForParent(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3762 var errorBuffer bytes.Buffer 3763 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3764 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3765 } 3766 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3767 3768 errorCode := "UnknownError" 3769 errorMessage := errorCode 3770 3771 code := response.Header.Get("X-Amzn-ErrorType") 3772 if len(code) != 0 { 3773 errorCode = restjson.SanitizeErrorCode(code) 3774 } 3775 3776 var buff [1024]byte 3777 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3778 3779 body := io.TeeReader(errorBody, ringBuffer) 3780 decoder := json.NewDecoder(body) 3781 decoder.UseNumber() 3782 code, message, err := restjson.GetErrorInfo(decoder) 3783 if err != nil { 3784 var snapshot bytes.Buffer 3785 io.Copy(&snapshot, ringBuffer) 3786 err = &smithy.DeserializationError{ 3787 Err: fmt.Errorf("failed to decode response body, %w", err), 3788 Snapshot: snapshot.Bytes(), 3789 } 3790 return err 3791 } 3792 3793 errorBody.Seek(0, io.SeekStart) 3794 if len(code) != 0 { 3795 errorCode = restjson.SanitizeErrorCode(code) 3796 } 3797 if len(message) != 0 { 3798 errorMessage = message 3799 } 3800 3801 switch { 3802 case strings.EqualFold("AccessDeniedException", errorCode): 3803 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 3804 3805 case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode): 3806 return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody) 3807 3808 case strings.EqualFold("InvalidInputException", errorCode): 3809 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 3810 3811 case strings.EqualFold("ParentNotFoundException", errorCode): 3812 return awsAwsjson11_deserializeErrorParentNotFoundException(response, errorBody) 3813 3814 case strings.EqualFold("ServiceException", errorCode): 3815 return awsAwsjson11_deserializeErrorServiceException(response, errorBody) 3816 3817 case strings.EqualFold("TooManyRequestsException", errorCode): 3818 return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody) 3819 3820 default: 3821 genericError := &smithy.GenericAPIError{ 3822 Code: errorCode, 3823 Message: errorMessage, 3824 } 3825 return genericError 3826 3827 } 3828} 3829 3830type awsAwsjson11_deserializeOpListAWSServiceAccessForOrganization struct { 3831} 3832 3833func (*awsAwsjson11_deserializeOpListAWSServiceAccessForOrganization) ID() string { 3834 return "OperationDeserializer" 3835} 3836 3837func (m *awsAwsjson11_deserializeOpListAWSServiceAccessForOrganization) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3838 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3839) { 3840 out, metadata, err = next.HandleDeserialize(ctx, in) 3841 if err != nil { 3842 return out, metadata, err 3843 } 3844 3845 response, ok := out.RawResponse.(*smithyhttp.Response) 3846 if !ok { 3847 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3848 } 3849 3850 if response.StatusCode < 200 || response.StatusCode >= 300 { 3851 return out, metadata, awsAwsjson11_deserializeOpErrorListAWSServiceAccessForOrganization(response, &metadata) 3852 } 3853 output := &ListAWSServiceAccessForOrganizationOutput{} 3854 out.Result = output 3855 3856 var buff [1024]byte 3857 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3858 3859 body := io.TeeReader(response.Body, ringBuffer) 3860 decoder := json.NewDecoder(body) 3861 decoder.UseNumber() 3862 var shape interface{} 3863 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3864 var snapshot bytes.Buffer 3865 io.Copy(&snapshot, ringBuffer) 3866 err = &smithy.DeserializationError{ 3867 Err: fmt.Errorf("failed to decode response body, %w", err), 3868 Snapshot: snapshot.Bytes(), 3869 } 3870 return out, metadata, err 3871 } 3872 3873 err = awsAwsjson11_deserializeOpDocumentListAWSServiceAccessForOrganizationOutput(&output, shape) 3874 if err != nil { 3875 var snapshot bytes.Buffer 3876 io.Copy(&snapshot, ringBuffer) 3877 err = &smithy.DeserializationError{ 3878 Err: fmt.Errorf("failed to decode response body, %w", err), 3879 Snapshot: snapshot.Bytes(), 3880 } 3881 return out, metadata, err 3882 } 3883 3884 return out, metadata, err 3885} 3886 3887func awsAwsjson11_deserializeOpErrorListAWSServiceAccessForOrganization(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3888 var errorBuffer bytes.Buffer 3889 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3890 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3891 } 3892 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3893 3894 errorCode := "UnknownError" 3895 errorMessage := errorCode 3896 3897 code := response.Header.Get("X-Amzn-ErrorType") 3898 if len(code) != 0 { 3899 errorCode = restjson.SanitizeErrorCode(code) 3900 } 3901 3902 var buff [1024]byte 3903 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3904 3905 body := io.TeeReader(errorBody, ringBuffer) 3906 decoder := json.NewDecoder(body) 3907 decoder.UseNumber() 3908 code, message, err := restjson.GetErrorInfo(decoder) 3909 if err != nil { 3910 var snapshot bytes.Buffer 3911 io.Copy(&snapshot, ringBuffer) 3912 err = &smithy.DeserializationError{ 3913 Err: fmt.Errorf("failed to decode response body, %w", err), 3914 Snapshot: snapshot.Bytes(), 3915 } 3916 return err 3917 } 3918 3919 errorBody.Seek(0, io.SeekStart) 3920 if len(code) != 0 { 3921 errorCode = restjson.SanitizeErrorCode(code) 3922 } 3923 if len(message) != 0 { 3924 errorMessage = message 3925 } 3926 3927 switch { 3928 case strings.EqualFold("AccessDeniedException", errorCode): 3929 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 3930 3931 case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode): 3932 return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody) 3933 3934 case strings.EqualFold("ConstraintViolationException", errorCode): 3935 return awsAwsjson11_deserializeErrorConstraintViolationException(response, errorBody) 3936 3937 case strings.EqualFold("InvalidInputException", errorCode): 3938 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 3939 3940 case strings.EqualFold("ServiceException", errorCode): 3941 return awsAwsjson11_deserializeErrorServiceException(response, errorBody) 3942 3943 case strings.EqualFold("TooManyRequestsException", errorCode): 3944 return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody) 3945 3946 case strings.EqualFold("UnsupportedAPIEndpointException", errorCode): 3947 return awsAwsjson11_deserializeErrorUnsupportedAPIEndpointException(response, errorBody) 3948 3949 default: 3950 genericError := &smithy.GenericAPIError{ 3951 Code: errorCode, 3952 Message: errorMessage, 3953 } 3954 return genericError 3955 3956 } 3957} 3958 3959type awsAwsjson11_deserializeOpListChildren struct { 3960} 3961 3962func (*awsAwsjson11_deserializeOpListChildren) ID() string { 3963 return "OperationDeserializer" 3964} 3965 3966func (m *awsAwsjson11_deserializeOpListChildren) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3967 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3968) { 3969 out, metadata, err = next.HandleDeserialize(ctx, in) 3970 if err != nil { 3971 return out, metadata, err 3972 } 3973 3974 response, ok := out.RawResponse.(*smithyhttp.Response) 3975 if !ok { 3976 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3977 } 3978 3979 if response.StatusCode < 200 || response.StatusCode >= 300 { 3980 return out, metadata, awsAwsjson11_deserializeOpErrorListChildren(response, &metadata) 3981 } 3982 output := &ListChildrenOutput{} 3983 out.Result = output 3984 3985 var buff [1024]byte 3986 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3987 3988 body := io.TeeReader(response.Body, ringBuffer) 3989 decoder := json.NewDecoder(body) 3990 decoder.UseNumber() 3991 var shape interface{} 3992 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3993 var snapshot bytes.Buffer 3994 io.Copy(&snapshot, ringBuffer) 3995 err = &smithy.DeserializationError{ 3996 Err: fmt.Errorf("failed to decode response body, %w", err), 3997 Snapshot: snapshot.Bytes(), 3998 } 3999 return out, metadata, err 4000 } 4001 4002 err = awsAwsjson11_deserializeOpDocumentListChildrenOutput(&output, shape) 4003 if err != nil { 4004 var snapshot bytes.Buffer 4005 io.Copy(&snapshot, ringBuffer) 4006 err = &smithy.DeserializationError{ 4007 Err: fmt.Errorf("failed to decode response body, %w", err), 4008 Snapshot: snapshot.Bytes(), 4009 } 4010 return out, metadata, err 4011 } 4012 4013 return out, metadata, err 4014} 4015 4016func awsAwsjson11_deserializeOpErrorListChildren(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4017 var errorBuffer bytes.Buffer 4018 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4019 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4020 } 4021 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4022 4023 errorCode := "UnknownError" 4024 errorMessage := errorCode 4025 4026 code := response.Header.Get("X-Amzn-ErrorType") 4027 if len(code) != 0 { 4028 errorCode = restjson.SanitizeErrorCode(code) 4029 } 4030 4031 var buff [1024]byte 4032 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4033 4034 body := io.TeeReader(errorBody, ringBuffer) 4035 decoder := json.NewDecoder(body) 4036 decoder.UseNumber() 4037 code, message, err := restjson.GetErrorInfo(decoder) 4038 if err != nil { 4039 var snapshot bytes.Buffer 4040 io.Copy(&snapshot, ringBuffer) 4041 err = &smithy.DeserializationError{ 4042 Err: fmt.Errorf("failed to decode response body, %w", err), 4043 Snapshot: snapshot.Bytes(), 4044 } 4045 return err 4046 } 4047 4048 errorBody.Seek(0, io.SeekStart) 4049 if len(code) != 0 { 4050 errorCode = restjson.SanitizeErrorCode(code) 4051 } 4052 if len(message) != 0 { 4053 errorMessage = message 4054 } 4055 4056 switch { 4057 case strings.EqualFold("AccessDeniedException", errorCode): 4058 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 4059 4060 case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode): 4061 return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody) 4062 4063 case strings.EqualFold("InvalidInputException", errorCode): 4064 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 4065 4066 case strings.EqualFold("ParentNotFoundException", errorCode): 4067 return awsAwsjson11_deserializeErrorParentNotFoundException(response, errorBody) 4068 4069 case strings.EqualFold("ServiceException", errorCode): 4070 return awsAwsjson11_deserializeErrorServiceException(response, errorBody) 4071 4072 case strings.EqualFold("TooManyRequestsException", errorCode): 4073 return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody) 4074 4075 default: 4076 genericError := &smithy.GenericAPIError{ 4077 Code: errorCode, 4078 Message: errorMessage, 4079 } 4080 return genericError 4081 4082 } 4083} 4084 4085type awsAwsjson11_deserializeOpListCreateAccountStatus struct { 4086} 4087 4088func (*awsAwsjson11_deserializeOpListCreateAccountStatus) ID() string { 4089 return "OperationDeserializer" 4090} 4091 4092func (m *awsAwsjson11_deserializeOpListCreateAccountStatus) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4093 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4094) { 4095 out, metadata, err = next.HandleDeserialize(ctx, in) 4096 if err != nil { 4097 return out, metadata, err 4098 } 4099 4100 response, ok := out.RawResponse.(*smithyhttp.Response) 4101 if !ok { 4102 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4103 } 4104 4105 if response.StatusCode < 200 || response.StatusCode >= 300 { 4106 return out, metadata, awsAwsjson11_deserializeOpErrorListCreateAccountStatus(response, &metadata) 4107 } 4108 output := &ListCreateAccountStatusOutput{} 4109 out.Result = output 4110 4111 var buff [1024]byte 4112 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4113 4114 body := io.TeeReader(response.Body, ringBuffer) 4115 decoder := json.NewDecoder(body) 4116 decoder.UseNumber() 4117 var shape interface{} 4118 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4119 var snapshot bytes.Buffer 4120 io.Copy(&snapshot, ringBuffer) 4121 err = &smithy.DeserializationError{ 4122 Err: fmt.Errorf("failed to decode response body, %w", err), 4123 Snapshot: snapshot.Bytes(), 4124 } 4125 return out, metadata, err 4126 } 4127 4128 err = awsAwsjson11_deserializeOpDocumentListCreateAccountStatusOutput(&output, shape) 4129 if err != nil { 4130 var snapshot bytes.Buffer 4131 io.Copy(&snapshot, ringBuffer) 4132 err = &smithy.DeserializationError{ 4133 Err: fmt.Errorf("failed to decode response body, %w", err), 4134 Snapshot: snapshot.Bytes(), 4135 } 4136 return out, metadata, err 4137 } 4138 4139 return out, metadata, err 4140} 4141 4142func awsAwsjson11_deserializeOpErrorListCreateAccountStatus(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4143 var errorBuffer bytes.Buffer 4144 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4145 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4146 } 4147 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4148 4149 errorCode := "UnknownError" 4150 errorMessage := errorCode 4151 4152 code := response.Header.Get("X-Amzn-ErrorType") 4153 if len(code) != 0 { 4154 errorCode = restjson.SanitizeErrorCode(code) 4155 } 4156 4157 var buff [1024]byte 4158 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4159 4160 body := io.TeeReader(errorBody, ringBuffer) 4161 decoder := json.NewDecoder(body) 4162 decoder.UseNumber() 4163 code, message, err := restjson.GetErrorInfo(decoder) 4164 if err != nil { 4165 var snapshot bytes.Buffer 4166 io.Copy(&snapshot, ringBuffer) 4167 err = &smithy.DeserializationError{ 4168 Err: fmt.Errorf("failed to decode response body, %w", err), 4169 Snapshot: snapshot.Bytes(), 4170 } 4171 return err 4172 } 4173 4174 errorBody.Seek(0, io.SeekStart) 4175 if len(code) != 0 { 4176 errorCode = restjson.SanitizeErrorCode(code) 4177 } 4178 if len(message) != 0 { 4179 errorMessage = message 4180 } 4181 4182 switch { 4183 case strings.EqualFold("AccessDeniedException", errorCode): 4184 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 4185 4186 case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode): 4187 return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody) 4188 4189 case strings.EqualFold("InvalidInputException", errorCode): 4190 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 4191 4192 case strings.EqualFold("ServiceException", errorCode): 4193 return awsAwsjson11_deserializeErrorServiceException(response, errorBody) 4194 4195 case strings.EqualFold("TooManyRequestsException", errorCode): 4196 return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody) 4197 4198 case strings.EqualFold("UnsupportedAPIEndpointException", errorCode): 4199 return awsAwsjson11_deserializeErrorUnsupportedAPIEndpointException(response, errorBody) 4200 4201 default: 4202 genericError := &smithy.GenericAPIError{ 4203 Code: errorCode, 4204 Message: errorMessage, 4205 } 4206 return genericError 4207 4208 } 4209} 4210 4211type awsAwsjson11_deserializeOpListDelegatedAdministrators struct { 4212} 4213 4214func (*awsAwsjson11_deserializeOpListDelegatedAdministrators) ID() string { 4215 return "OperationDeserializer" 4216} 4217 4218func (m *awsAwsjson11_deserializeOpListDelegatedAdministrators) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4219 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4220) { 4221 out, metadata, err = next.HandleDeserialize(ctx, in) 4222 if err != nil { 4223 return out, metadata, err 4224 } 4225 4226 response, ok := out.RawResponse.(*smithyhttp.Response) 4227 if !ok { 4228 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4229 } 4230 4231 if response.StatusCode < 200 || response.StatusCode >= 300 { 4232 return out, metadata, awsAwsjson11_deserializeOpErrorListDelegatedAdministrators(response, &metadata) 4233 } 4234 output := &ListDelegatedAdministratorsOutput{} 4235 out.Result = output 4236 4237 var buff [1024]byte 4238 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4239 4240 body := io.TeeReader(response.Body, ringBuffer) 4241 decoder := json.NewDecoder(body) 4242 decoder.UseNumber() 4243 var shape interface{} 4244 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4245 var snapshot bytes.Buffer 4246 io.Copy(&snapshot, ringBuffer) 4247 err = &smithy.DeserializationError{ 4248 Err: fmt.Errorf("failed to decode response body, %w", err), 4249 Snapshot: snapshot.Bytes(), 4250 } 4251 return out, metadata, err 4252 } 4253 4254 err = awsAwsjson11_deserializeOpDocumentListDelegatedAdministratorsOutput(&output, shape) 4255 if err != nil { 4256 var snapshot bytes.Buffer 4257 io.Copy(&snapshot, ringBuffer) 4258 err = &smithy.DeserializationError{ 4259 Err: fmt.Errorf("failed to decode response body, %w", err), 4260 Snapshot: snapshot.Bytes(), 4261 } 4262 return out, metadata, err 4263 } 4264 4265 return out, metadata, err 4266} 4267 4268func awsAwsjson11_deserializeOpErrorListDelegatedAdministrators(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4269 var errorBuffer bytes.Buffer 4270 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4271 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4272 } 4273 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4274 4275 errorCode := "UnknownError" 4276 errorMessage := errorCode 4277 4278 code := response.Header.Get("X-Amzn-ErrorType") 4279 if len(code) != 0 { 4280 errorCode = restjson.SanitizeErrorCode(code) 4281 } 4282 4283 var buff [1024]byte 4284 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4285 4286 body := io.TeeReader(errorBody, ringBuffer) 4287 decoder := json.NewDecoder(body) 4288 decoder.UseNumber() 4289 code, message, err := restjson.GetErrorInfo(decoder) 4290 if err != nil { 4291 var snapshot bytes.Buffer 4292 io.Copy(&snapshot, ringBuffer) 4293 err = &smithy.DeserializationError{ 4294 Err: fmt.Errorf("failed to decode response body, %w", err), 4295 Snapshot: snapshot.Bytes(), 4296 } 4297 return err 4298 } 4299 4300 errorBody.Seek(0, io.SeekStart) 4301 if len(code) != 0 { 4302 errorCode = restjson.SanitizeErrorCode(code) 4303 } 4304 if len(message) != 0 { 4305 errorMessage = message 4306 } 4307 4308 switch { 4309 case strings.EqualFold("AccessDeniedException", errorCode): 4310 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 4311 4312 case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode): 4313 return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody) 4314 4315 case strings.EqualFold("ConstraintViolationException", errorCode): 4316 return awsAwsjson11_deserializeErrorConstraintViolationException(response, errorBody) 4317 4318 case strings.EqualFold("InvalidInputException", errorCode): 4319 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 4320 4321 case strings.EqualFold("ServiceException", errorCode): 4322 return awsAwsjson11_deserializeErrorServiceException(response, errorBody) 4323 4324 case strings.EqualFold("TooManyRequestsException", errorCode): 4325 return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody) 4326 4327 case strings.EqualFold("UnsupportedAPIEndpointException", errorCode): 4328 return awsAwsjson11_deserializeErrorUnsupportedAPIEndpointException(response, errorBody) 4329 4330 default: 4331 genericError := &smithy.GenericAPIError{ 4332 Code: errorCode, 4333 Message: errorMessage, 4334 } 4335 return genericError 4336 4337 } 4338} 4339 4340type awsAwsjson11_deserializeOpListDelegatedServicesForAccount struct { 4341} 4342 4343func (*awsAwsjson11_deserializeOpListDelegatedServicesForAccount) ID() string { 4344 return "OperationDeserializer" 4345} 4346 4347func (m *awsAwsjson11_deserializeOpListDelegatedServicesForAccount) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4348 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4349) { 4350 out, metadata, err = next.HandleDeserialize(ctx, in) 4351 if err != nil { 4352 return out, metadata, err 4353 } 4354 4355 response, ok := out.RawResponse.(*smithyhttp.Response) 4356 if !ok { 4357 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4358 } 4359 4360 if response.StatusCode < 200 || response.StatusCode >= 300 { 4361 return out, metadata, awsAwsjson11_deserializeOpErrorListDelegatedServicesForAccount(response, &metadata) 4362 } 4363 output := &ListDelegatedServicesForAccountOutput{} 4364 out.Result = output 4365 4366 var buff [1024]byte 4367 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4368 4369 body := io.TeeReader(response.Body, ringBuffer) 4370 decoder := json.NewDecoder(body) 4371 decoder.UseNumber() 4372 var shape interface{} 4373 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4374 var snapshot bytes.Buffer 4375 io.Copy(&snapshot, ringBuffer) 4376 err = &smithy.DeserializationError{ 4377 Err: fmt.Errorf("failed to decode response body, %w", err), 4378 Snapshot: snapshot.Bytes(), 4379 } 4380 return out, metadata, err 4381 } 4382 4383 err = awsAwsjson11_deserializeOpDocumentListDelegatedServicesForAccountOutput(&output, shape) 4384 if err != nil { 4385 var snapshot bytes.Buffer 4386 io.Copy(&snapshot, ringBuffer) 4387 err = &smithy.DeserializationError{ 4388 Err: fmt.Errorf("failed to decode response body, %w", err), 4389 Snapshot: snapshot.Bytes(), 4390 } 4391 return out, metadata, err 4392 } 4393 4394 return out, metadata, err 4395} 4396 4397func awsAwsjson11_deserializeOpErrorListDelegatedServicesForAccount(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4398 var errorBuffer bytes.Buffer 4399 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4400 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4401 } 4402 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4403 4404 errorCode := "UnknownError" 4405 errorMessage := errorCode 4406 4407 code := response.Header.Get("X-Amzn-ErrorType") 4408 if len(code) != 0 { 4409 errorCode = restjson.SanitizeErrorCode(code) 4410 } 4411 4412 var buff [1024]byte 4413 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4414 4415 body := io.TeeReader(errorBody, ringBuffer) 4416 decoder := json.NewDecoder(body) 4417 decoder.UseNumber() 4418 code, message, err := restjson.GetErrorInfo(decoder) 4419 if err != nil { 4420 var snapshot bytes.Buffer 4421 io.Copy(&snapshot, ringBuffer) 4422 err = &smithy.DeserializationError{ 4423 Err: fmt.Errorf("failed to decode response body, %w", err), 4424 Snapshot: snapshot.Bytes(), 4425 } 4426 return err 4427 } 4428 4429 errorBody.Seek(0, io.SeekStart) 4430 if len(code) != 0 { 4431 errorCode = restjson.SanitizeErrorCode(code) 4432 } 4433 if len(message) != 0 { 4434 errorMessage = message 4435 } 4436 4437 switch { 4438 case strings.EqualFold("AccessDeniedException", errorCode): 4439 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 4440 4441 case strings.EqualFold("AccountNotFoundException", errorCode): 4442 return awsAwsjson11_deserializeErrorAccountNotFoundException(response, errorBody) 4443 4444 case strings.EqualFold("AccountNotRegisteredException", errorCode): 4445 return awsAwsjson11_deserializeErrorAccountNotRegisteredException(response, errorBody) 4446 4447 case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode): 4448 return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody) 4449 4450 case strings.EqualFold("ConstraintViolationException", errorCode): 4451 return awsAwsjson11_deserializeErrorConstraintViolationException(response, errorBody) 4452 4453 case strings.EqualFold("InvalidInputException", errorCode): 4454 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 4455 4456 case strings.EqualFold("ServiceException", errorCode): 4457 return awsAwsjson11_deserializeErrorServiceException(response, errorBody) 4458 4459 case strings.EqualFold("TooManyRequestsException", errorCode): 4460 return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody) 4461 4462 case strings.EqualFold("UnsupportedAPIEndpointException", errorCode): 4463 return awsAwsjson11_deserializeErrorUnsupportedAPIEndpointException(response, errorBody) 4464 4465 default: 4466 genericError := &smithy.GenericAPIError{ 4467 Code: errorCode, 4468 Message: errorMessage, 4469 } 4470 return genericError 4471 4472 } 4473} 4474 4475type awsAwsjson11_deserializeOpListHandshakesForAccount struct { 4476} 4477 4478func (*awsAwsjson11_deserializeOpListHandshakesForAccount) ID() string { 4479 return "OperationDeserializer" 4480} 4481 4482func (m *awsAwsjson11_deserializeOpListHandshakesForAccount) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4483 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4484) { 4485 out, metadata, err = next.HandleDeserialize(ctx, in) 4486 if err != nil { 4487 return out, metadata, err 4488 } 4489 4490 response, ok := out.RawResponse.(*smithyhttp.Response) 4491 if !ok { 4492 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4493 } 4494 4495 if response.StatusCode < 200 || response.StatusCode >= 300 { 4496 return out, metadata, awsAwsjson11_deserializeOpErrorListHandshakesForAccount(response, &metadata) 4497 } 4498 output := &ListHandshakesForAccountOutput{} 4499 out.Result = output 4500 4501 var buff [1024]byte 4502 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4503 4504 body := io.TeeReader(response.Body, ringBuffer) 4505 decoder := json.NewDecoder(body) 4506 decoder.UseNumber() 4507 var shape interface{} 4508 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4509 var snapshot bytes.Buffer 4510 io.Copy(&snapshot, ringBuffer) 4511 err = &smithy.DeserializationError{ 4512 Err: fmt.Errorf("failed to decode response body, %w", err), 4513 Snapshot: snapshot.Bytes(), 4514 } 4515 return out, metadata, err 4516 } 4517 4518 err = awsAwsjson11_deserializeOpDocumentListHandshakesForAccountOutput(&output, shape) 4519 if err != nil { 4520 var snapshot bytes.Buffer 4521 io.Copy(&snapshot, ringBuffer) 4522 err = &smithy.DeserializationError{ 4523 Err: fmt.Errorf("failed to decode response body, %w", err), 4524 Snapshot: snapshot.Bytes(), 4525 } 4526 return out, metadata, err 4527 } 4528 4529 return out, metadata, err 4530} 4531 4532func awsAwsjson11_deserializeOpErrorListHandshakesForAccount(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4533 var errorBuffer bytes.Buffer 4534 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4535 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4536 } 4537 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4538 4539 errorCode := "UnknownError" 4540 errorMessage := errorCode 4541 4542 code := response.Header.Get("X-Amzn-ErrorType") 4543 if len(code) != 0 { 4544 errorCode = restjson.SanitizeErrorCode(code) 4545 } 4546 4547 var buff [1024]byte 4548 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4549 4550 body := io.TeeReader(errorBody, ringBuffer) 4551 decoder := json.NewDecoder(body) 4552 decoder.UseNumber() 4553 code, message, err := restjson.GetErrorInfo(decoder) 4554 if err != nil { 4555 var snapshot bytes.Buffer 4556 io.Copy(&snapshot, ringBuffer) 4557 err = &smithy.DeserializationError{ 4558 Err: fmt.Errorf("failed to decode response body, %w", err), 4559 Snapshot: snapshot.Bytes(), 4560 } 4561 return err 4562 } 4563 4564 errorBody.Seek(0, io.SeekStart) 4565 if len(code) != 0 { 4566 errorCode = restjson.SanitizeErrorCode(code) 4567 } 4568 if len(message) != 0 { 4569 errorMessage = message 4570 } 4571 4572 switch { 4573 case strings.EqualFold("AccessDeniedException", errorCode): 4574 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 4575 4576 case strings.EqualFold("ConcurrentModificationException", errorCode): 4577 return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody) 4578 4579 case strings.EqualFold("InvalidInputException", errorCode): 4580 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 4581 4582 case strings.EqualFold("ServiceException", errorCode): 4583 return awsAwsjson11_deserializeErrorServiceException(response, errorBody) 4584 4585 case strings.EqualFold("TooManyRequestsException", errorCode): 4586 return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody) 4587 4588 default: 4589 genericError := &smithy.GenericAPIError{ 4590 Code: errorCode, 4591 Message: errorMessage, 4592 } 4593 return genericError 4594 4595 } 4596} 4597 4598type awsAwsjson11_deserializeOpListHandshakesForOrganization struct { 4599} 4600 4601func (*awsAwsjson11_deserializeOpListHandshakesForOrganization) ID() string { 4602 return "OperationDeserializer" 4603} 4604 4605func (m *awsAwsjson11_deserializeOpListHandshakesForOrganization) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4606 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4607) { 4608 out, metadata, err = next.HandleDeserialize(ctx, in) 4609 if err != nil { 4610 return out, metadata, err 4611 } 4612 4613 response, ok := out.RawResponse.(*smithyhttp.Response) 4614 if !ok { 4615 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4616 } 4617 4618 if response.StatusCode < 200 || response.StatusCode >= 300 { 4619 return out, metadata, awsAwsjson11_deserializeOpErrorListHandshakesForOrganization(response, &metadata) 4620 } 4621 output := &ListHandshakesForOrganizationOutput{} 4622 out.Result = output 4623 4624 var buff [1024]byte 4625 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4626 4627 body := io.TeeReader(response.Body, ringBuffer) 4628 decoder := json.NewDecoder(body) 4629 decoder.UseNumber() 4630 var shape interface{} 4631 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4632 var snapshot bytes.Buffer 4633 io.Copy(&snapshot, ringBuffer) 4634 err = &smithy.DeserializationError{ 4635 Err: fmt.Errorf("failed to decode response body, %w", err), 4636 Snapshot: snapshot.Bytes(), 4637 } 4638 return out, metadata, err 4639 } 4640 4641 err = awsAwsjson11_deserializeOpDocumentListHandshakesForOrganizationOutput(&output, shape) 4642 if err != nil { 4643 var snapshot bytes.Buffer 4644 io.Copy(&snapshot, ringBuffer) 4645 err = &smithy.DeserializationError{ 4646 Err: fmt.Errorf("failed to decode response body, %w", err), 4647 Snapshot: snapshot.Bytes(), 4648 } 4649 return out, metadata, err 4650 } 4651 4652 return out, metadata, err 4653} 4654 4655func awsAwsjson11_deserializeOpErrorListHandshakesForOrganization(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4656 var errorBuffer bytes.Buffer 4657 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4658 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4659 } 4660 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4661 4662 errorCode := "UnknownError" 4663 errorMessage := errorCode 4664 4665 code := response.Header.Get("X-Amzn-ErrorType") 4666 if len(code) != 0 { 4667 errorCode = restjson.SanitizeErrorCode(code) 4668 } 4669 4670 var buff [1024]byte 4671 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4672 4673 body := io.TeeReader(errorBody, ringBuffer) 4674 decoder := json.NewDecoder(body) 4675 decoder.UseNumber() 4676 code, message, err := restjson.GetErrorInfo(decoder) 4677 if err != nil { 4678 var snapshot bytes.Buffer 4679 io.Copy(&snapshot, ringBuffer) 4680 err = &smithy.DeserializationError{ 4681 Err: fmt.Errorf("failed to decode response body, %w", err), 4682 Snapshot: snapshot.Bytes(), 4683 } 4684 return err 4685 } 4686 4687 errorBody.Seek(0, io.SeekStart) 4688 if len(code) != 0 { 4689 errorCode = restjson.SanitizeErrorCode(code) 4690 } 4691 if len(message) != 0 { 4692 errorMessage = message 4693 } 4694 4695 switch { 4696 case strings.EqualFold("AccessDeniedException", errorCode): 4697 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 4698 4699 case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode): 4700 return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody) 4701 4702 case strings.EqualFold("ConcurrentModificationException", errorCode): 4703 return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody) 4704 4705 case strings.EqualFold("InvalidInputException", errorCode): 4706 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 4707 4708 case strings.EqualFold("ServiceException", errorCode): 4709 return awsAwsjson11_deserializeErrorServiceException(response, errorBody) 4710 4711 case strings.EqualFold("TooManyRequestsException", errorCode): 4712 return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody) 4713 4714 default: 4715 genericError := &smithy.GenericAPIError{ 4716 Code: errorCode, 4717 Message: errorMessage, 4718 } 4719 return genericError 4720 4721 } 4722} 4723 4724type awsAwsjson11_deserializeOpListOrganizationalUnitsForParent struct { 4725} 4726 4727func (*awsAwsjson11_deserializeOpListOrganizationalUnitsForParent) ID() string { 4728 return "OperationDeserializer" 4729} 4730 4731func (m *awsAwsjson11_deserializeOpListOrganizationalUnitsForParent) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4732 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4733) { 4734 out, metadata, err = next.HandleDeserialize(ctx, in) 4735 if err != nil { 4736 return out, metadata, err 4737 } 4738 4739 response, ok := out.RawResponse.(*smithyhttp.Response) 4740 if !ok { 4741 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4742 } 4743 4744 if response.StatusCode < 200 || response.StatusCode >= 300 { 4745 return out, metadata, awsAwsjson11_deserializeOpErrorListOrganizationalUnitsForParent(response, &metadata) 4746 } 4747 output := &ListOrganizationalUnitsForParentOutput{} 4748 out.Result = output 4749 4750 var buff [1024]byte 4751 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4752 4753 body := io.TeeReader(response.Body, ringBuffer) 4754 decoder := json.NewDecoder(body) 4755 decoder.UseNumber() 4756 var shape interface{} 4757 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4758 var snapshot bytes.Buffer 4759 io.Copy(&snapshot, ringBuffer) 4760 err = &smithy.DeserializationError{ 4761 Err: fmt.Errorf("failed to decode response body, %w", err), 4762 Snapshot: snapshot.Bytes(), 4763 } 4764 return out, metadata, err 4765 } 4766 4767 err = awsAwsjson11_deserializeOpDocumentListOrganizationalUnitsForParentOutput(&output, shape) 4768 if err != nil { 4769 var snapshot bytes.Buffer 4770 io.Copy(&snapshot, ringBuffer) 4771 err = &smithy.DeserializationError{ 4772 Err: fmt.Errorf("failed to decode response body, %w", err), 4773 Snapshot: snapshot.Bytes(), 4774 } 4775 return out, metadata, err 4776 } 4777 4778 return out, metadata, err 4779} 4780 4781func awsAwsjson11_deserializeOpErrorListOrganizationalUnitsForParent(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4782 var errorBuffer bytes.Buffer 4783 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4784 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4785 } 4786 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4787 4788 errorCode := "UnknownError" 4789 errorMessage := errorCode 4790 4791 code := response.Header.Get("X-Amzn-ErrorType") 4792 if len(code) != 0 { 4793 errorCode = restjson.SanitizeErrorCode(code) 4794 } 4795 4796 var buff [1024]byte 4797 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4798 4799 body := io.TeeReader(errorBody, ringBuffer) 4800 decoder := json.NewDecoder(body) 4801 decoder.UseNumber() 4802 code, message, err := restjson.GetErrorInfo(decoder) 4803 if err != nil { 4804 var snapshot bytes.Buffer 4805 io.Copy(&snapshot, ringBuffer) 4806 err = &smithy.DeserializationError{ 4807 Err: fmt.Errorf("failed to decode response body, %w", err), 4808 Snapshot: snapshot.Bytes(), 4809 } 4810 return err 4811 } 4812 4813 errorBody.Seek(0, io.SeekStart) 4814 if len(code) != 0 { 4815 errorCode = restjson.SanitizeErrorCode(code) 4816 } 4817 if len(message) != 0 { 4818 errorMessage = message 4819 } 4820 4821 switch { 4822 case strings.EqualFold("AccessDeniedException", errorCode): 4823 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 4824 4825 case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode): 4826 return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody) 4827 4828 case strings.EqualFold("InvalidInputException", errorCode): 4829 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 4830 4831 case strings.EqualFold("ParentNotFoundException", errorCode): 4832 return awsAwsjson11_deserializeErrorParentNotFoundException(response, errorBody) 4833 4834 case strings.EqualFold("ServiceException", errorCode): 4835 return awsAwsjson11_deserializeErrorServiceException(response, errorBody) 4836 4837 case strings.EqualFold("TooManyRequestsException", errorCode): 4838 return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody) 4839 4840 default: 4841 genericError := &smithy.GenericAPIError{ 4842 Code: errorCode, 4843 Message: errorMessage, 4844 } 4845 return genericError 4846 4847 } 4848} 4849 4850type awsAwsjson11_deserializeOpListParents struct { 4851} 4852 4853func (*awsAwsjson11_deserializeOpListParents) ID() string { 4854 return "OperationDeserializer" 4855} 4856 4857func (m *awsAwsjson11_deserializeOpListParents) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4858 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4859) { 4860 out, metadata, err = next.HandleDeserialize(ctx, in) 4861 if err != nil { 4862 return out, metadata, err 4863 } 4864 4865 response, ok := out.RawResponse.(*smithyhttp.Response) 4866 if !ok { 4867 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4868 } 4869 4870 if response.StatusCode < 200 || response.StatusCode >= 300 { 4871 return out, metadata, awsAwsjson11_deserializeOpErrorListParents(response, &metadata) 4872 } 4873 output := &ListParentsOutput{} 4874 out.Result = output 4875 4876 var buff [1024]byte 4877 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4878 4879 body := io.TeeReader(response.Body, ringBuffer) 4880 decoder := json.NewDecoder(body) 4881 decoder.UseNumber() 4882 var shape interface{} 4883 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4884 var snapshot bytes.Buffer 4885 io.Copy(&snapshot, ringBuffer) 4886 err = &smithy.DeserializationError{ 4887 Err: fmt.Errorf("failed to decode response body, %w", err), 4888 Snapshot: snapshot.Bytes(), 4889 } 4890 return out, metadata, err 4891 } 4892 4893 err = awsAwsjson11_deserializeOpDocumentListParentsOutput(&output, shape) 4894 if err != nil { 4895 var snapshot bytes.Buffer 4896 io.Copy(&snapshot, ringBuffer) 4897 err = &smithy.DeserializationError{ 4898 Err: fmt.Errorf("failed to decode response body, %w", err), 4899 Snapshot: snapshot.Bytes(), 4900 } 4901 return out, metadata, err 4902 } 4903 4904 return out, metadata, err 4905} 4906 4907func awsAwsjson11_deserializeOpErrorListParents(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4908 var errorBuffer bytes.Buffer 4909 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4910 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4911 } 4912 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4913 4914 errorCode := "UnknownError" 4915 errorMessage := errorCode 4916 4917 code := response.Header.Get("X-Amzn-ErrorType") 4918 if len(code) != 0 { 4919 errorCode = restjson.SanitizeErrorCode(code) 4920 } 4921 4922 var buff [1024]byte 4923 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4924 4925 body := io.TeeReader(errorBody, ringBuffer) 4926 decoder := json.NewDecoder(body) 4927 decoder.UseNumber() 4928 code, message, err := restjson.GetErrorInfo(decoder) 4929 if err != nil { 4930 var snapshot bytes.Buffer 4931 io.Copy(&snapshot, ringBuffer) 4932 err = &smithy.DeserializationError{ 4933 Err: fmt.Errorf("failed to decode response body, %w", err), 4934 Snapshot: snapshot.Bytes(), 4935 } 4936 return err 4937 } 4938 4939 errorBody.Seek(0, io.SeekStart) 4940 if len(code) != 0 { 4941 errorCode = restjson.SanitizeErrorCode(code) 4942 } 4943 if len(message) != 0 { 4944 errorMessage = message 4945 } 4946 4947 switch { 4948 case strings.EqualFold("AccessDeniedException", errorCode): 4949 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 4950 4951 case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode): 4952 return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody) 4953 4954 case strings.EqualFold("ChildNotFoundException", errorCode): 4955 return awsAwsjson11_deserializeErrorChildNotFoundException(response, errorBody) 4956 4957 case strings.EqualFold("InvalidInputException", errorCode): 4958 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 4959 4960 case strings.EqualFold("ServiceException", errorCode): 4961 return awsAwsjson11_deserializeErrorServiceException(response, errorBody) 4962 4963 case strings.EqualFold("TooManyRequestsException", errorCode): 4964 return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody) 4965 4966 default: 4967 genericError := &smithy.GenericAPIError{ 4968 Code: errorCode, 4969 Message: errorMessage, 4970 } 4971 return genericError 4972 4973 } 4974} 4975 4976type awsAwsjson11_deserializeOpListPolicies struct { 4977} 4978 4979func (*awsAwsjson11_deserializeOpListPolicies) ID() string { 4980 return "OperationDeserializer" 4981} 4982 4983func (m *awsAwsjson11_deserializeOpListPolicies) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4984 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4985) { 4986 out, metadata, err = next.HandleDeserialize(ctx, in) 4987 if err != nil { 4988 return out, metadata, err 4989 } 4990 4991 response, ok := out.RawResponse.(*smithyhttp.Response) 4992 if !ok { 4993 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4994 } 4995 4996 if response.StatusCode < 200 || response.StatusCode >= 300 { 4997 return out, metadata, awsAwsjson11_deserializeOpErrorListPolicies(response, &metadata) 4998 } 4999 output := &ListPoliciesOutput{} 5000 out.Result = output 5001 5002 var buff [1024]byte 5003 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5004 5005 body := io.TeeReader(response.Body, ringBuffer) 5006 decoder := json.NewDecoder(body) 5007 decoder.UseNumber() 5008 var shape interface{} 5009 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5010 var snapshot bytes.Buffer 5011 io.Copy(&snapshot, ringBuffer) 5012 err = &smithy.DeserializationError{ 5013 Err: fmt.Errorf("failed to decode response body, %w", err), 5014 Snapshot: snapshot.Bytes(), 5015 } 5016 return out, metadata, err 5017 } 5018 5019 err = awsAwsjson11_deserializeOpDocumentListPoliciesOutput(&output, shape) 5020 if err != nil { 5021 var snapshot bytes.Buffer 5022 io.Copy(&snapshot, ringBuffer) 5023 err = &smithy.DeserializationError{ 5024 Err: fmt.Errorf("failed to decode response body, %w", err), 5025 Snapshot: snapshot.Bytes(), 5026 } 5027 return out, metadata, err 5028 } 5029 5030 return out, metadata, err 5031} 5032 5033func awsAwsjson11_deserializeOpErrorListPolicies(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5034 var errorBuffer bytes.Buffer 5035 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5036 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5037 } 5038 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5039 5040 errorCode := "UnknownError" 5041 errorMessage := errorCode 5042 5043 code := response.Header.Get("X-Amzn-ErrorType") 5044 if len(code) != 0 { 5045 errorCode = restjson.SanitizeErrorCode(code) 5046 } 5047 5048 var buff [1024]byte 5049 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5050 5051 body := io.TeeReader(errorBody, ringBuffer) 5052 decoder := json.NewDecoder(body) 5053 decoder.UseNumber() 5054 code, message, err := restjson.GetErrorInfo(decoder) 5055 if err != nil { 5056 var snapshot bytes.Buffer 5057 io.Copy(&snapshot, ringBuffer) 5058 err = &smithy.DeserializationError{ 5059 Err: fmt.Errorf("failed to decode response body, %w", err), 5060 Snapshot: snapshot.Bytes(), 5061 } 5062 return err 5063 } 5064 5065 errorBody.Seek(0, io.SeekStart) 5066 if len(code) != 0 { 5067 errorCode = restjson.SanitizeErrorCode(code) 5068 } 5069 if len(message) != 0 { 5070 errorMessage = message 5071 } 5072 5073 switch { 5074 case strings.EqualFold("AccessDeniedException", errorCode): 5075 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 5076 5077 case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode): 5078 return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody) 5079 5080 case strings.EqualFold("InvalidInputException", errorCode): 5081 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 5082 5083 case strings.EqualFold("ServiceException", errorCode): 5084 return awsAwsjson11_deserializeErrorServiceException(response, errorBody) 5085 5086 case strings.EqualFold("TooManyRequestsException", errorCode): 5087 return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody) 5088 5089 case strings.EqualFold("UnsupportedAPIEndpointException", errorCode): 5090 return awsAwsjson11_deserializeErrorUnsupportedAPIEndpointException(response, errorBody) 5091 5092 default: 5093 genericError := &smithy.GenericAPIError{ 5094 Code: errorCode, 5095 Message: errorMessage, 5096 } 5097 return genericError 5098 5099 } 5100} 5101 5102type awsAwsjson11_deserializeOpListPoliciesForTarget struct { 5103} 5104 5105func (*awsAwsjson11_deserializeOpListPoliciesForTarget) ID() string { 5106 return "OperationDeserializer" 5107} 5108 5109func (m *awsAwsjson11_deserializeOpListPoliciesForTarget) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5110 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5111) { 5112 out, metadata, err = next.HandleDeserialize(ctx, in) 5113 if err != nil { 5114 return out, metadata, err 5115 } 5116 5117 response, ok := out.RawResponse.(*smithyhttp.Response) 5118 if !ok { 5119 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5120 } 5121 5122 if response.StatusCode < 200 || response.StatusCode >= 300 { 5123 return out, metadata, awsAwsjson11_deserializeOpErrorListPoliciesForTarget(response, &metadata) 5124 } 5125 output := &ListPoliciesForTargetOutput{} 5126 out.Result = output 5127 5128 var buff [1024]byte 5129 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5130 5131 body := io.TeeReader(response.Body, ringBuffer) 5132 decoder := json.NewDecoder(body) 5133 decoder.UseNumber() 5134 var shape interface{} 5135 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5136 var snapshot bytes.Buffer 5137 io.Copy(&snapshot, ringBuffer) 5138 err = &smithy.DeserializationError{ 5139 Err: fmt.Errorf("failed to decode response body, %w", err), 5140 Snapshot: snapshot.Bytes(), 5141 } 5142 return out, metadata, err 5143 } 5144 5145 err = awsAwsjson11_deserializeOpDocumentListPoliciesForTargetOutput(&output, shape) 5146 if err != nil { 5147 var snapshot bytes.Buffer 5148 io.Copy(&snapshot, ringBuffer) 5149 err = &smithy.DeserializationError{ 5150 Err: fmt.Errorf("failed to decode response body, %w", err), 5151 Snapshot: snapshot.Bytes(), 5152 } 5153 return out, metadata, err 5154 } 5155 5156 return out, metadata, err 5157} 5158 5159func awsAwsjson11_deserializeOpErrorListPoliciesForTarget(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5160 var errorBuffer bytes.Buffer 5161 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5162 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5163 } 5164 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5165 5166 errorCode := "UnknownError" 5167 errorMessage := errorCode 5168 5169 code := response.Header.Get("X-Amzn-ErrorType") 5170 if len(code) != 0 { 5171 errorCode = restjson.SanitizeErrorCode(code) 5172 } 5173 5174 var buff [1024]byte 5175 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5176 5177 body := io.TeeReader(errorBody, ringBuffer) 5178 decoder := json.NewDecoder(body) 5179 decoder.UseNumber() 5180 code, message, err := restjson.GetErrorInfo(decoder) 5181 if err != nil { 5182 var snapshot bytes.Buffer 5183 io.Copy(&snapshot, ringBuffer) 5184 err = &smithy.DeserializationError{ 5185 Err: fmt.Errorf("failed to decode response body, %w", err), 5186 Snapshot: snapshot.Bytes(), 5187 } 5188 return err 5189 } 5190 5191 errorBody.Seek(0, io.SeekStart) 5192 if len(code) != 0 { 5193 errorCode = restjson.SanitizeErrorCode(code) 5194 } 5195 if len(message) != 0 { 5196 errorMessage = message 5197 } 5198 5199 switch { 5200 case strings.EqualFold("AccessDeniedException", errorCode): 5201 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 5202 5203 case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode): 5204 return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody) 5205 5206 case strings.EqualFold("InvalidInputException", errorCode): 5207 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 5208 5209 case strings.EqualFold("ServiceException", errorCode): 5210 return awsAwsjson11_deserializeErrorServiceException(response, errorBody) 5211 5212 case strings.EqualFold("TargetNotFoundException", errorCode): 5213 return awsAwsjson11_deserializeErrorTargetNotFoundException(response, errorBody) 5214 5215 case strings.EqualFold("TooManyRequestsException", errorCode): 5216 return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody) 5217 5218 case strings.EqualFold("UnsupportedAPIEndpointException", errorCode): 5219 return awsAwsjson11_deserializeErrorUnsupportedAPIEndpointException(response, errorBody) 5220 5221 default: 5222 genericError := &smithy.GenericAPIError{ 5223 Code: errorCode, 5224 Message: errorMessage, 5225 } 5226 return genericError 5227 5228 } 5229} 5230 5231type awsAwsjson11_deserializeOpListRoots struct { 5232} 5233 5234func (*awsAwsjson11_deserializeOpListRoots) ID() string { 5235 return "OperationDeserializer" 5236} 5237 5238func (m *awsAwsjson11_deserializeOpListRoots) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5239 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5240) { 5241 out, metadata, err = next.HandleDeserialize(ctx, in) 5242 if err != nil { 5243 return out, metadata, err 5244 } 5245 5246 response, ok := out.RawResponse.(*smithyhttp.Response) 5247 if !ok { 5248 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5249 } 5250 5251 if response.StatusCode < 200 || response.StatusCode >= 300 { 5252 return out, metadata, awsAwsjson11_deserializeOpErrorListRoots(response, &metadata) 5253 } 5254 output := &ListRootsOutput{} 5255 out.Result = output 5256 5257 var buff [1024]byte 5258 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5259 5260 body := io.TeeReader(response.Body, ringBuffer) 5261 decoder := json.NewDecoder(body) 5262 decoder.UseNumber() 5263 var shape interface{} 5264 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5265 var snapshot bytes.Buffer 5266 io.Copy(&snapshot, ringBuffer) 5267 err = &smithy.DeserializationError{ 5268 Err: fmt.Errorf("failed to decode response body, %w", err), 5269 Snapshot: snapshot.Bytes(), 5270 } 5271 return out, metadata, err 5272 } 5273 5274 err = awsAwsjson11_deserializeOpDocumentListRootsOutput(&output, shape) 5275 if err != nil { 5276 var snapshot bytes.Buffer 5277 io.Copy(&snapshot, ringBuffer) 5278 err = &smithy.DeserializationError{ 5279 Err: fmt.Errorf("failed to decode response body, %w", err), 5280 Snapshot: snapshot.Bytes(), 5281 } 5282 return out, metadata, err 5283 } 5284 5285 return out, metadata, err 5286} 5287 5288func awsAwsjson11_deserializeOpErrorListRoots(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5289 var errorBuffer bytes.Buffer 5290 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5291 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5292 } 5293 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5294 5295 errorCode := "UnknownError" 5296 errorMessage := errorCode 5297 5298 code := response.Header.Get("X-Amzn-ErrorType") 5299 if len(code) != 0 { 5300 errorCode = restjson.SanitizeErrorCode(code) 5301 } 5302 5303 var buff [1024]byte 5304 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5305 5306 body := io.TeeReader(errorBody, ringBuffer) 5307 decoder := json.NewDecoder(body) 5308 decoder.UseNumber() 5309 code, message, err := restjson.GetErrorInfo(decoder) 5310 if err != nil { 5311 var snapshot bytes.Buffer 5312 io.Copy(&snapshot, ringBuffer) 5313 err = &smithy.DeserializationError{ 5314 Err: fmt.Errorf("failed to decode response body, %w", err), 5315 Snapshot: snapshot.Bytes(), 5316 } 5317 return err 5318 } 5319 5320 errorBody.Seek(0, io.SeekStart) 5321 if len(code) != 0 { 5322 errorCode = restjson.SanitizeErrorCode(code) 5323 } 5324 if len(message) != 0 { 5325 errorMessage = message 5326 } 5327 5328 switch { 5329 case strings.EqualFold("AccessDeniedException", errorCode): 5330 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 5331 5332 case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode): 5333 return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody) 5334 5335 case strings.EqualFold("InvalidInputException", errorCode): 5336 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 5337 5338 case strings.EqualFold("ServiceException", errorCode): 5339 return awsAwsjson11_deserializeErrorServiceException(response, errorBody) 5340 5341 case strings.EqualFold("TooManyRequestsException", errorCode): 5342 return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody) 5343 5344 default: 5345 genericError := &smithy.GenericAPIError{ 5346 Code: errorCode, 5347 Message: errorMessage, 5348 } 5349 return genericError 5350 5351 } 5352} 5353 5354type awsAwsjson11_deserializeOpListTagsForResource struct { 5355} 5356 5357func (*awsAwsjson11_deserializeOpListTagsForResource) ID() string { 5358 return "OperationDeserializer" 5359} 5360 5361func (m *awsAwsjson11_deserializeOpListTagsForResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5362 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5363) { 5364 out, metadata, err = next.HandleDeserialize(ctx, in) 5365 if err != nil { 5366 return out, metadata, err 5367 } 5368 5369 response, ok := out.RawResponse.(*smithyhttp.Response) 5370 if !ok { 5371 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5372 } 5373 5374 if response.StatusCode < 200 || response.StatusCode >= 300 { 5375 return out, metadata, awsAwsjson11_deserializeOpErrorListTagsForResource(response, &metadata) 5376 } 5377 output := &ListTagsForResourceOutput{} 5378 out.Result = output 5379 5380 var buff [1024]byte 5381 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5382 5383 body := io.TeeReader(response.Body, ringBuffer) 5384 decoder := json.NewDecoder(body) 5385 decoder.UseNumber() 5386 var shape interface{} 5387 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5388 var snapshot bytes.Buffer 5389 io.Copy(&snapshot, ringBuffer) 5390 err = &smithy.DeserializationError{ 5391 Err: fmt.Errorf("failed to decode response body, %w", err), 5392 Snapshot: snapshot.Bytes(), 5393 } 5394 return out, metadata, err 5395 } 5396 5397 err = awsAwsjson11_deserializeOpDocumentListTagsForResourceOutput(&output, shape) 5398 if err != nil { 5399 var snapshot bytes.Buffer 5400 io.Copy(&snapshot, ringBuffer) 5401 err = &smithy.DeserializationError{ 5402 Err: fmt.Errorf("failed to decode response body, %w", err), 5403 Snapshot: snapshot.Bytes(), 5404 } 5405 return out, metadata, err 5406 } 5407 5408 return out, metadata, err 5409} 5410 5411func awsAwsjson11_deserializeOpErrorListTagsForResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5412 var errorBuffer bytes.Buffer 5413 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5414 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5415 } 5416 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5417 5418 errorCode := "UnknownError" 5419 errorMessage := errorCode 5420 5421 code := response.Header.Get("X-Amzn-ErrorType") 5422 if len(code) != 0 { 5423 errorCode = restjson.SanitizeErrorCode(code) 5424 } 5425 5426 var buff [1024]byte 5427 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5428 5429 body := io.TeeReader(errorBody, ringBuffer) 5430 decoder := json.NewDecoder(body) 5431 decoder.UseNumber() 5432 code, message, err := restjson.GetErrorInfo(decoder) 5433 if err != nil { 5434 var snapshot bytes.Buffer 5435 io.Copy(&snapshot, ringBuffer) 5436 err = &smithy.DeserializationError{ 5437 Err: fmt.Errorf("failed to decode response body, %w", err), 5438 Snapshot: snapshot.Bytes(), 5439 } 5440 return err 5441 } 5442 5443 errorBody.Seek(0, io.SeekStart) 5444 if len(code) != 0 { 5445 errorCode = restjson.SanitizeErrorCode(code) 5446 } 5447 if len(message) != 0 { 5448 errorMessage = message 5449 } 5450 5451 switch { 5452 case strings.EqualFold("AccessDeniedException", errorCode): 5453 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 5454 5455 case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode): 5456 return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody) 5457 5458 case strings.EqualFold("InvalidInputException", errorCode): 5459 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 5460 5461 case strings.EqualFold("ServiceException", errorCode): 5462 return awsAwsjson11_deserializeErrorServiceException(response, errorBody) 5463 5464 case strings.EqualFold("TargetNotFoundException", errorCode): 5465 return awsAwsjson11_deserializeErrorTargetNotFoundException(response, errorBody) 5466 5467 case strings.EqualFold("TooManyRequestsException", errorCode): 5468 return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody) 5469 5470 default: 5471 genericError := &smithy.GenericAPIError{ 5472 Code: errorCode, 5473 Message: errorMessage, 5474 } 5475 return genericError 5476 5477 } 5478} 5479 5480type awsAwsjson11_deserializeOpListTargetsForPolicy struct { 5481} 5482 5483func (*awsAwsjson11_deserializeOpListTargetsForPolicy) ID() string { 5484 return "OperationDeserializer" 5485} 5486 5487func (m *awsAwsjson11_deserializeOpListTargetsForPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5488 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5489) { 5490 out, metadata, err = next.HandleDeserialize(ctx, in) 5491 if err != nil { 5492 return out, metadata, err 5493 } 5494 5495 response, ok := out.RawResponse.(*smithyhttp.Response) 5496 if !ok { 5497 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5498 } 5499 5500 if response.StatusCode < 200 || response.StatusCode >= 300 { 5501 return out, metadata, awsAwsjson11_deserializeOpErrorListTargetsForPolicy(response, &metadata) 5502 } 5503 output := &ListTargetsForPolicyOutput{} 5504 out.Result = output 5505 5506 var buff [1024]byte 5507 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5508 5509 body := io.TeeReader(response.Body, ringBuffer) 5510 decoder := json.NewDecoder(body) 5511 decoder.UseNumber() 5512 var shape interface{} 5513 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5514 var snapshot bytes.Buffer 5515 io.Copy(&snapshot, ringBuffer) 5516 err = &smithy.DeserializationError{ 5517 Err: fmt.Errorf("failed to decode response body, %w", err), 5518 Snapshot: snapshot.Bytes(), 5519 } 5520 return out, metadata, err 5521 } 5522 5523 err = awsAwsjson11_deserializeOpDocumentListTargetsForPolicyOutput(&output, shape) 5524 if err != nil { 5525 var snapshot bytes.Buffer 5526 io.Copy(&snapshot, ringBuffer) 5527 err = &smithy.DeserializationError{ 5528 Err: fmt.Errorf("failed to decode response body, %w", err), 5529 Snapshot: snapshot.Bytes(), 5530 } 5531 return out, metadata, err 5532 } 5533 5534 return out, metadata, err 5535} 5536 5537func awsAwsjson11_deserializeOpErrorListTargetsForPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5538 var errorBuffer bytes.Buffer 5539 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5540 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5541 } 5542 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5543 5544 errorCode := "UnknownError" 5545 errorMessage := errorCode 5546 5547 code := response.Header.Get("X-Amzn-ErrorType") 5548 if len(code) != 0 { 5549 errorCode = restjson.SanitizeErrorCode(code) 5550 } 5551 5552 var buff [1024]byte 5553 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5554 5555 body := io.TeeReader(errorBody, ringBuffer) 5556 decoder := json.NewDecoder(body) 5557 decoder.UseNumber() 5558 code, message, err := restjson.GetErrorInfo(decoder) 5559 if err != nil { 5560 var snapshot bytes.Buffer 5561 io.Copy(&snapshot, ringBuffer) 5562 err = &smithy.DeserializationError{ 5563 Err: fmt.Errorf("failed to decode response body, %w", err), 5564 Snapshot: snapshot.Bytes(), 5565 } 5566 return err 5567 } 5568 5569 errorBody.Seek(0, io.SeekStart) 5570 if len(code) != 0 { 5571 errorCode = restjson.SanitizeErrorCode(code) 5572 } 5573 if len(message) != 0 { 5574 errorMessage = message 5575 } 5576 5577 switch { 5578 case strings.EqualFold("AccessDeniedException", errorCode): 5579 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 5580 5581 case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode): 5582 return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody) 5583 5584 case strings.EqualFold("InvalidInputException", errorCode): 5585 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 5586 5587 case strings.EqualFold("PolicyNotFoundException", errorCode): 5588 return awsAwsjson11_deserializeErrorPolicyNotFoundException(response, errorBody) 5589 5590 case strings.EqualFold("ServiceException", errorCode): 5591 return awsAwsjson11_deserializeErrorServiceException(response, errorBody) 5592 5593 case strings.EqualFold("TooManyRequestsException", errorCode): 5594 return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody) 5595 5596 case strings.EqualFold("UnsupportedAPIEndpointException", errorCode): 5597 return awsAwsjson11_deserializeErrorUnsupportedAPIEndpointException(response, errorBody) 5598 5599 default: 5600 genericError := &smithy.GenericAPIError{ 5601 Code: errorCode, 5602 Message: errorMessage, 5603 } 5604 return genericError 5605 5606 } 5607} 5608 5609type awsAwsjson11_deserializeOpMoveAccount struct { 5610} 5611 5612func (*awsAwsjson11_deserializeOpMoveAccount) ID() string { 5613 return "OperationDeserializer" 5614} 5615 5616func (m *awsAwsjson11_deserializeOpMoveAccount) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5617 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5618) { 5619 out, metadata, err = next.HandleDeserialize(ctx, in) 5620 if err != nil { 5621 return out, metadata, err 5622 } 5623 5624 response, ok := out.RawResponse.(*smithyhttp.Response) 5625 if !ok { 5626 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5627 } 5628 5629 if response.StatusCode < 200 || response.StatusCode >= 300 { 5630 return out, metadata, awsAwsjson11_deserializeOpErrorMoveAccount(response, &metadata) 5631 } 5632 output := &MoveAccountOutput{} 5633 out.Result = output 5634 5635 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 5636 return out, metadata, &smithy.DeserializationError{ 5637 Err: fmt.Errorf("failed to discard response body, %w", err), 5638 } 5639 } 5640 5641 return out, metadata, err 5642} 5643 5644func awsAwsjson11_deserializeOpErrorMoveAccount(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5645 var errorBuffer bytes.Buffer 5646 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5647 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5648 } 5649 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5650 5651 errorCode := "UnknownError" 5652 errorMessage := errorCode 5653 5654 code := response.Header.Get("X-Amzn-ErrorType") 5655 if len(code) != 0 { 5656 errorCode = restjson.SanitizeErrorCode(code) 5657 } 5658 5659 var buff [1024]byte 5660 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5661 5662 body := io.TeeReader(errorBody, ringBuffer) 5663 decoder := json.NewDecoder(body) 5664 decoder.UseNumber() 5665 code, message, err := restjson.GetErrorInfo(decoder) 5666 if err != nil { 5667 var snapshot bytes.Buffer 5668 io.Copy(&snapshot, ringBuffer) 5669 err = &smithy.DeserializationError{ 5670 Err: fmt.Errorf("failed to decode response body, %w", err), 5671 Snapshot: snapshot.Bytes(), 5672 } 5673 return err 5674 } 5675 5676 errorBody.Seek(0, io.SeekStart) 5677 if len(code) != 0 { 5678 errorCode = restjson.SanitizeErrorCode(code) 5679 } 5680 if len(message) != 0 { 5681 errorMessage = message 5682 } 5683 5684 switch { 5685 case strings.EqualFold("AccessDeniedException", errorCode): 5686 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 5687 5688 case strings.EqualFold("AccountNotFoundException", errorCode): 5689 return awsAwsjson11_deserializeErrorAccountNotFoundException(response, errorBody) 5690 5691 case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode): 5692 return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody) 5693 5694 case strings.EqualFold("ConcurrentModificationException", errorCode): 5695 return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody) 5696 5697 case strings.EqualFold("DestinationParentNotFoundException", errorCode): 5698 return awsAwsjson11_deserializeErrorDestinationParentNotFoundException(response, errorBody) 5699 5700 case strings.EqualFold("DuplicateAccountException", errorCode): 5701 return awsAwsjson11_deserializeErrorDuplicateAccountException(response, errorBody) 5702 5703 case strings.EqualFold("InvalidInputException", errorCode): 5704 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 5705 5706 case strings.EqualFold("ServiceException", errorCode): 5707 return awsAwsjson11_deserializeErrorServiceException(response, errorBody) 5708 5709 case strings.EqualFold("SourceParentNotFoundException", errorCode): 5710 return awsAwsjson11_deserializeErrorSourceParentNotFoundException(response, errorBody) 5711 5712 case strings.EqualFold("TooManyRequestsException", errorCode): 5713 return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody) 5714 5715 default: 5716 genericError := &smithy.GenericAPIError{ 5717 Code: errorCode, 5718 Message: errorMessage, 5719 } 5720 return genericError 5721 5722 } 5723} 5724 5725type awsAwsjson11_deserializeOpRegisterDelegatedAdministrator struct { 5726} 5727 5728func (*awsAwsjson11_deserializeOpRegisterDelegatedAdministrator) ID() string { 5729 return "OperationDeserializer" 5730} 5731 5732func (m *awsAwsjson11_deserializeOpRegisterDelegatedAdministrator) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5733 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5734) { 5735 out, metadata, err = next.HandleDeserialize(ctx, in) 5736 if err != nil { 5737 return out, metadata, err 5738 } 5739 5740 response, ok := out.RawResponse.(*smithyhttp.Response) 5741 if !ok { 5742 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5743 } 5744 5745 if response.StatusCode < 200 || response.StatusCode >= 300 { 5746 return out, metadata, awsAwsjson11_deserializeOpErrorRegisterDelegatedAdministrator(response, &metadata) 5747 } 5748 output := &RegisterDelegatedAdministratorOutput{} 5749 out.Result = output 5750 5751 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 5752 return out, metadata, &smithy.DeserializationError{ 5753 Err: fmt.Errorf("failed to discard response body, %w", err), 5754 } 5755 } 5756 5757 return out, metadata, err 5758} 5759 5760func awsAwsjson11_deserializeOpErrorRegisterDelegatedAdministrator(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5761 var errorBuffer bytes.Buffer 5762 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5763 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5764 } 5765 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5766 5767 errorCode := "UnknownError" 5768 errorMessage := errorCode 5769 5770 code := response.Header.Get("X-Amzn-ErrorType") 5771 if len(code) != 0 { 5772 errorCode = restjson.SanitizeErrorCode(code) 5773 } 5774 5775 var buff [1024]byte 5776 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5777 5778 body := io.TeeReader(errorBody, ringBuffer) 5779 decoder := json.NewDecoder(body) 5780 decoder.UseNumber() 5781 code, message, err := restjson.GetErrorInfo(decoder) 5782 if err != nil { 5783 var snapshot bytes.Buffer 5784 io.Copy(&snapshot, ringBuffer) 5785 err = &smithy.DeserializationError{ 5786 Err: fmt.Errorf("failed to decode response body, %w", err), 5787 Snapshot: snapshot.Bytes(), 5788 } 5789 return err 5790 } 5791 5792 errorBody.Seek(0, io.SeekStart) 5793 if len(code) != 0 { 5794 errorCode = restjson.SanitizeErrorCode(code) 5795 } 5796 if len(message) != 0 { 5797 errorMessage = message 5798 } 5799 5800 switch { 5801 case strings.EqualFold("AccessDeniedException", errorCode): 5802 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 5803 5804 case strings.EqualFold("AccountAlreadyRegisteredException", errorCode): 5805 return awsAwsjson11_deserializeErrorAccountAlreadyRegisteredException(response, errorBody) 5806 5807 case strings.EqualFold("AccountNotFoundException", errorCode): 5808 return awsAwsjson11_deserializeErrorAccountNotFoundException(response, errorBody) 5809 5810 case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode): 5811 return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody) 5812 5813 case strings.EqualFold("ConcurrentModificationException", errorCode): 5814 return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody) 5815 5816 case strings.EqualFold("ConstraintViolationException", errorCode): 5817 return awsAwsjson11_deserializeErrorConstraintViolationException(response, errorBody) 5818 5819 case strings.EqualFold("InvalidInputException", errorCode): 5820 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 5821 5822 case strings.EqualFold("ServiceException", errorCode): 5823 return awsAwsjson11_deserializeErrorServiceException(response, errorBody) 5824 5825 case strings.EqualFold("TooManyRequestsException", errorCode): 5826 return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody) 5827 5828 case strings.EqualFold("UnsupportedAPIEndpointException", errorCode): 5829 return awsAwsjson11_deserializeErrorUnsupportedAPIEndpointException(response, errorBody) 5830 5831 default: 5832 genericError := &smithy.GenericAPIError{ 5833 Code: errorCode, 5834 Message: errorMessage, 5835 } 5836 return genericError 5837 5838 } 5839} 5840 5841type awsAwsjson11_deserializeOpRemoveAccountFromOrganization struct { 5842} 5843 5844func (*awsAwsjson11_deserializeOpRemoveAccountFromOrganization) ID() string { 5845 return "OperationDeserializer" 5846} 5847 5848func (m *awsAwsjson11_deserializeOpRemoveAccountFromOrganization) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5849 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5850) { 5851 out, metadata, err = next.HandleDeserialize(ctx, in) 5852 if err != nil { 5853 return out, metadata, err 5854 } 5855 5856 response, ok := out.RawResponse.(*smithyhttp.Response) 5857 if !ok { 5858 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5859 } 5860 5861 if response.StatusCode < 200 || response.StatusCode >= 300 { 5862 return out, metadata, awsAwsjson11_deserializeOpErrorRemoveAccountFromOrganization(response, &metadata) 5863 } 5864 output := &RemoveAccountFromOrganizationOutput{} 5865 out.Result = output 5866 5867 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 5868 return out, metadata, &smithy.DeserializationError{ 5869 Err: fmt.Errorf("failed to discard response body, %w", err), 5870 } 5871 } 5872 5873 return out, metadata, err 5874} 5875 5876func awsAwsjson11_deserializeOpErrorRemoveAccountFromOrganization(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5877 var errorBuffer bytes.Buffer 5878 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5879 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5880 } 5881 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5882 5883 errorCode := "UnknownError" 5884 errorMessage := errorCode 5885 5886 code := response.Header.Get("X-Amzn-ErrorType") 5887 if len(code) != 0 { 5888 errorCode = restjson.SanitizeErrorCode(code) 5889 } 5890 5891 var buff [1024]byte 5892 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5893 5894 body := io.TeeReader(errorBody, ringBuffer) 5895 decoder := json.NewDecoder(body) 5896 decoder.UseNumber() 5897 code, message, err := restjson.GetErrorInfo(decoder) 5898 if err != nil { 5899 var snapshot bytes.Buffer 5900 io.Copy(&snapshot, ringBuffer) 5901 err = &smithy.DeserializationError{ 5902 Err: fmt.Errorf("failed to decode response body, %w", err), 5903 Snapshot: snapshot.Bytes(), 5904 } 5905 return err 5906 } 5907 5908 errorBody.Seek(0, io.SeekStart) 5909 if len(code) != 0 { 5910 errorCode = restjson.SanitizeErrorCode(code) 5911 } 5912 if len(message) != 0 { 5913 errorMessage = message 5914 } 5915 5916 switch { 5917 case strings.EqualFold("AccessDeniedException", errorCode): 5918 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 5919 5920 case strings.EqualFold("AccountNotFoundException", errorCode): 5921 return awsAwsjson11_deserializeErrorAccountNotFoundException(response, errorBody) 5922 5923 case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode): 5924 return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody) 5925 5926 case strings.EqualFold("ConcurrentModificationException", errorCode): 5927 return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody) 5928 5929 case strings.EqualFold("ConstraintViolationException", errorCode): 5930 return awsAwsjson11_deserializeErrorConstraintViolationException(response, errorBody) 5931 5932 case strings.EqualFold("InvalidInputException", errorCode): 5933 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 5934 5935 case strings.EqualFold("MasterCannotLeaveOrganizationException", errorCode): 5936 return awsAwsjson11_deserializeErrorMasterCannotLeaveOrganizationException(response, errorBody) 5937 5938 case strings.EqualFold("ServiceException", errorCode): 5939 return awsAwsjson11_deserializeErrorServiceException(response, errorBody) 5940 5941 case strings.EqualFold("TooManyRequestsException", errorCode): 5942 return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody) 5943 5944 default: 5945 genericError := &smithy.GenericAPIError{ 5946 Code: errorCode, 5947 Message: errorMessage, 5948 } 5949 return genericError 5950 5951 } 5952} 5953 5954type awsAwsjson11_deserializeOpTagResource struct { 5955} 5956 5957func (*awsAwsjson11_deserializeOpTagResource) ID() string { 5958 return "OperationDeserializer" 5959} 5960 5961func (m *awsAwsjson11_deserializeOpTagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5962 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5963) { 5964 out, metadata, err = next.HandleDeserialize(ctx, in) 5965 if err != nil { 5966 return out, metadata, err 5967 } 5968 5969 response, ok := out.RawResponse.(*smithyhttp.Response) 5970 if !ok { 5971 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5972 } 5973 5974 if response.StatusCode < 200 || response.StatusCode >= 300 { 5975 return out, metadata, awsAwsjson11_deserializeOpErrorTagResource(response, &metadata) 5976 } 5977 output := &TagResourceOutput{} 5978 out.Result = output 5979 5980 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 5981 return out, metadata, &smithy.DeserializationError{ 5982 Err: fmt.Errorf("failed to discard response body, %w", err), 5983 } 5984 } 5985 5986 return out, metadata, err 5987} 5988 5989func awsAwsjson11_deserializeOpErrorTagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5990 var errorBuffer bytes.Buffer 5991 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5992 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5993 } 5994 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5995 5996 errorCode := "UnknownError" 5997 errorMessage := errorCode 5998 5999 code := response.Header.Get("X-Amzn-ErrorType") 6000 if len(code) != 0 { 6001 errorCode = restjson.SanitizeErrorCode(code) 6002 } 6003 6004 var buff [1024]byte 6005 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6006 6007 body := io.TeeReader(errorBody, ringBuffer) 6008 decoder := json.NewDecoder(body) 6009 decoder.UseNumber() 6010 code, message, err := restjson.GetErrorInfo(decoder) 6011 if err != nil { 6012 var snapshot bytes.Buffer 6013 io.Copy(&snapshot, ringBuffer) 6014 err = &smithy.DeserializationError{ 6015 Err: fmt.Errorf("failed to decode response body, %w", err), 6016 Snapshot: snapshot.Bytes(), 6017 } 6018 return err 6019 } 6020 6021 errorBody.Seek(0, io.SeekStart) 6022 if len(code) != 0 { 6023 errorCode = restjson.SanitizeErrorCode(code) 6024 } 6025 if len(message) != 0 { 6026 errorMessage = message 6027 } 6028 6029 switch { 6030 case strings.EqualFold("AccessDeniedException", errorCode): 6031 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 6032 6033 case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode): 6034 return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody) 6035 6036 case strings.EqualFold("ConcurrentModificationException", errorCode): 6037 return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody) 6038 6039 case strings.EqualFold("ConstraintViolationException", errorCode): 6040 return awsAwsjson11_deserializeErrorConstraintViolationException(response, errorBody) 6041 6042 case strings.EqualFold("InvalidInputException", errorCode): 6043 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 6044 6045 case strings.EqualFold("ServiceException", errorCode): 6046 return awsAwsjson11_deserializeErrorServiceException(response, errorBody) 6047 6048 case strings.EqualFold("TargetNotFoundException", errorCode): 6049 return awsAwsjson11_deserializeErrorTargetNotFoundException(response, errorBody) 6050 6051 case strings.EqualFold("TooManyRequestsException", errorCode): 6052 return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody) 6053 6054 default: 6055 genericError := &smithy.GenericAPIError{ 6056 Code: errorCode, 6057 Message: errorMessage, 6058 } 6059 return genericError 6060 6061 } 6062} 6063 6064type awsAwsjson11_deserializeOpUntagResource struct { 6065} 6066 6067func (*awsAwsjson11_deserializeOpUntagResource) ID() string { 6068 return "OperationDeserializer" 6069} 6070 6071func (m *awsAwsjson11_deserializeOpUntagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6072 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6073) { 6074 out, metadata, err = next.HandleDeserialize(ctx, in) 6075 if err != nil { 6076 return out, metadata, err 6077 } 6078 6079 response, ok := out.RawResponse.(*smithyhttp.Response) 6080 if !ok { 6081 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6082 } 6083 6084 if response.StatusCode < 200 || response.StatusCode >= 300 { 6085 return out, metadata, awsAwsjson11_deserializeOpErrorUntagResource(response, &metadata) 6086 } 6087 output := &UntagResourceOutput{} 6088 out.Result = output 6089 6090 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 6091 return out, metadata, &smithy.DeserializationError{ 6092 Err: fmt.Errorf("failed to discard response body, %w", err), 6093 } 6094 } 6095 6096 return out, metadata, err 6097} 6098 6099func awsAwsjson11_deserializeOpErrorUntagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6100 var errorBuffer bytes.Buffer 6101 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6102 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6103 } 6104 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6105 6106 errorCode := "UnknownError" 6107 errorMessage := errorCode 6108 6109 code := response.Header.Get("X-Amzn-ErrorType") 6110 if len(code) != 0 { 6111 errorCode = restjson.SanitizeErrorCode(code) 6112 } 6113 6114 var buff [1024]byte 6115 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6116 6117 body := io.TeeReader(errorBody, ringBuffer) 6118 decoder := json.NewDecoder(body) 6119 decoder.UseNumber() 6120 code, message, err := restjson.GetErrorInfo(decoder) 6121 if err != nil { 6122 var snapshot bytes.Buffer 6123 io.Copy(&snapshot, ringBuffer) 6124 err = &smithy.DeserializationError{ 6125 Err: fmt.Errorf("failed to decode response body, %w", err), 6126 Snapshot: snapshot.Bytes(), 6127 } 6128 return err 6129 } 6130 6131 errorBody.Seek(0, io.SeekStart) 6132 if len(code) != 0 { 6133 errorCode = restjson.SanitizeErrorCode(code) 6134 } 6135 if len(message) != 0 { 6136 errorMessage = message 6137 } 6138 6139 switch { 6140 case strings.EqualFold("AccessDeniedException", errorCode): 6141 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 6142 6143 case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode): 6144 return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody) 6145 6146 case strings.EqualFold("ConcurrentModificationException", errorCode): 6147 return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody) 6148 6149 case strings.EqualFold("ConstraintViolationException", errorCode): 6150 return awsAwsjson11_deserializeErrorConstraintViolationException(response, errorBody) 6151 6152 case strings.EqualFold("InvalidInputException", errorCode): 6153 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 6154 6155 case strings.EqualFold("ServiceException", errorCode): 6156 return awsAwsjson11_deserializeErrorServiceException(response, errorBody) 6157 6158 case strings.EqualFold("TargetNotFoundException", errorCode): 6159 return awsAwsjson11_deserializeErrorTargetNotFoundException(response, errorBody) 6160 6161 case strings.EqualFold("TooManyRequestsException", errorCode): 6162 return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody) 6163 6164 default: 6165 genericError := &smithy.GenericAPIError{ 6166 Code: errorCode, 6167 Message: errorMessage, 6168 } 6169 return genericError 6170 6171 } 6172} 6173 6174type awsAwsjson11_deserializeOpUpdateOrganizationalUnit struct { 6175} 6176 6177func (*awsAwsjson11_deserializeOpUpdateOrganizationalUnit) ID() string { 6178 return "OperationDeserializer" 6179} 6180 6181func (m *awsAwsjson11_deserializeOpUpdateOrganizationalUnit) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6182 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6183) { 6184 out, metadata, err = next.HandleDeserialize(ctx, in) 6185 if err != nil { 6186 return out, metadata, err 6187 } 6188 6189 response, ok := out.RawResponse.(*smithyhttp.Response) 6190 if !ok { 6191 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6192 } 6193 6194 if response.StatusCode < 200 || response.StatusCode >= 300 { 6195 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateOrganizationalUnit(response, &metadata) 6196 } 6197 output := &UpdateOrganizationalUnitOutput{} 6198 out.Result = output 6199 6200 var buff [1024]byte 6201 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6202 6203 body := io.TeeReader(response.Body, ringBuffer) 6204 decoder := json.NewDecoder(body) 6205 decoder.UseNumber() 6206 var shape interface{} 6207 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6208 var snapshot bytes.Buffer 6209 io.Copy(&snapshot, ringBuffer) 6210 err = &smithy.DeserializationError{ 6211 Err: fmt.Errorf("failed to decode response body, %w", err), 6212 Snapshot: snapshot.Bytes(), 6213 } 6214 return out, metadata, err 6215 } 6216 6217 err = awsAwsjson11_deserializeOpDocumentUpdateOrganizationalUnitOutput(&output, shape) 6218 if err != nil { 6219 var snapshot bytes.Buffer 6220 io.Copy(&snapshot, ringBuffer) 6221 err = &smithy.DeserializationError{ 6222 Err: fmt.Errorf("failed to decode response body, %w", err), 6223 Snapshot: snapshot.Bytes(), 6224 } 6225 return out, metadata, err 6226 } 6227 6228 return out, metadata, err 6229} 6230 6231func awsAwsjson11_deserializeOpErrorUpdateOrganizationalUnit(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6232 var errorBuffer bytes.Buffer 6233 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6234 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6235 } 6236 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6237 6238 errorCode := "UnknownError" 6239 errorMessage := errorCode 6240 6241 code := response.Header.Get("X-Amzn-ErrorType") 6242 if len(code) != 0 { 6243 errorCode = restjson.SanitizeErrorCode(code) 6244 } 6245 6246 var buff [1024]byte 6247 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6248 6249 body := io.TeeReader(errorBody, ringBuffer) 6250 decoder := json.NewDecoder(body) 6251 decoder.UseNumber() 6252 code, message, err := restjson.GetErrorInfo(decoder) 6253 if err != nil { 6254 var snapshot bytes.Buffer 6255 io.Copy(&snapshot, ringBuffer) 6256 err = &smithy.DeserializationError{ 6257 Err: fmt.Errorf("failed to decode response body, %w", err), 6258 Snapshot: snapshot.Bytes(), 6259 } 6260 return err 6261 } 6262 6263 errorBody.Seek(0, io.SeekStart) 6264 if len(code) != 0 { 6265 errorCode = restjson.SanitizeErrorCode(code) 6266 } 6267 if len(message) != 0 { 6268 errorMessage = message 6269 } 6270 6271 switch { 6272 case strings.EqualFold("AccessDeniedException", errorCode): 6273 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 6274 6275 case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode): 6276 return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody) 6277 6278 case strings.EqualFold("ConcurrentModificationException", errorCode): 6279 return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody) 6280 6281 case strings.EqualFold("DuplicateOrganizationalUnitException", errorCode): 6282 return awsAwsjson11_deserializeErrorDuplicateOrganizationalUnitException(response, errorBody) 6283 6284 case strings.EqualFold("InvalidInputException", errorCode): 6285 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 6286 6287 case strings.EqualFold("OrganizationalUnitNotFoundException", errorCode): 6288 return awsAwsjson11_deserializeErrorOrganizationalUnitNotFoundException(response, errorBody) 6289 6290 case strings.EqualFold("ServiceException", errorCode): 6291 return awsAwsjson11_deserializeErrorServiceException(response, errorBody) 6292 6293 case strings.EqualFold("TooManyRequestsException", errorCode): 6294 return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody) 6295 6296 default: 6297 genericError := &smithy.GenericAPIError{ 6298 Code: errorCode, 6299 Message: errorMessage, 6300 } 6301 return genericError 6302 6303 } 6304} 6305 6306type awsAwsjson11_deserializeOpUpdatePolicy struct { 6307} 6308 6309func (*awsAwsjson11_deserializeOpUpdatePolicy) ID() string { 6310 return "OperationDeserializer" 6311} 6312 6313func (m *awsAwsjson11_deserializeOpUpdatePolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6314 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6315) { 6316 out, metadata, err = next.HandleDeserialize(ctx, in) 6317 if err != nil { 6318 return out, metadata, err 6319 } 6320 6321 response, ok := out.RawResponse.(*smithyhttp.Response) 6322 if !ok { 6323 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6324 } 6325 6326 if response.StatusCode < 200 || response.StatusCode >= 300 { 6327 return out, metadata, awsAwsjson11_deserializeOpErrorUpdatePolicy(response, &metadata) 6328 } 6329 output := &UpdatePolicyOutput{} 6330 out.Result = output 6331 6332 var buff [1024]byte 6333 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6334 6335 body := io.TeeReader(response.Body, ringBuffer) 6336 decoder := json.NewDecoder(body) 6337 decoder.UseNumber() 6338 var shape interface{} 6339 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6340 var snapshot bytes.Buffer 6341 io.Copy(&snapshot, ringBuffer) 6342 err = &smithy.DeserializationError{ 6343 Err: fmt.Errorf("failed to decode response body, %w", err), 6344 Snapshot: snapshot.Bytes(), 6345 } 6346 return out, metadata, err 6347 } 6348 6349 err = awsAwsjson11_deserializeOpDocumentUpdatePolicyOutput(&output, shape) 6350 if err != nil { 6351 var snapshot bytes.Buffer 6352 io.Copy(&snapshot, ringBuffer) 6353 err = &smithy.DeserializationError{ 6354 Err: fmt.Errorf("failed to decode response body, %w", err), 6355 Snapshot: snapshot.Bytes(), 6356 } 6357 return out, metadata, err 6358 } 6359 6360 return out, metadata, err 6361} 6362 6363func awsAwsjson11_deserializeOpErrorUpdatePolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6364 var errorBuffer bytes.Buffer 6365 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6366 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6367 } 6368 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6369 6370 errorCode := "UnknownError" 6371 errorMessage := errorCode 6372 6373 code := response.Header.Get("X-Amzn-ErrorType") 6374 if len(code) != 0 { 6375 errorCode = restjson.SanitizeErrorCode(code) 6376 } 6377 6378 var buff [1024]byte 6379 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6380 6381 body := io.TeeReader(errorBody, ringBuffer) 6382 decoder := json.NewDecoder(body) 6383 decoder.UseNumber() 6384 code, message, err := restjson.GetErrorInfo(decoder) 6385 if err != nil { 6386 var snapshot bytes.Buffer 6387 io.Copy(&snapshot, ringBuffer) 6388 err = &smithy.DeserializationError{ 6389 Err: fmt.Errorf("failed to decode response body, %w", err), 6390 Snapshot: snapshot.Bytes(), 6391 } 6392 return err 6393 } 6394 6395 errorBody.Seek(0, io.SeekStart) 6396 if len(code) != 0 { 6397 errorCode = restjson.SanitizeErrorCode(code) 6398 } 6399 if len(message) != 0 { 6400 errorMessage = message 6401 } 6402 6403 switch { 6404 case strings.EqualFold("AccessDeniedException", errorCode): 6405 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 6406 6407 case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode): 6408 return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody) 6409 6410 case strings.EqualFold("ConcurrentModificationException", errorCode): 6411 return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody) 6412 6413 case strings.EqualFold("ConstraintViolationException", errorCode): 6414 return awsAwsjson11_deserializeErrorConstraintViolationException(response, errorBody) 6415 6416 case strings.EqualFold("DuplicatePolicyException", errorCode): 6417 return awsAwsjson11_deserializeErrorDuplicatePolicyException(response, errorBody) 6418 6419 case strings.EqualFold("InvalidInputException", errorCode): 6420 return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody) 6421 6422 case strings.EqualFold("MalformedPolicyDocumentException", errorCode): 6423 return awsAwsjson11_deserializeErrorMalformedPolicyDocumentException(response, errorBody) 6424 6425 case strings.EqualFold("PolicyChangesInProgressException", errorCode): 6426 return awsAwsjson11_deserializeErrorPolicyChangesInProgressException(response, errorBody) 6427 6428 case strings.EqualFold("PolicyNotFoundException", errorCode): 6429 return awsAwsjson11_deserializeErrorPolicyNotFoundException(response, errorBody) 6430 6431 case strings.EqualFold("ServiceException", errorCode): 6432 return awsAwsjson11_deserializeErrorServiceException(response, errorBody) 6433 6434 case strings.EqualFold("TooManyRequestsException", errorCode): 6435 return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody) 6436 6437 case strings.EqualFold("UnsupportedAPIEndpointException", errorCode): 6438 return awsAwsjson11_deserializeErrorUnsupportedAPIEndpointException(response, errorBody) 6439 6440 default: 6441 genericError := &smithy.GenericAPIError{ 6442 Code: errorCode, 6443 Message: errorMessage, 6444 } 6445 return genericError 6446 6447 } 6448} 6449 6450func awsAwsjson11_deserializeErrorAccessDeniedException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 6451 var buff [1024]byte 6452 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6453 6454 body := io.TeeReader(errorBody, ringBuffer) 6455 decoder := json.NewDecoder(body) 6456 decoder.UseNumber() 6457 var shape interface{} 6458 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6459 var snapshot bytes.Buffer 6460 io.Copy(&snapshot, ringBuffer) 6461 err = &smithy.DeserializationError{ 6462 Err: fmt.Errorf("failed to decode response body, %w", err), 6463 Snapshot: snapshot.Bytes(), 6464 } 6465 return err 6466 } 6467 6468 output := &types.AccessDeniedException{} 6469 err := awsAwsjson11_deserializeDocumentAccessDeniedException(&output, shape) 6470 6471 if err != nil { 6472 var snapshot bytes.Buffer 6473 io.Copy(&snapshot, ringBuffer) 6474 err = &smithy.DeserializationError{ 6475 Err: fmt.Errorf("failed to decode response body, %w", err), 6476 Snapshot: snapshot.Bytes(), 6477 } 6478 return err 6479 } 6480 6481 errorBody.Seek(0, io.SeekStart) 6482 return output 6483} 6484 6485func awsAwsjson11_deserializeErrorAccessDeniedForDependencyException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 6486 var buff [1024]byte 6487 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6488 6489 body := io.TeeReader(errorBody, ringBuffer) 6490 decoder := json.NewDecoder(body) 6491 decoder.UseNumber() 6492 var shape interface{} 6493 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6494 var snapshot bytes.Buffer 6495 io.Copy(&snapshot, ringBuffer) 6496 err = &smithy.DeserializationError{ 6497 Err: fmt.Errorf("failed to decode response body, %w", err), 6498 Snapshot: snapshot.Bytes(), 6499 } 6500 return err 6501 } 6502 6503 output := &types.AccessDeniedForDependencyException{} 6504 err := awsAwsjson11_deserializeDocumentAccessDeniedForDependencyException(&output, shape) 6505 6506 if err != nil { 6507 var snapshot bytes.Buffer 6508 io.Copy(&snapshot, ringBuffer) 6509 err = &smithy.DeserializationError{ 6510 Err: fmt.Errorf("failed to decode response body, %w", err), 6511 Snapshot: snapshot.Bytes(), 6512 } 6513 return err 6514 } 6515 6516 errorBody.Seek(0, io.SeekStart) 6517 return output 6518} 6519 6520func awsAwsjson11_deserializeErrorAccountAlreadyRegisteredException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 6521 var buff [1024]byte 6522 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6523 6524 body := io.TeeReader(errorBody, ringBuffer) 6525 decoder := json.NewDecoder(body) 6526 decoder.UseNumber() 6527 var shape interface{} 6528 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6529 var snapshot bytes.Buffer 6530 io.Copy(&snapshot, ringBuffer) 6531 err = &smithy.DeserializationError{ 6532 Err: fmt.Errorf("failed to decode response body, %w", err), 6533 Snapshot: snapshot.Bytes(), 6534 } 6535 return err 6536 } 6537 6538 output := &types.AccountAlreadyRegisteredException{} 6539 err := awsAwsjson11_deserializeDocumentAccountAlreadyRegisteredException(&output, shape) 6540 6541 if err != nil { 6542 var snapshot bytes.Buffer 6543 io.Copy(&snapshot, ringBuffer) 6544 err = &smithy.DeserializationError{ 6545 Err: fmt.Errorf("failed to decode response body, %w", err), 6546 Snapshot: snapshot.Bytes(), 6547 } 6548 return err 6549 } 6550 6551 errorBody.Seek(0, io.SeekStart) 6552 return output 6553} 6554 6555func awsAwsjson11_deserializeErrorAccountNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 6556 var buff [1024]byte 6557 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6558 6559 body := io.TeeReader(errorBody, ringBuffer) 6560 decoder := json.NewDecoder(body) 6561 decoder.UseNumber() 6562 var shape interface{} 6563 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6564 var snapshot bytes.Buffer 6565 io.Copy(&snapshot, ringBuffer) 6566 err = &smithy.DeserializationError{ 6567 Err: fmt.Errorf("failed to decode response body, %w", err), 6568 Snapshot: snapshot.Bytes(), 6569 } 6570 return err 6571 } 6572 6573 output := &types.AccountNotFoundException{} 6574 err := awsAwsjson11_deserializeDocumentAccountNotFoundException(&output, shape) 6575 6576 if err != nil { 6577 var snapshot bytes.Buffer 6578 io.Copy(&snapshot, ringBuffer) 6579 err = &smithy.DeserializationError{ 6580 Err: fmt.Errorf("failed to decode response body, %w", err), 6581 Snapshot: snapshot.Bytes(), 6582 } 6583 return err 6584 } 6585 6586 errorBody.Seek(0, io.SeekStart) 6587 return output 6588} 6589 6590func awsAwsjson11_deserializeErrorAccountNotRegisteredException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 6591 var buff [1024]byte 6592 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6593 6594 body := io.TeeReader(errorBody, ringBuffer) 6595 decoder := json.NewDecoder(body) 6596 decoder.UseNumber() 6597 var shape interface{} 6598 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6599 var snapshot bytes.Buffer 6600 io.Copy(&snapshot, ringBuffer) 6601 err = &smithy.DeserializationError{ 6602 Err: fmt.Errorf("failed to decode response body, %w", err), 6603 Snapshot: snapshot.Bytes(), 6604 } 6605 return err 6606 } 6607 6608 output := &types.AccountNotRegisteredException{} 6609 err := awsAwsjson11_deserializeDocumentAccountNotRegisteredException(&output, shape) 6610 6611 if err != nil { 6612 var snapshot bytes.Buffer 6613 io.Copy(&snapshot, ringBuffer) 6614 err = &smithy.DeserializationError{ 6615 Err: fmt.Errorf("failed to decode response body, %w", err), 6616 Snapshot: snapshot.Bytes(), 6617 } 6618 return err 6619 } 6620 6621 errorBody.Seek(0, io.SeekStart) 6622 return output 6623} 6624 6625func awsAwsjson11_deserializeErrorAccountOwnerNotVerifiedException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 6626 var buff [1024]byte 6627 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6628 6629 body := io.TeeReader(errorBody, ringBuffer) 6630 decoder := json.NewDecoder(body) 6631 decoder.UseNumber() 6632 var shape interface{} 6633 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6634 var snapshot bytes.Buffer 6635 io.Copy(&snapshot, ringBuffer) 6636 err = &smithy.DeserializationError{ 6637 Err: fmt.Errorf("failed to decode response body, %w", err), 6638 Snapshot: snapshot.Bytes(), 6639 } 6640 return err 6641 } 6642 6643 output := &types.AccountOwnerNotVerifiedException{} 6644 err := awsAwsjson11_deserializeDocumentAccountOwnerNotVerifiedException(&output, shape) 6645 6646 if err != nil { 6647 var snapshot bytes.Buffer 6648 io.Copy(&snapshot, ringBuffer) 6649 err = &smithy.DeserializationError{ 6650 Err: fmt.Errorf("failed to decode response body, %w", err), 6651 Snapshot: snapshot.Bytes(), 6652 } 6653 return err 6654 } 6655 6656 errorBody.Seek(0, io.SeekStart) 6657 return output 6658} 6659 6660func awsAwsjson11_deserializeErrorAlreadyInOrganizationException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 6661 var buff [1024]byte 6662 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6663 6664 body := io.TeeReader(errorBody, ringBuffer) 6665 decoder := json.NewDecoder(body) 6666 decoder.UseNumber() 6667 var shape interface{} 6668 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6669 var snapshot bytes.Buffer 6670 io.Copy(&snapshot, ringBuffer) 6671 err = &smithy.DeserializationError{ 6672 Err: fmt.Errorf("failed to decode response body, %w", err), 6673 Snapshot: snapshot.Bytes(), 6674 } 6675 return err 6676 } 6677 6678 output := &types.AlreadyInOrganizationException{} 6679 err := awsAwsjson11_deserializeDocumentAlreadyInOrganizationException(&output, shape) 6680 6681 if err != nil { 6682 var snapshot bytes.Buffer 6683 io.Copy(&snapshot, ringBuffer) 6684 err = &smithy.DeserializationError{ 6685 Err: fmt.Errorf("failed to decode response body, %w", err), 6686 Snapshot: snapshot.Bytes(), 6687 } 6688 return err 6689 } 6690 6691 errorBody.Seek(0, io.SeekStart) 6692 return output 6693} 6694 6695func awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 6696 var buff [1024]byte 6697 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6698 6699 body := io.TeeReader(errorBody, ringBuffer) 6700 decoder := json.NewDecoder(body) 6701 decoder.UseNumber() 6702 var shape interface{} 6703 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6704 var snapshot bytes.Buffer 6705 io.Copy(&snapshot, ringBuffer) 6706 err = &smithy.DeserializationError{ 6707 Err: fmt.Errorf("failed to decode response body, %w", err), 6708 Snapshot: snapshot.Bytes(), 6709 } 6710 return err 6711 } 6712 6713 output := &types.AWSOrganizationsNotInUseException{} 6714 err := awsAwsjson11_deserializeDocumentAWSOrganizationsNotInUseException(&output, shape) 6715 6716 if err != nil { 6717 var snapshot bytes.Buffer 6718 io.Copy(&snapshot, ringBuffer) 6719 err = &smithy.DeserializationError{ 6720 Err: fmt.Errorf("failed to decode response body, %w", err), 6721 Snapshot: snapshot.Bytes(), 6722 } 6723 return err 6724 } 6725 6726 errorBody.Seek(0, io.SeekStart) 6727 return output 6728} 6729 6730func awsAwsjson11_deserializeErrorChildNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 6731 var buff [1024]byte 6732 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6733 6734 body := io.TeeReader(errorBody, ringBuffer) 6735 decoder := json.NewDecoder(body) 6736 decoder.UseNumber() 6737 var shape interface{} 6738 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6739 var snapshot bytes.Buffer 6740 io.Copy(&snapshot, ringBuffer) 6741 err = &smithy.DeserializationError{ 6742 Err: fmt.Errorf("failed to decode response body, %w", err), 6743 Snapshot: snapshot.Bytes(), 6744 } 6745 return err 6746 } 6747 6748 output := &types.ChildNotFoundException{} 6749 err := awsAwsjson11_deserializeDocumentChildNotFoundException(&output, shape) 6750 6751 if err != nil { 6752 var snapshot bytes.Buffer 6753 io.Copy(&snapshot, ringBuffer) 6754 err = &smithy.DeserializationError{ 6755 Err: fmt.Errorf("failed to decode response body, %w", err), 6756 Snapshot: snapshot.Bytes(), 6757 } 6758 return err 6759 } 6760 6761 errorBody.Seek(0, io.SeekStart) 6762 return output 6763} 6764 6765func awsAwsjson11_deserializeErrorConcurrentModificationException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 6766 var buff [1024]byte 6767 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6768 6769 body := io.TeeReader(errorBody, ringBuffer) 6770 decoder := json.NewDecoder(body) 6771 decoder.UseNumber() 6772 var shape interface{} 6773 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6774 var snapshot bytes.Buffer 6775 io.Copy(&snapshot, ringBuffer) 6776 err = &smithy.DeserializationError{ 6777 Err: fmt.Errorf("failed to decode response body, %w", err), 6778 Snapshot: snapshot.Bytes(), 6779 } 6780 return err 6781 } 6782 6783 output := &types.ConcurrentModificationException{} 6784 err := awsAwsjson11_deserializeDocumentConcurrentModificationException(&output, shape) 6785 6786 if err != nil { 6787 var snapshot bytes.Buffer 6788 io.Copy(&snapshot, ringBuffer) 6789 err = &smithy.DeserializationError{ 6790 Err: fmt.Errorf("failed to decode response body, %w", err), 6791 Snapshot: snapshot.Bytes(), 6792 } 6793 return err 6794 } 6795 6796 errorBody.Seek(0, io.SeekStart) 6797 return output 6798} 6799 6800func awsAwsjson11_deserializeErrorConstraintViolationException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 6801 var buff [1024]byte 6802 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6803 6804 body := io.TeeReader(errorBody, ringBuffer) 6805 decoder := json.NewDecoder(body) 6806 decoder.UseNumber() 6807 var shape interface{} 6808 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6809 var snapshot bytes.Buffer 6810 io.Copy(&snapshot, ringBuffer) 6811 err = &smithy.DeserializationError{ 6812 Err: fmt.Errorf("failed to decode response body, %w", err), 6813 Snapshot: snapshot.Bytes(), 6814 } 6815 return err 6816 } 6817 6818 output := &types.ConstraintViolationException{} 6819 err := awsAwsjson11_deserializeDocumentConstraintViolationException(&output, shape) 6820 6821 if err != nil { 6822 var snapshot bytes.Buffer 6823 io.Copy(&snapshot, ringBuffer) 6824 err = &smithy.DeserializationError{ 6825 Err: fmt.Errorf("failed to decode response body, %w", err), 6826 Snapshot: snapshot.Bytes(), 6827 } 6828 return err 6829 } 6830 6831 errorBody.Seek(0, io.SeekStart) 6832 return output 6833} 6834 6835func awsAwsjson11_deserializeErrorCreateAccountStatusNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 6836 var buff [1024]byte 6837 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6838 6839 body := io.TeeReader(errorBody, ringBuffer) 6840 decoder := json.NewDecoder(body) 6841 decoder.UseNumber() 6842 var shape interface{} 6843 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6844 var snapshot bytes.Buffer 6845 io.Copy(&snapshot, ringBuffer) 6846 err = &smithy.DeserializationError{ 6847 Err: fmt.Errorf("failed to decode response body, %w", err), 6848 Snapshot: snapshot.Bytes(), 6849 } 6850 return err 6851 } 6852 6853 output := &types.CreateAccountStatusNotFoundException{} 6854 err := awsAwsjson11_deserializeDocumentCreateAccountStatusNotFoundException(&output, shape) 6855 6856 if err != nil { 6857 var snapshot bytes.Buffer 6858 io.Copy(&snapshot, ringBuffer) 6859 err = &smithy.DeserializationError{ 6860 Err: fmt.Errorf("failed to decode response body, %w", err), 6861 Snapshot: snapshot.Bytes(), 6862 } 6863 return err 6864 } 6865 6866 errorBody.Seek(0, io.SeekStart) 6867 return output 6868} 6869 6870func awsAwsjson11_deserializeErrorDestinationParentNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 6871 var buff [1024]byte 6872 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6873 6874 body := io.TeeReader(errorBody, ringBuffer) 6875 decoder := json.NewDecoder(body) 6876 decoder.UseNumber() 6877 var shape interface{} 6878 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6879 var snapshot bytes.Buffer 6880 io.Copy(&snapshot, ringBuffer) 6881 err = &smithy.DeserializationError{ 6882 Err: fmt.Errorf("failed to decode response body, %w", err), 6883 Snapshot: snapshot.Bytes(), 6884 } 6885 return err 6886 } 6887 6888 output := &types.DestinationParentNotFoundException{} 6889 err := awsAwsjson11_deserializeDocumentDestinationParentNotFoundException(&output, shape) 6890 6891 if err != nil { 6892 var snapshot bytes.Buffer 6893 io.Copy(&snapshot, ringBuffer) 6894 err = &smithy.DeserializationError{ 6895 Err: fmt.Errorf("failed to decode response body, %w", err), 6896 Snapshot: snapshot.Bytes(), 6897 } 6898 return err 6899 } 6900 6901 errorBody.Seek(0, io.SeekStart) 6902 return output 6903} 6904 6905func awsAwsjson11_deserializeErrorDuplicateAccountException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 6906 var buff [1024]byte 6907 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6908 6909 body := io.TeeReader(errorBody, ringBuffer) 6910 decoder := json.NewDecoder(body) 6911 decoder.UseNumber() 6912 var shape interface{} 6913 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6914 var snapshot bytes.Buffer 6915 io.Copy(&snapshot, ringBuffer) 6916 err = &smithy.DeserializationError{ 6917 Err: fmt.Errorf("failed to decode response body, %w", err), 6918 Snapshot: snapshot.Bytes(), 6919 } 6920 return err 6921 } 6922 6923 output := &types.DuplicateAccountException{} 6924 err := awsAwsjson11_deserializeDocumentDuplicateAccountException(&output, shape) 6925 6926 if err != nil { 6927 var snapshot bytes.Buffer 6928 io.Copy(&snapshot, ringBuffer) 6929 err = &smithy.DeserializationError{ 6930 Err: fmt.Errorf("failed to decode response body, %w", err), 6931 Snapshot: snapshot.Bytes(), 6932 } 6933 return err 6934 } 6935 6936 errorBody.Seek(0, io.SeekStart) 6937 return output 6938} 6939 6940func awsAwsjson11_deserializeErrorDuplicateHandshakeException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 6941 var buff [1024]byte 6942 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6943 6944 body := io.TeeReader(errorBody, ringBuffer) 6945 decoder := json.NewDecoder(body) 6946 decoder.UseNumber() 6947 var shape interface{} 6948 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6949 var snapshot bytes.Buffer 6950 io.Copy(&snapshot, ringBuffer) 6951 err = &smithy.DeserializationError{ 6952 Err: fmt.Errorf("failed to decode response body, %w", err), 6953 Snapshot: snapshot.Bytes(), 6954 } 6955 return err 6956 } 6957 6958 output := &types.DuplicateHandshakeException{} 6959 err := awsAwsjson11_deserializeDocumentDuplicateHandshakeException(&output, shape) 6960 6961 if err != nil { 6962 var snapshot bytes.Buffer 6963 io.Copy(&snapshot, ringBuffer) 6964 err = &smithy.DeserializationError{ 6965 Err: fmt.Errorf("failed to decode response body, %w", err), 6966 Snapshot: snapshot.Bytes(), 6967 } 6968 return err 6969 } 6970 6971 errorBody.Seek(0, io.SeekStart) 6972 return output 6973} 6974 6975func awsAwsjson11_deserializeErrorDuplicateOrganizationalUnitException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 6976 var buff [1024]byte 6977 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6978 6979 body := io.TeeReader(errorBody, ringBuffer) 6980 decoder := json.NewDecoder(body) 6981 decoder.UseNumber() 6982 var shape interface{} 6983 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6984 var snapshot bytes.Buffer 6985 io.Copy(&snapshot, ringBuffer) 6986 err = &smithy.DeserializationError{ 6987 Err: fmt.Errorf("failed to decode response body, %w", err), 6988 Snapshot: snapshot.Bytes(), 6989 } 6990 return err 6991 } 6992 6993 output := &types.DuplicateOrganizationalUnitException{} 6994 err := awsAwsjson11_deserializeDocumentDuplicateOrganizationalUnitException(&output, shape) 6995 6996 if err != nil { 6997 var snapshot bytes.Buffer 6998 io.Copy(&snapshot, ringBuffer) 6999 err = &smithy.DeserializationError{ 7000 Err: fmt.Errorf("failed to decode response body, %w", err), 7001 Snapshot: snapshot.Bytes(), 7002 } 7003 return err 7004 } 7005 7006 errorBody.Seek(0, io.SeekStart) 7007 return output 7008} 7009 7010func awsAwsjson11_deserializeErrorDuplicatePolicyAttachmentException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7011 var buff [1024]byte 7012 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7013 7014 body := io.TeeReader(errorBody, ringBuffer) 7015 decoder := json.NewDecoder(body) 7016 decoder.UseNumber() 7017 var shape interface{} 7018 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7019 var snapshot bytes.Buffer 7020 io.Copy(&snapshot, ringBuffer) 7021 err = &smithy.DeserializationError{ 7022 Err: fmt.Errorf("failed to decode response body, %w", err), 7023 Snapshot: snapshot.Bytes(), 7024 } 7025 return err 7026 } 7027 7028 output := &types.DuplicatePolicyAttachmentException{} 7029 err := awsAwsjson11_deserializeDocumentDuplicatePolicyAttachmentException(&output, shape) 7030 7031 if err != nil { 7032 var snapshot bytes.Buffer 7033 io.Copy(&snapshot, ringBuffer) 7034 err = &smithy.DeserializationError{ 7035 Err: fmt.Errorf("failed to decode response body, %w", err), 7036 Snapshot: snapshot.Bytes(), 7037 } 7038 return err 7039 } 7040 7041 errorBody.Seek(0, io.SeekStart) 7042 return output 7043} 7044 7045func awsAwsjson11_deserializeErrorDuplicatePolicyException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7046 var buff [1024]byte 7047 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7048 7049 body := io.TeeReader(errorBody, ringBuffer) 7050 decoder := json.NewDecoder(body) 7051 decoder.UseNumber() 7052 var shape interface{} 7053 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7054 var snapshot bytes.Buffer 7055 io.Copy(&snapshot, ringBuffer) 7056 err = &smithy.DeserializationError{ 7057 Err: fmt.Errorf("failed to decode response body, %w", err), 7058 Snapshot: snapshot.Bytes(), 7059 } 7060 return err 7061 } 7062 7063 output := &types.DuplicatePolicyException{} 7064 err := awsAwsjson11_deserializeDocumentDuplicatePolicyException(&output, shape) 7065 7066 if err != nil { 7067 var snapshot bytes.Buffer 7068 io.Copy(&snapshot, ringBuffer) 7069 err = &smithy.DeserializationError{ 7070 Err: fmt.Errorf("failed to decode response body, %w", err), 7071 Snapshot: snapshot.Bytes(), 7072 } 7073 return err 7074 } 7075 7076 errorBody.Seek(0, io.SeekStart) 7077 return output 7078} 7079 7080func awsAwsjson11_deserializeErrorEffectivePolicyNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7081 var buff [1024]byte 7082 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7083 7084 body := io.TeeReader(errorBody, ringBuffer) 7085 decoder := json.NewDecoder(body) 7086 decoder.UseNumber() 7087 var shape interface{} 7088 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7089 var snapshot bytes.Buffer 7090 io.Copy(&snapshot, ringBuffer) 7091 err = &smithy.DeserializationError{ 7092 Err: fmt.Errorf("failed to decode response body, %w", err), 7093 Snapshot: snapshot.Bytes(), 7094 } 7095 return err 7096 } 7097 7098 output := &types.EffectivePolicyNotFoundException{} 7099 err := awsAwsjson11_deserializeDocumentEffectivePolicyNotFoundException(&output, shape) 7100 7101 if err != nil { 7102 var snapshot bytes.Buffer 7103 io.Copy(&snapshot, ringBuffer) 7104 err = &smithy.DeserializationError{ 7105 Err: fmt.Errorf("failed to decode response body, %w", err), 7106 Snapshot: snapshot.Bytes(), 7107 } 7108 return err 7109 } 7110 7111 errorBody.Seek(0, io.SeekStart) 7112 return output 7113} 7114 7115func awsAwsjson11_deserializeErrorFinalizingOrganizationException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7116 var buff [1024]byte 7117 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7118 7119 body := io.TeeReader(errorBody, ringBuffer) 7120 decoder := json.NewDecoder(body) 7121 decoder.UseNumber() 7122 var shape interface{} 7123 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7124 var snapshot bytes.Buffer 7125 io.Copy(&snapshot, ringBuffer) 7126 err = &smithy.DeserializationError{ 7127 Err: fmt.Errorf("failed to decode response body, %w", err), 7128 Snapshot: snapshot.Bytes(), 7129 } 7130 return err 7131 } 7132 7133 output := &types.FinalizingOrganizationException{} 7134 err := awsAwsjson11_deserializeDocumentFinalizingOrganizationException(&output, shape) 7135 7136 if err != nil { 7137 var snapshot bytes.Buffer 7138 io.Copy(&snapshot, ringBuffer) 7139 err = &smithy.DeserializationError{ 7140 Err: fmt.Errorf("failed to decode response body, %w", err), 7141 Snapshot: snapshot.Bytes(), 7142 } 7143 return err 7144 } 7145 7146 errorBody.Seek(0, io.SeekStart) 7147 return output 7148} 7149 7150func awsAwsjson11_deserializeErrorHandshakeAlreadyInStateException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7151 var buff [1024]byte 7152 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7153 7154 body := io.TeeReader(errorBody, ringBuffer) 7155 decoder := json.NewDecoder(body) 7156 decoder.UseNumber() 7157 var shape interface{} 7158 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7159 var snapshot bytes.Buffer 7160 io.Copy(&snapshot, ringBuffer) 7161 err = &smithy.DeserializationError{ 7162 Err: fmt.Errorf("failed to decode response body, %w", err), 7163 Snapshot: snapshot.Bytes(), 7164 } 7165 return err 7166 } 7167 7168 output := &types.HandshakeAlreadyInStateException{} 7169 err := awsAwsjson11_deserializeDocumentHandshakeAlreadyInStateException(&output, shape) 7170 7171 if err != nil { 7172 var snapshot bytes.Buffer 7173 io.Copy(&snapshot, ringBuffer) 7174 err = &smithy.DeserializationError{ 7175 Err: fmt.Errorf("failed to decode response body, %w", err), 7176 Snapshot: snapshot.Bytes(), 7177 } 7178 return err 7179 } 7180 7181 errorBody.Seek(0, io.SeekStart) 7182 return output 7183} 7184 7185func awsAwsjson11_deserializeErrorHandshakeConstraintViolationException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7186 var buff [1024]byte 7187 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7188 7189 body := io.TeeReader(errorBody, ringBuffer) 7190 decoder := json.NewDecoder(body) 7191 decoder.UseNumber() 7192 var shape interface{} 7193 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7194 var snapshot bytes.Buffer 7195 io.Copy(&snapshot, ringBuffer) 7196 err = &smithy.DeserializationError{ 7197 Err: fmt.Errorf("failed to decode response body, %w", err), 7198 Snapshot: snapshot.Bytes(), 7199 } 7200 return err 7201 } 7202 7203 output := &types.HandshakeConstraintViolationException{} 7204 err := awsAwsjson11_deserializeDocumentHandshakeConstraintViolationException(&output, shape) 7205 7206 if err != nil { 7207 var snapshot bytes.Buffer 7208 io.Copy(&snapshot, ringBuffer) 7209 err = &smithy.DeserializationError{ 7210 Err: fmt.Errorf("failed to decode response body, %w", err), 7211 Snapshot: snapshot.Bytes(), 7212 } 7213 return err 7214 } 7215 7216 errorBody.Seek(0, io.SeekStart) 7217 return output 7218} 7219 7220func awsAwsjson11_deserializeErrorHandshakeNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7221 var buff [1024]byte 7222 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7223 7224 body := io.TeeReader(errorBody, ringBuffer) 7225 decoder := json.NewDecoder(body) 7226 decoder.UseNumber() 7227 var shape interface{} 7228 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7229 var snapshot bytes.Buffer 7230 io.Copy(&snapshot, ringBuffer) 7231 err = &smithy.DeserializationError{ 7232 Err: fmt.Errorf("failed to decode response body, %w", err), 7233 Snapshot: snapshot.Bytes(), 7234 } 7235 return err 7236 } 7237 7238 output := &types.HandshakeNotFoundException{} 7239 err := awsAwsjson11_deserializeDocumentHandshakeNotFoundException(&output, shape) 7240 7241 if err != nil { 7242 var snapshot bytes.Buffer 7243 io.Copy(&snapshot, ringBuffer) 7244 err = &smithy.DeserializationError{ 7245 Err: fmt.Errorf("failed to decode response body, %w", err), 7246 Snapshot: snapshot.Bytes(), 7247 } 7248 return err 7249 } 7250 7251 errorBody.Seek(0, io.SeekStart) 7252 return output 7253} 7254 7255func awsAwsjson11_deserializeErrorInvalidHandshakeTransitionException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7256 var buff [1024]byte 7257 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7258 7259 body := io.TeeReader(errorBody, ringBuffer) 7260 decoder := json.NewDecoder(body) 7261 decoder.UseNumber() 7262 var shape interface{} 7263 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7264 var snapshot bytes.Buffer 7265 io.Copy(&snapshot, ringBuffer) 7266 err = &smithy.DeserializationError{ 7267 Err: fmt.Errorf("failed to decode response body, %w", err), 7268 Snapshot: snapshot.Bytes(), 7269 } 7270 return err 7271 } 7272 7273 output := &types.InvalidHandshakeTransitionException{} 7274 err := awsAwsjson11_deserializeDocumentInvalidHandshakeTransitionException(&output, shape) 7275 7276 if err != nil { 7277 var snapshot bytes.Buffer 7278 io.Copy(&snapshot, ringBuffer) 7279 err = &smithy.DeserializationError{ 7280 Err: fmt.Errorf("failed to decode response body, %w", err), 7281 Snapshot: snapshot.Bytes(), 7282 } 7283 return err 7284 } 7285 7286 errorBody.Seek(0, io.SeekStart) 7287 return output 7288} 7289 7290func awsAwsjson11_deserializeErrorInvalidInputException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7291 var buff [1024]byte 7292 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7293 7294 body := io.TeeReader(errorBody, ringBuffer) 7295 decoder := json.NewDecoder(body) 7296 decoder.UseNumber() 7297 var shape interface{} 7298 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7299 var snapshot bytes.Buffer 7300 io.Copy(&snapshot, ringBuffer) 7301 err = &smithy.DeserializationError{ 7302 Err: fmt.Errorf("failed to decode response body, %w", err), 7303 Snapshot: snapshot.Bytes(), 7304 } 7305 return err 7306 } 7307 7308 output := &types.InvalidInputException{} 7309 err := awsAwsjson11_deserializeDocumentInvalidInputException(&output, shape) 7310 7311 if err != nil { 7312 var snapshot bytes.Buffer 7313 io.Copy(&snapshot, ringBuffer) 7314 err = &smithy.DeserializationError{ 7315 Err: fmt.Errorf("failed to decode response body, %w", err), 7316 Snapshot: snapshot.Bytes(), 7317 } 7318 return err 7319 } 7320 7321 errorBody.Seek(0, io.SeekStart) 7322 return output 7323} 7324 7325func awsAwsjson11_deserializeErrorMalformedPolicyDocumentException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7326 var buff [1024]byte 7327 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7328 7329 body := io.TeeReader(errorBody, ringBuffer) 7330 decoder := json.NewDecoder(body) 7331 decoder.UseNumber() 7332 var shape interface{} 7333 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7334 var snapshot bytes.Buffer 7335 io.Copy(&snapshot, ringBuffer) 7336 err = &smithy.DeserializationError{ 7337 Err: fmt.Errorf("failed to decode response body, %w", err), 7338 Snapshot: snapshot.Bytes(), 7339 } 7340 return err 7341 } 7342 7343 output := &types.MalformedPolicyDocumentException{} 7344 err := awsAwsjson11_deserializeDocumentMalformedPolicyDocumentException(&output, shape) 7345 7346 if err != nil { 7347 var snapshot bytes.Buffer 7348 io.Copy(&snapshot, ringBuffer) 7349 err = &smithy.DeserializationError{ 7350 Err: fmt.Errorf("failed to decode response body, %w", err), 7351 Snapshot: snapshot.Bytes(), 7352 } 7353 return err 7354 } 7355 7356 errorBody.Seek(0, io.SeekStart) 7357 return output 7358} 7359 7360func awsAwsjson11_deserializeErrorMasterCannotLeaveOrganizationException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7361 var buff [1024]byte 7362 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7363 7364 body := io.TeeReader(errorBody, ringBuffer) 7365 decoder := json.NewDecoder(body) 7366 decoder.UseNumber() 7367 var shape interface{} 7368 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7369 var snapshot bytes.Buffer 7370 io.Copy(&snapshot, ringBuffer) 7371 err = &smithy.DeserializationError{ 7372 Err: fmt.Errorf("failed to decode response body, %w", err), 7373 Snapshot: snapshot.Bytes(), 7374 } 7375 return err 7376 } 7377 7378 output := &types.MasterCannotLeaveOrganizationException{} 7379 err := awsAwsjson11_deserializeDocumentMasterCannotLeaveOrganizationException(&output, shape) 7380 7381 if err != nil { 7382 var snapshot bytes.Buffer 7383 io.Copy(&snapshot, ringBuffer) 7384 err = &smithy.DeserializationError{ 7385 Err: fmt.Errorf("failed to decode response body, %w", err), 7386 Snapshot: snapshot.Bytes(), 7387 } 7388 return err 7389 } 7390 7391 errorBody.Seek(0, io.SeekStart) 7392 return output 7393} 7394 7395func awsAwsjson11_deserializeErrorOrganizationalUnitNotEmptyException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7396 var buff [1024]byte 7397 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7398 7399 body := io.TeeReader(errorBody, ringBuffer) 7400 decoder := json.NewDecoder(body) 7401 decoder.UseNumber() 7402 var shape interface{} 7403 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7404 var snapshot bytes.Buffer 7405 io.Copy(&snapshot, ringBuffer) 7406 err = &smithy.DeserializationError{ 7407 Err: fmt.Errorf("failed to decode response body, %w", err), 7408 Snapshot: snapshot.Bytes(), 7409 } 7410 return err 7411 } 7412 7413 output := &types.OrganizationalUnitNotEmptyException{} 7414 err := awsAwsjson11_deserializeDocumentOrganizationalUnitNotEmptyException(&output, shape) 7415 7416 if err != nil { 7417 var snapshot bytes.Buffer 7418 io.Copy(&snapshot, ringBuffer) 7419 err = &smithy.DeserializationError{ 7420 Err: fmt.Errorf("failed to decode response body, %w", err), 7421 Snapshot: snapshot.Bytes(), 7422 } 7423 return err 7424 } 7425 7426 errorBody.Seek(0, io.SeekStart) 7427 return output 7428} 7429 7430func awsAwsjson11_deserializeErrorOrganizationalUnitNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7431 var buff [1024]byte 7432 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7433 7434 body := io.TeeReader(errorBody, ringBuffer) 7435 decoder := json.NewDecoder(body) 7436 decoder.UseNumber() 7437 var shape interface{} 7438 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7439 var snapshot bytes.Buffer 7440 io.Copy(&snapshot, ringBuffer) 7441 err = &smithy.DeserializationError{ 7442 Err: fmt.Errorf("failed to decode response body, %w", err), 7443 Snapshot: snapshot.Bytes(), 7444 } 7445 return err 7446 } 7447 7448 output := &types.OrganizationalUnitNotFoundException{} 7449 err := awsAwsjson11_deserializeDocumentOrganizationalUnitNotFoundException(&output, shape) 7450 7451 if err != nil { 7452 var snapshot bytes.Buffer 7453 io.Copy(&snapshot, ringBuffer) 7454 err = &smithy.DeserializationError{ 7455 Err: fmt.Errorf("failed to decode response body, %w", err), 7456 Snapshot: snapshot.Bytes(), 7457 } 7458 return err 7459 } 7460 7461 errorBody.Seek(0, io.SeekStart) 7462 return output 7463} 7464 7465func awsAwsjson11_deserializeErrorOrganizationNotEmptyException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7466 var buff [1024]byte 7467 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7468 7469 body := io.TeeReader(errorBody, ringBuffer) 7470 decoder := json.NewDecoder(body) 7471 decoder.UseNumber() 7472 var shape interface{} 7473 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7474 var snapshot bytes.Buffer 7475 io.Copy(&snapshot, ringBuffer) 7476 err = &smithy.DeserializationError{ 7477 Err: fmt.Errorf("failed to decode response body, %w", err), 7478 Snapshot: snapshot.Bytes(), 7479 } 7480 return err 7481 } 7482 7483 output := &types.OrganizationNotEmptyException{} 7484 err := awsAwsjson11_deserializeDocumentOrganizationNotEmptyException(&output, shape) 7485 7486 if err != nil { 7487 var snapshot bytes.Buffer 7488 io.Copy(&snapshot, ringBuffer) 7489 err = &smithy.DeserializationError{ 7490 Err: fmt.Errorf("failed to decode response body, %w", err), 7491 Snapshot: snapshot.Bytes(), 7492 } 7493 return err 7494 } 7495 7496 errorBody.Seek(0, io.SeekStart) 7497 return output 7498} 7499 7500func awsAwsjson11_deserializeErrorParentNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7501 var buff [1024]byte 7502 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7503 7504 body := io.TeeReader(errorBody, ringBuffer) 7505 decoder := json.NewDecoder(body) 7506 decoder.UseNumber() 7507 var shape interface{} 7508 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7509 var snapshot bytes.Buffer 7510 io.Copy(&snapshot, ringBuffer) 7511 err = &smithy.DeserializationError{ 7512 Err: fmt.Errorf("failed to decode response body, %w", err), 7513 Snapshot: snapshot.Bytes(), 7514 } 7515 return err 7516 } 7517 7518 output := &types.ParentNotFoundException{} 7519 err := awsAwsjson11_deserializeDocumentParentNotFoundException(&output, shape) 7520 7521 if err != nil { 7522 var snapshot bytes.Buffer 7523 io.Copy(&snapshot, ringBuffer) 7524 err = &smithy.DeserializationError{ 7525 Err: fmt.Errorf("failed to decode response body, %w", err), 7526 Snapshot: snapshot.Bytes(), 7527 } 7528 return err 7529 } 7530 7531 errorBody.Seek(0, io.SeekStart) 7532 return output 7533} 7534 7535func awsAwsjson11_deserializeErrorPolicyChangesInProgressException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7536 var buff [1024]byte 7537 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7538 7539 body := io.TeeReader(errorBody, ringBuffer) 7540 decoder := json.NewDecoder(body) 7541 decoder.UseNumber() 7542 var shape interface{} 7543 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7544 var snapshot bytes.Buffer 7545 io.Copy(&snapshot, ringBuffer) 7546 err = &smithy.DeserializationError{ 7547 Err: fmt.Errorf("failed to decode response body, %w", err), 7548 Snapshot: snapshot.Bytes(), 7549 } 7550 return err 7551 } 7552 7553 output := &types.PolicyChangesInProgressException{} 7554 err := awsAwsjson11_deserializeDocumentPolicyChangesInProgressException(&output, shape) 7555 7556 if err != nil { 7557 var snapshot bytes.Buffer 7558 io.Copy(&snapshot, ringBuffer) 7559 err = &smithy.DeserializationError{ 7560 Err: fmt.Errorf("failed to decode response body, %w", err), 7561 Snapshot: snapshot.Bytes(), 7562 } 7563 return err 7564 } 7565 7566 errorBody.Seek(0, io.SeekStart) 7567 return output 7568} 7569 7570func awsAwsjson11_deserializeErrorPolicyInUseException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7571 var buff [1024]byte 7572 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7573 7574 body := io.TeeReader(errorBody, ringBuffer) 7575 decoder := json.NewDecoder(body) 7576 decoder.UseNumber() 7577 var shape interface{} 7578 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7579 var snapshot bytes.Buffer 7580 io.Copy(&snapshot, ringBuffer) 7581 err = &smithy.DeserializationError{ 7582 Err: fmt.Errorf("failed to decode response body, %w", err), 7583 Snapshot: snapshot.Bytes(), 7584 } 7585 return err 7586 } 7587 7588 output := &types.PolicyInUseException{} 7589 err := awsAwsjson11_deserializeDocumentPolicyInUseException(&output, shape) 7590 7591 if err != nil { 7592 var snapshot bytes.Buffer 7593 io.Copy(&snapshot, ringBuffer) 7594 err = &smithy.DeserializationError{ 7595 Err: fmt.Errorf("failed to decode response body, %w", err), 7596 Snapshot: snapshot.Bytes(), 7597 } 7598 return err 7599 } 7600 7601 errorBody.Seek(0, io.SeekStart) 7602 return output 7603} 7604 7605func awsAwsjson11_deserializeErrorPolicyNotAttachedException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7606 var buff [1024]byte 7607 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7608 7609 body := io.TeeReader(errorBody, ringBuffer) 7610 decoder := json.NewDecoder(body) 7611 decoder.UseNumber() 7612 var shape interface{} 7613 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7614 var snapshot bytes.Buffer 7615 io.Copy(&snapshot, ringBuffer) 7616 err = &smithy.DeserializationError{ 7617 Err: fmt.Errorf("failed to decode response body, %w", err), 7618 Snapshot: snapshot.Bytes(), 7619 } 7620 return err 7621 } 7622 7623 output := &types.PolicyNotAttachedException{} 7624 err := awsAwsjson11_deserializeDocumentPolicyNotAttachedException(&output, shape) 7625 7626 if err != nil { 7627 var snapshot bytes.Buffer 7628 io.Copy(&snapshot, ringBuffer) 7629 err = &smithy.DeserializationError{ 7630 Err: fmt.Errorf("failed to decode response body, %w", err), 7631 Snapshot: snapshot.Bytes(), 7632 } 7633 return err 7634 } 7635 7636 errorBody.Seek(0, io.SeekStart) 7637 return output 7638} 7639 7640func awsAwsjson11_deserializeErrorPolicyNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7641 var buff [1024]byte 7642 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7643 7644 body := io.TeeReader(errorBody, ringBuffer) 7645 decoder := json.NewDecoder(body) 7646 decoder.UseNumber() 7647 var shape interface{} 7648 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7649 var snapshot bytes.Buffer 7650 io.Copy(&snapshot, ringBuffer) 7651 err = &smithy.DeserializationError{ 7652 Err: fmt.Errorf("failed to decode response body, %w", err), 7653 Snapshot: snapshot.Bytes(), 7654 } 7655 return err 7656 } 7657 7658 output := &types.PolicyNotFoundException{} 7659 err := awsAwsjson11_deserializeDocumentPolicyNotFoundException(&output, shape) 7660 7661 if err != nil { 7662 var snapshot bytes.Buffer 7663 io.Copy(&snapshot, ringBuffer) 7664 err = &smithy.DeserializationError{ 7665 Err: fmt.Errorf("failed to decode response body, %w", err), 7666 Snapshot: snapshot.Bytes(), 7667 } 7668 return err 7669 } 7670 7671 errorBody.Seek(0, io.SeekStart) 7672 return output 7673} 7674 7675func awsAwsjson11_deserializeErrorPolicyTypeAlreadyEnabledException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7676 var buff [1024]byte 7677 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7678 7679 body := io.TeeReader(errorBody, ringBuffer) 7680 decoder := json.NewDecoder(body) 7681 decoder.UseNumber() 7682 var shape interface{} 7683 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7684 var snapshot bytes.Buffer 7685 io.Copy(&snapshot, ringBuffer) 7686 err = &smithy.DeserializationError{ 7687 Err: fmt.Errorf("failed to decode response body, %w", err), 7688 Snapshot: snapshot.Bytes(), 7689 } 7690 return err 7691 } 7692 7693 output := &types.PolicyTypeAlreadyEnabledException{} 7694 err := awsAwsjson11_deserializeDocumentPolicyTypeAlreadyEnabledException(&output, shape) 7695 7696 if err != nil { 7697 var snapshot bytes.Buffer 7698 io.Copy(&snapshot, ringBuffer) 7699 err = &smithy.DeserializationError{ 7700 Err: fmt.Errorf("failed to decode response body, %w", err), 7701 Snapshot: snapshot.Bytes(), 7702 } 7703 return err 7704 } 7705 7706 errorBody.Seek(0, io.SeekStart) 7707 return output 7708} 7709 7710func awsAwsjson11_deserializeErrorPolicyTypeNotAvailableForOrganizationException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7711 var buff [1024]byte 7712 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7713 7714 body := io.TeeReader(errorBody, ringBuffer) 7715 decoder := json.NewDecoder(body) 7716 decoder.UseNumber() 7717 var shape interface{} 7718 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7719 var snapshot bytes.Buffer 7720 io.Copy(&snapshot, ringBuffer) 7721 err = &smithy.DeserializationError{ 7722 Err: fmt.Errorf("failed to decode response body, %w", err), 7723 Snapshot: snapshot.Bytes(), 7724 } 7725 return err 7726 } 7727 7728 output := &types.PolicyTypeNotAvailableForOrganizationException{} 7729 err := awsAwsjson11_deserializeDocumentPolicyTypeNotAvailableForOrganizationException(&output, shape) 7730 7731 if err != nil { 7732 var snapshot bytes.Buffer 7733 io.Copy(&snapshot, ringBuffer) 7734 err = &smithy.DeserializationError{ 7735 Err: fmt.Errorf("failed to decode response body, %w", err), 7736 Snapshot: snapshot.Bytes(), 7737 } 7738 return err 7739 } 7740 7741 errorBody.Seek(0, io.SeekStart) 7742 return output 7743} 7744 7745func awsAwsjson11_deserializeErrorPolicyTypeNotEnabledException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7746 var buff [1024]byte 7747 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7748 7749 body := io.TeeReader(errorBody, ringBuffer) 7750 decoder := json.NewDecoder(body) 7751 decoder.UseNumber() 7752 var shape interface{} 7753 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7754 var snapshot bytes.Buffer 7755 io.Copy(&snapshot, ringBuffer) 7756 err = &smithy.DeserializationError{ 7757 Err: fmt.Errorf("failed to decode response body, %w", err), 7758 Snapshot: snapshot.Bytes(), 7759 } 7760 return err 7761 } 7762 7763 output := &types.PolicyTypeNotEnabledException{} 7764 err := awsAwsjson11_deserializeDocumentPolicyTypeNotEnabledException(&output, shape) 7765 7766 if err != nil { 7767 var snapshot bytes.Buffer 7768 io.Copy(&snapshot, ringBuffer) 7769 err = &smithy.DeserializationError{ 7770 Err: fmt.Errorf("failed to decode response body, %w", err), 7771 Snapshot: snapshot.Bytes(), 7772 } 7773 return err 7774 } 7775 7776 errorBody.Seek(0, io.SeekStart) 7777 return output 7778} 7779 7780func awsAwsjson11_deserializeErrorRootNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7781 var buff [1024]byte 7782 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7783 7784 body := io.TeeReader(errorBody, ringBuffer) 7785 decoder := json.NewDecoder(body) 7786 decoder.UseNumber() 7787 var shape interface{} 7788 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7789 var snapshot bytes.Buffer 7790 io.Copy(&snapshot, ringBuffer) 7791 err = &smithy.DeserializationError{ 7792 Err: fmt.Errorf("failed to decode response body, %w", err), 7793 Snapshot: snapshot.Bytes(), 7794 } 7795 return err 7796 } 7797 7798 output := &types.RootNotFoundException{} 7799 err := awsAwsjson11_deserializeDocumentRootNotFoundException(&output, shape) 7800 7801 if err != nil { 7802 var snapshot bytes.Buffer 7803 io.Copy(&snapshot, ringBuffer) 7804 err = &smithy.DeserializationError{ 7805 Err: fmt.Errorf("failed to decode response body, %w", err), 7806 Snapshot: snapshot.Bytes(), 7807 } 7808 return err 7809 } 7810 7811 errorBody.Seek(0, io.SeekStart) 7812 return output 7813} 7814 7815func awsAwsjson11_deserializeErrorServiceException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7816 var buff [1024]byte 7817 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7818 7819 body := io.TeeReader(errorBody, ringBuffer) 7820 decoder := json.NewDecoder(body) 7821 decoder.UseNumber() 7822 var shape interface{} 7823 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7824 var snapshot bytes.Buffer 7825 io.Copy(&snapshot, ringBuffer) 7826 err = &smithy.DeserializationError{ 7827 Err: fmt.Errorf("failed to decode response body, %w", err), 7828 Snapshot: snapshot.Bytes(), 7829 } 7830 return err 7831 } 7832 7833 output := &types.ServiceException{} 7834 err := awsAwsjson11_deserializeDocumentServiceException(&output, shape) 7835 7836 if err != nil { 7837 var snapshot bytes.Buffer 7838 io.Copy(&snapshot, ringBuffer) 7839 err = &smithy.DeserializationError{ 7840 Err: fmt.Errorf("failed to decode response body, %w", err), 7841 Snapshot: snapshot.Bytes(), 7842 } 7843 return err 7844 } 7845 7846 errorBody.Seek(0, io.SeekStart) 7847 return output 7848} 7849 7850func awsAwsjson11_deserializeErrorSourceParentNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7851 var buff [1024]byte 7852 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7853 7854 body := io.TeeReader(errorBody, ringBuffer) 7855 decoder := json.NewDecoder(body) 7856 decoder.UseNumber() 7857 var shape interface{} 7858 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7859 var snapshot bytes.Buffer 7860 io.Copy(&snapshot, ringBuffer) 7861 err = &smithy.DeserializationError{ 7862 Err: fmt.Errorf("failed to decode response body, %w", err), 7863 Snapshot: snapshot.Bytes(), 7864 } 7865 return err 7866 } 7867 7868 output := &types.SourceParentNotFoundException{} 7869 err := awsAwsjson11_deserializeDocumentSourceParentNotFoundException(&output, shape) 7870 7871 if err != nil { 7872 var snapshot bytes.Buffer 7873 io.Copy(&snapshot, ringBuffer) 7874 err = &smithy.DeserializationError{ 7875 Err: fmt.Errorf("failed to decode response body, %w", err), 7876 Snapshot: snapshot.Bytes(), 7877 } 7878 return err 7879 } 7880 7881 errorBody.Seek(0, io.SeekStart) 7882 return output 7883} 7884 7885func awsAwsjson11_deserializeErrorTargetNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7886 var buff [1024]byte 7887 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7888 7889 body := io.TeeReader(errorBody, ringBuffer) 7890 decoder := json.NewDecoder(body) 7891 decoder.UseNumber() 7892 var shape interface{} 7893 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7894 var snapshot bytes.Buffer 7895 io.Copy(&snapshot, ringBuffer) 7896 err = &smithy.DeserializationError{ 7897 Err: fmt.Errorf("failed to decode response body, %w", err), 7898 Snapshot: snapshot.Bytes(), 7899 } 7900 return err 7901 } 7902 7903 output := &types.TargetNotFoundException{} 7904 err := awsAwsjson11_deserializeDocumentTargetNotFoundException(&output, shape) 7905 7906 if err != nil { 7907 var snapshot bytes.Buffer 7908 io.Copy(&snapshot, ringBuffer) 7909 err = &smithy.DeserializationError{ 7910 Err: fmt.Errorf("failed to decode response body, %w", err), 7911 Snapshot: snapshot.Bytes(), 7912 } 7913 return err 7914 } 7915 7916 errorBody.Seek(0, io.SeekStart) 7917 return output 7918} 7919 7920func awsAwsjson11_deserializeErrorTooManyRequestsException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7921 var buff [1024]byte 7922 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7923 7924 body := io.TeeReader(errorBody, ringBuffer) 7925 decoder := json.NewDecoder(body) 7926 decoder.UseNumber() 7927 var shape interface{} 7928 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7929 var snapshot bytes.Buffer 7930 io.Copy(&snapshot, ringBuffer) 7931 err = &smithy.DeserializationError{ 7932 Err: fmt.Errorf("failed to decode response body, %w", err), 7933 Snapshot: snapshot.Bytes(), 7934 } 7935 return err 7936 } 7937 7938 output := &types.TooManyRequestsException{} 7939 err := awsAwsjson11_deserializeDocumentTooManyRequestsException(&output, shape) 7940 7941 if err != nil { 7942 var snapshot bytes.Buffer 7943 io.Copy(&snapshot, ringBuffer) 7944 err = &smithy.DeserializationError{ 7945 Err: fmt.Errorf("failed to decode response body, %w", err), 7946 Snapshot: snapshot.Bytes(), 7947 } 7948 return err 7949 } 7950 7951 errorBody.Seek(0, io.SeekStart) 7952 return output 7953} 7954 7955func awsAwsjson11_deserializeErrorUnsupportedAPIEndpointException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 7956 var buff [1024]byte 7957 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7958 7959 body := io.TeeReader(errorBody, ringBuffer) 7960 decoder := json.NewDecoder(body) 7961 decoder.UseNumber() 7962 var shape interface{} 7963 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7964 var snapshot bytes.Buffer 7965 io.Copy(&snapshot, ringBuffer) 7966 err = &smithy.DeserializationError{ 7967 Err: fmt.Errorf("failed to decode response body, %w", err), 7968 Snapshot: snapshot.Bytes(), 7969 } 7970 return err 7971 } 7972 7973 output := &types.UnsupportedAPIEndpointException{} 7974 err := awsAwsjson11_deserializeDocumentUnsupportedAPIEndpointException(&output, shape) 7975 7976 if err != nil { 7977 var snapshot bytes.Buffer 7978 io.Copy(&snapshot, ringBuffer) 7979 err = &smithy.DeserializationError{ 7980 Err: fmt.Errorf("failed to decode response body, %w", err), 7981 Snapshot: snapshot.Bytes(), 7982 } 7983 return err 7984 } 7985 7986 errorBody.Seek(0, io.SeekStart) 7987 return output 7988} 7989 7990func awsAwsjson11_deserializeDocumentAccessDeniedException(v **types.AccessDeniedException, value interface{}) error { 7991 if v == nil { 7992 return fmt.Errorf("unexpected nil of type %T", v) 7993 } 7994 if value == nil { 7995 return nil 7996 } 7997 7998 shape, ok := value.(map[string]interface{}) 7999 if !ok { 8000 return fmt.Errorf("unexpected JSON type %v", value) 8001 } 8002 8003 var sv *types.AccessDeniedException 8004 if *v == nil { 8005 sv = &types.AccessDeniedException{} 8006 } else { 8007 sv = *v 8008 } 8009 8010 for key, value := range shape { 8011 switch key { 8012 case "Message": 8013 if value != nil { 8014 jtv, ok := value.(string) 8015 if !ok { 8016 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 8017 } 8018 sv.Message = ptr.String(jtv) 8019 } 8020 8021 default: 8022 _, _ = key, value 8023 8024 } 8025 } 8026 *v = sv 8027 return nil 8028} 8029 8030func awsAwsjson11_deserializeDocumentAccessDeniedForDependencyException(v **types.AccessDeniedForDependencyException, value interface{}) error { 8031 if v == nil { 8032 return fmt.Errorf("unexpected nil of type %T", v) 8033 } 8034 if value == nil { 8035 return nil 8036 } 8037 8038 shape, ok := value.(map[string]interface{}) 8039 if !ok { 8040 return fmt.Errorf("unexpected JSON type %v", value) 8041 } 8042 8043 var sv *types.AccessDeniedForDependencyException 8044 if *v == nil { 8045 sv = &types.AccessDeniedForDependencyException{} 8046 } else { 8047 sv = *v 8048 } 8049 8050 for key, value := range shape { 8051 switch key { 8052 case "Message": 8053 if value != nil { 8054 jtv, ok := value.(string) 8055 if !ok { 8056 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 8057 } 8058 sv.Message = ptr.String(jtv) 8059 } 8060 8061 case "Reason": 8062 if value != nil { 8063 jtv, ok := value.(string) 8064 if !ok { 8065 return fmt.Errorf("expected AccessDeniedForDependencyExceptionReason to be of type string, got %T instead", value) 8066 } 8067 sv.Reason = types.AccessDeniedForDependencyExceptionReason(jtv) 8068 } 8069 8070 default: 8071 _, _ = key, value 8072 8073 } 8074 } 8075 *v = sv 8076 return nil 8077} 8078 8079func awsAwsjson11_deserializeDocumentAccount(v **types.Account, value interface{}) error { 8080 if v == nil { 8081 return fmt.Errorf("unexpected nil of type %T", v) 8082 } 8083 if value == nil { 8084 return nil 8085 } 8086 8087 shape, ok := value.(map[string]interface{}) 8088 if !ok { 8089 return fmt.Errorf("unexpected JSON type %v", value) 8090 } 8091 8092 var sv *types.Account 8093 if *v == nil { 8094 sv = &types.Account{} 8095 } else { 8096 sv = *v 8097 } 8098 8099 for key, value := range shape { 8100 switch key { 8101 case "Arn": 8102 if value != nil { 8103 jtv, ok := value.(string) 8104 if !ok { 8105 return fmt.Errorf("expected AccountArn to be of type string, got %T instead", value) 8106 } 8107 sv.Arn = ptr.String(jtv) 8108 } 8109 8110 case "Email": 8111 if value != nil { 8112 jtv, ok := value.(string) 8113 if !ok { 8114 return fmt.Errorf("expected Email to be of type string, got %T instead", value) 8115 } 8116 sv.Email = ptr.String(jtv) 8117 } 8118 8119 case "Id": 8120 if value != nil { 8121 jtv, ok := value.(string) 8122 if !ok { 8123 return fmt.Errorf("expected AccountId to be of type string, got %T instead", value) 8124 } 8125 sv.Id = ptr.String(jtv) 8126 } 8127 8128 case "JoinedMethod": 8129 if value != nil { 8130 jtv, ok := value.(string) 8131 if !ok { 8132 return fmt.Errorf("expected AccountJoinedMethod to be of type string, got %T instead", value) 8133 } 8134 sv.JoinedMethod = types.AccountJoinedMethod(jtv) 8135 } 8136 8137 case "JoinedTimestamp": 8138 if value != nil { 8139 jtv, ok := value.(json.Number) 8140 if !ok { 8141 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 8142 } 8143 f64, err := jtv.Float64() 8144 if err != nil { 8145 return err 8146 } 8147 sv.JoinedTimestamp = ptr.Time(smithytime.ParseEpochSeconds(f64)) 8148 } 8149 8150 case "Name": 8151 if value != nil { 8152 jtv, ok := value.(string) 8153 if !ok { 8154 return fmt.Errorf("expected AccountName to be of type string, got %T instead", value) 8155 } 8156 sv.Name = ptr.String(jtv) 8157 } 8158 8159 case "Status": 8160 if value != nil { 8161 jtv, ok := value.(string) 8162 if !ok { 8163 return fmt.Errorf("expected AccountStatus to be of type string, got %T instead", value) 8164 } 8165 sv.Status = types.AccountStatus(jtv) 8166 } 8167 8168 default: 8169 _, _ = key, value 8170 8171 } 8172 } 8173 *v = sv 8174 return nil 8175} 8176 8177func awsAwsjson11_deserializeDocumentAccountAlreadyRegisteredException(v **types.AccountAlreadyRegisteredException, value interface{}) error { 8178 if v == nil { 8179 return fmt.Errorf("unexpected nil of type %T", v) 8180 } 8181 if value == nil { 8182 return nil 8183 } 8184 8185 shape, ok := value.(map[string]interface{}) 8186 if !ok { 8187 return fmt.Errorf("unexpected JSON type %v", value) 8188 } 8189 8190 var sv *types.AccountAlreadyRegisteredException 8191 if *v == nil { 8192 sv = &types.AccountAlreadyRegisteredException{} 8193 } else { 8194 sv = *v 8195 } 8196 8197 for key, value := range shape { 8198 switch key { 8199 case "Message": 8200 if value != nil { 8201 jtv, ok := value.(string) 8202 if !ok { 8203 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 8204 } 8205 sv.Message = ptr.String(jtv) 8206 } 8207 8208 default: 8209 _, _ = key, value 8210 8211 } 8212 } 8213 *v = sv 8214 return nil 8215} 8216 8217func awsAwsjson11_deserializeDocumentAccountNotFoundException(v **types.AccountNotFoundException, value interface{}) error { 8218 if v == nil { 8219 return fmt.Errorf("unexpected nil of type %T", v) 8220 } 8221 if value == nil { 8222 return nil 8223 } 8224 8225 shape, ok := value.(map[string]interface{}) 8226 if !ok { 8227 return fmt.Errorf("unexpected JSON type %v", value) 8228 } 8229 8230 var sv *types.AccountNotFoundException 8231 if *v == nil { 8232 sv = &types.AccountNotFoundException{} 8233 } else { 8234 sv = *v 8235 } 8236 8237 for key, value := range shape { 8238 switch key { 8239 case "Message": 8240 if value != nil { 8241 jtv, ok := value.(string) 8242 if !ok { 8243 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 8244 } 8245 sv.Message = ptr.String(jtv) 8246 } 8247 8248 default: 8249 _, _ = key, value 8250 8251 } 8252 } 8253 *v = sv 8254 return nil 8255} 8256 8257func awsAwsjson11_deserializeDocumentAccountNotRegisteredException(v **types.AccountNotRegisteredException, value interface{}) error { 8258 if v == nil { 8259 return fmt.Errorf("unexpected nil of type %T", v) 8260 } 8261 if value == nil { 8262 return nil 8263 } 8264 8265 shape, ok := value.(map[string]interface{}) 8266 if !ok { 8267 return fmt.Errorf("unexpected JSON type %v", value) 8268 } 8269 8270 var sv *types.AccountNotRegisteredException 8271 if *v == nil { 8272 sv = &types.AccountNotRegisteredException{} 8273 } else { 8274 sv = *v 8275 } 8276 8277 for key, value := range shape { 8278 switch key { 8279 case "Message": 8280 if value != nil { 8281 jtv, ok := value.(string) 8282 if !ok { 8283 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 8284 } 8285 sv.Message = ptr.String(jtv) 8286 } 8287 8288 default: 8289 _, _ = key, value 8290 8291 } 8292 } 8293 *v = sv 8294 return nil 8295} 8296 8297func awsAwsjson11_deserializeDocumentAccountOwnerNotVerifiedException(v **types.AccountOwnerNotVerifiedException, value interface{}) error { 8298 if v == nil { 8299 return fmt.Errorf("unexpected nil of type %T", v) 8300 } 8301 if value == nil { 8302 return nil 8303 } 8304 8305 shape, ok := value.(map[string]interface{}) 8306 if !ok { 8307 return fmt.Errorf("unexpected JSON type %v", value) 8308 } 8309 8310 var sv *types.AccountOwnerNotVerifiedException 8311 if *v == nil { 8312 sv = &types.AccountOwnerNotVerifiedException{} 8313 } else { 8314 sv = *v 8315 } 8316 8317 for key, value := range shape { 8318 switch key { 8319 case "Message": 8320 if value != nil { 8321 jtv, ok := value.(string) 8322 if !ok { 8323 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 8324 } 8325 sv.Message = ptr.String(jtv) 8326 } 8327 8328 default: 8329 _, _ = key, value 8330 8331 } 8332 } 8333 *v = sv 8334 return nil 8335} 8336 8337func awsAwsjson11_deserializeDocumentAccounts(v *[]types.Account, value interface{}) error { 8338 if v == nil { 8339 return fmt.Errorf("unexpected nil of type %T", v) 8340 } 8341 if value == nil { 8342 return nil 8343 } 8344 8345 shape, ok := value.([]interface{}) 8346 if !ok { 8347 return fmt.Errorf("unexpected JSON type %v", value) 8348 } 8349 8350 var cv []types.Account 8351 if *v == nil { 8352 cv = []types.Account{} 8353 } else { 8354 cv = *v 8355 } 8356 8357 for _, value := range shape { 8358 var col types.Account 8359 destAddr := &col 8360 if err := awsAwsjson11_deserializeDocumentAccount(&destAddr, value); err != nil { 8361 return err 8362 } 8363 col = *destAddr 8364 cv = append(cv, col) 8365 8366 } 8367 *v = cv 8368 return nil 8369} 8370 8371func awsAwsjson11_deserializeDocumentAlreadyInOrganizationException(v **types.AlreadyInOrganizationException, value interface{}) error { 8372 if v == nil { 8373 return fmt.Errorf("unexpected nil of type %T", v) 8374 } 8375 if value == nil { 8376 return nil 8377 } 8378 8379 shape, ok := value.(map[string]interface{}) 8380 if !ok { 8381 return fmt.Errorf("unexpected JSON type %v", value) 8382 } 8383 8384 var sv *types.AlreadyInOrganizationException 8385 if *v == nil { 8386 sv = &types.AlreadyInOrganizationException{} 8387 } else { 8388 sv = *v 8389 } 8390 8391 for key, value := range shape { 8392 switch key { 8393 case "Message": 8394 if value != nil { 8395 jtv, ok := value.(string) 8396 if !ok { 8397 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 8398 } 8399 sv.Message = ptr.String(jtv) 8400 } 8401 8402 default: 8403 _, _ = key, value 8404 8405 } 8406 } 8407 *v = sv 8408 return nil 8409} 8410 8411func awsAwsjson11_deserializeDocumentAWSOrganizationsNotInUseException(v **types.AWSOrganizationsNotInUseException, value interface{}) error { 8412 if v == nil { 8413 return fmt.Errorf("unexpected nil of type %T", v) 8414 } 8415 if value == nil { 8416 return nil 8417 } 8418 8419 shape, ok := value.(map[string]interface{}) 8420 if !ok { 8421 return fmt.Errorf("unexpected JSON type %v", value) 8422 } 8423 8424 var sv *types.AWSOrganizationsNotInUseException 8425 if *v == nil { 8426 sv = &types.AWSOrganizationsNotInUseException{} 8427 } else { 8428 sv = *v 8429 } 8430 8431 for key, value := range shape { 8432 switch key { 8433 case "Message": 8434 if value != nil { 8435 jtv, ok := value.(string) 8436 if !ok { 8437 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 8438 } 8439 sv.Message = ptr.String(jtv) 8440 } 8441 8442 default: 8443 _, _ = key, value 8444 8445 } 8446 } 8447 *v = sv 8448 return nil 8449} 8450 8451func awsAwsjson11_deserializeDocumentChild(v **types.Child, value interface{}) error { 8452 if v == nil { 8453 return fmt.Errorf("unexpected nil of type %T", v) 8454 } 8455 if value == nil { 8456 return nil 8457 } 8458 8459 shape, ok := value.(map[string]interface{}) 8460 if !ok { 8461 return fmt.Errorf("unexpected JSON type %v", value) 8462 } 8463 8464 var sv *types.Child 8465 if *v == nil { 8466 sv = &types.Child{} 8467 } else { 8468 sv = *v 8469 } 8470 8471 for key, value := range shape { 8472 switch key { 8473 case "Id": 8474 if value != nil { 8475 jtv, ok := value.(string) 8476 if !ok { 8477 return fmt.Errorf("expected ChildId to be of type string, got %T instead", value) 8478 } 8479 sv.Id = ptr.String(jtv) 8480 } 8481 8482 case "Type": 8483 if value != nil { 8484 jtv, ok := value.(string) 8485 if !ok { 8486 return fmt.Errorf("expected ChildType to be of type string, got %T instead", value) 8487 } 8488 sv.Type = types.ChildType(jtv) 8489 } 8490 8491 default: 8492 _, _ = key, value 8493 8494 } 8495 } 8496 *v = sv 8497 return nil 8498} 8499 8500func awsAwsjson11_deserializeDocumentChildNotFoundException(v **types.ChildNotFoundException, value interface{}) error { 8501 if v == nil { 8502 return fmt.Errorf("unexpected nil of type %T", v) 8503 } 8504 if value == nil { 8505 return nil 8506 } 8507 8508 shape, ok := value.(map[string]interface{}) 8509 if !ok { 8510 return fmt.Errorf("unexpected JSON type %v", value) 8511 } 8512 8513 var sv *types.ChildNotFoundException 8514 if *v == nil { 8515 sv = &types.ChildNotFoundException{} 8516 } else { 8517 sv = *v 8518 } 8519 8520 for key, value := range shape { 8521 switch key { 8522 case "Message": 8523 if value != nil { 8524 jtv, ok := value.(string) 8525 if !ok { 8526 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 8527 } 8528 sv.Message = ptr.String(jtv) 8529 } 8530 8531 default: 8532 _, _ = key, value 8533 8534 } 8535 } 8536 *v = sv 8537 return nil 8538} 8539 8540func awsAwsjson11_deserializeDocumentChildren(v *[]types.Child, value interface{}) error { 8541 if v == nil { 8542 return fmt.Errorf("unexpected nil of type %T", v) 8543 } 8544 if value == nil { 8545 return nil 8546 } 8547 8548 shape, ok := value.([]interface{}) 8549 if !ok { 8550 return fmt.Errorf("unexpected JSON type %v", value) 8551 } 8552 8553 var cv []types.Child 8554 if *v == nil { 8555 cv = []types.Child{} 8556 } else { 8557 cv = *v 8558 } 8559 8560 for _, value := range shape { 8561 var col types.Child 8562 destAddr := &col 8563 if err := awsAwsjson11_deserializeDocumentChild(&destAddr, value); err != nil { 8564 return err 8565 } 8566 col = *destAddr 8567 cv = append(cv, col) 8568 8569 } 8570 *v = cv 8571 return nil 8572} 8573 8574func awsAwsjson11_deserializeDocumentConcurrentModificationException(v **types.ConcurrentModificationException, value interface{}) error { 8575 if v == nil { 8576 return fmt.Errorf("unexpected nil of type %T", v) 8577 } 8578 if value == nil { 8579 return nil 8580 } 8581 8582 shape, ok := value.(map[string]interface{}) 8583 if !ok { 8584 return fmt.Errorf("unexpected JSON type %v", value) 8585 } 8586 8587 var sv *types.ConcurrentModificationException 8588 if *v == nil { 8589 sv = &types.ConcurrentModificationException{} 8590 } else { 8591 sv = *v 8592 } 8593 8594 for key, value := range shape { 8595 switch key { 8596 case "Message": 8597 if value != nil { 8598 jtv, ok := value.(string) 8599 if !ok { 8600 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 8601 } 8602 sv.Message = ptr.String(jtv) 8603 } 8604 8605 default: 8606 _, _ = key, value 8607 8608 } 8609 } 8610 *v = sv 8611 return nil 8612} 8613 8614func awsAwsjson11_deserializeDocumentConstraintViolationException(v **types.ConstraintViolationException, value interface{}) error { 8615 if v == nil { 8616 return fmt.Errorf("unexpected nil of type %T", v) 8617 } 8618 if value == nil { 8619 return nil 8620 } 8621 8622 shape, ok := value.(map[string]interface{}) 8623 if !ok { 8624 return fmt.Errorf("unexpected JSON type %v", value) 8625 } 8626 8627 var sv *types.ConstraintViolationException 8628 if *v == nil { 8629 sv = &types.ConstraintViolationException{} 8630 } else { 8631 sv = *v 8632 } 8633 8634 for key, value := range shape { 8635 switch key { 8636 case "Message": 8637 if value != nil { 8638 jtv, ok := value.(string) 8639 if !ok { 8640 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 8641 } 8642 sv.Message = ptr.String(jtv) 8643 } 8644 8645 case "Reason": 8646 if value != nil { 8647 jtv, ok := value.(string) 8648 if !ok { 8649 return fmt.Errorf("expected ConstraintViolationExceptionReason to be of type string, got %T instead", value) 8650 } 8651 sv.Reason = types.ConstraintViolationExceptionReason(jtv) 8652 } 8653 8654 default: 8655 _, _ = key, value 8656 8657 } 8658 } 8659 *v = sv 8660 return nil 8661} 8662 8663func awsAwsjson11_deserializeDocumentCreateAccountStatus(v **types.CreateAccountStatus, value interface{}) error { 8664 if v == nil { 8665 return fmt.Errorf("unexpected nil of type %T", v) 8666 } 8667 if value == nil { 8668 return nil 8669 } 8670 8671 shape, ok := value.(map[string]interface{}) 8672 if !ok { 8673 return fmt.Errorf("unexpected JSON type %v", value) 8674 } 8675 8676 var sv *types.CreateAccountStatus 8677 if *v == nil { 8678 sv = &types.CreateAccountStatus{} 8679 } else { 8680 sv = *v 8681 } 8682 8683 for key, value := range shape { 8684 switch key { 8685 case "AccountId": 8686 if value != nil { 8687 jtv, ok := value.(string) 8688 if !ok { 8689 return fmt.Errorf("expected AccountId to be of type string, got %T instead", value) 8690 } 8691 sv.AccountId = ptr.String(jtv) 8692 } 8693 8694 case "AccountName": 8695 if value != nil { 8696 jtv, ok := value.(string) 8697 if !ok { 8698 return fmt.Errorf("expected AccountName to be of type string, got %T instead", value) 8699 } 8700 sv.AccountName = ptr.String(jtv) 8701 } 8702 8703 case "CompletedTimestamp": 8704 if value != nil { 8705 jtv, ok := value.(json.Number) 8706 if !ok { 8707 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 8708 } 8709 f64, err := jtv.Float64() 8710 if err != nil { 8711 return err 8712 } 8713 sv.CompletedTimestamp = ptr.Time(smithytime.ParseEpochSeconds(f64)) 8714 } 8715 8716 case "FailureReason": 8717 if value != nil { 8718 jtv, ok := value.(string) 8719 if !ok { 8720 return fmt.Errorf("expected CreateAccountFailureReason to be of type string, got %T instead", value) 8721 } 8722 sv.FailureReason = types.CreateAccountFailureReason(jtv) 8723 } 8724 8725 case "GovCloudAccountId": 8726 if value != nil { 8727 jtv, ok := value.(string) 8728 if !ok { 8729 return fmt.Errorf("expected AccountId to be of type string, got %T instead", value) 8730 } 8731 sv.GovCloudAccountId = ptr.String(jtv) 8732 } 8733 8734 case "Id": 8735 if value != nil { 8736 jtv, ok := value.(string) 8737 if !ok { 8738 return fmt.Errorf("expected CreateAccountRequestId to be of type string, got %T instead", value) 8739 } 8740 sv.Id = ptr.String(jtv) 8741 } 8742 8743 case "RequestedTimestamp": 8744 if value != nil { 8745 jtv, ok := value.(json.Number) 8746 if !ok { 8747 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 8748 } 8749 f64, err := jtv.Float64() 8750 if err != nil { 8751 return err 8752 } 8753 sv.RequestedTimestamp = ptr.Time(smithytime.ParseEpochSeconds(f64)) 8754 } 8755 8756 case "State": 8757 if value != nil { 8758 jtv, ok := value.(string) 8759 if !ok { 8760 return fmt.Errorf("expected CreateAccountState to be of type string, got %T instead", value) 8761 } 8762 sv.State = types.CreateAccountState(jtv) 8763 } 8764 8765 default: 8766 _, _ = key, value 8767 8768 } 8769 } 8770 *v = sv 8771 return nil 8772} 8773 8774func awsAwsjson11_deserializeDocumentCreateAccountStatuses(v *[]types.CreateAccountStatus, value interface{}) error { 8775 if v == nil { 8776 return fmt.Errorf("unexpected nil of type %T", v) 8777 } 8778 if value == nil { 8779 return nil 8780 } 8781 8782 shape, ok := value.([]interface{}) 8783 if !ok { 8784 return fmt.Errorf("unexpected JSON type %v", value) 8785 } 8786 8787 var cv []types.CreateAccountStatus 8788 if *v == nil { 8789 cv = []types.CreateAccountStatus{} 8790 } else { 8791 cv = *v 8792 } 8793 8794 for _, value := range shape { 8795 var col types.CreateAccountStatus 8796 destAddr := &col 8797 if err := awsAwsjson11_deserializeDocumentCreateAccountStatus(&destAddr, value); err != nil { 8798 return err 8799 } 8800 col = *destAddr 8801 cv = append(cv, col) 8802 8803 } 8804 *v = cv 8805 return nil 8806} 8807 8808func awsAwsjson11_deserializeDocumentCreateAccountStatusNotFoundException(v **types.CreateAccountStatusNotFoundException, value interface{}) error { 8809 if v == nil { 8810 return fmt.Errorf("unexpected nil of type %T", v) 8811 } 8812 if value == nil { 8813 return nil 8814 } 8815 8816 shape, ok := value.(map[string]interface{}) 8817 if !ok { 8818 return fmt.Errorf("unexpected JSON type %v", value) 8819 } 8820 8821 var sv *types.CreateAccountStatusNotFoundException 8822 if *v == nil { 8823 sv = &types.CreateAccountStatusNotFoundException{} 8824 } else { 8825 sv = *v 8826 } 8827 8828 for key, value := range shape { 8829 switch key { 8830 case "Message": 8831 if value != nil { 8832 jtv, ok := value.(string) 8833 if !ok { 8834 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 8835 } 8836 sv.Message = ptr.String(jtv) 8837 } 8838 8839 default: 8840 _, _ = key, value 8841 8842 } 8843 } 8844 *v = sv 8845 return nil 8846} 8847 8848func awsAwsjson11_deserializeDocumentDelegatedAdministrator(v **types.DelegatedAdministrator, value interface{}) error { 8849 if v == nil { 8850 return fmt.Errorf("unexpected nil of type %T", v) 8851 } 8852 if value == nil { 8853 return nil 8854 } 8855 8856 shape, ok := value.(map[string]interface{}) 8857 if !ok { 8858 return fmt.Errorf("unexpected JSON type %v", value) 8859 } 8860 8861 var sv *types.DelegatedAdministrator 8862 if *v == nil { 8863 sv = &types.DelegatedAdministrator{} 8864 } else { 8865 sv = *v 8866 } 8867 8868 for key, value := range shape { 8869 switch key { 8870 case "Arn": 8871 if value != nil { 8872 jtv, ok := value.(string) 8873 if !ok { 8874 return fmt.Errorf("expected AccountArn to be of type string, got %T instead", value) 8875 } 8876 sv.Arn = ptr.String(jtv) 8877 } 8878 8879 case "DelegationEnabledDate": 8880 if value != nil { 8881 jtv, ok := value.(json.Number) 8882 if !ok { 8883 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 8884 } 8885 f64, err := jtv.Float64() 8886 if err != nil { 8887 return err 8888 } 8889 sv.DelegationEnabledDate = ptr.Time(smithytime.ParseEpochSeconds(f64)) 8890 } 8891 8892 case "Email": 8893 if value != nil { 8894 jtv, ok := value.(string) 8895 if !ok { 8896 return fmt.Errorf("expected Email to be of type string, got %T instead", value) 8897 } 8898 sv.Email = ptr.String(jtv) 8899 } 8900 8901 case "Id": 8902 if value != nil { 8903 jtv, ok := value.(string) 8904 if !ok { 8905 return fmt.Errorf("expected AccountId to be of type string, got %T instead", value) 8906 } 8907 sv.Id = ptr.String(jtv) 8908 } 8909 8910 case "JoinedMethod": 8911 if value != nil { 8912 jtv, ok := value.(string) 8913 if !ok { 8914 return fmt.Errorf("expected AccountJoinedMethod to be of type string, got %T instead", value) 8915 } 8916 sv.JoinedMethod = types.AccountJoinedMethod(jtv) 8917 } 8918 8919 case "JoinedTimestamp": 8920 if value != nil { 8921 jtv, ok := value.(json.Number) 8922 if !ok { 8923 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 8924 } 8925 f64, err := jtv.Float64() 8926 if err != nil { 8927 return err 8928 } 8929 sv.JoinedTimestamp = ptr.Time(smithytime.ParseEpochSeconds(f64)) 8930 } 8931 8932 case "Name": 8933 if value != nil { 8934 jtv, ok := value.(string) 8935 if !ok { 8936 return fmt.Errorf("expected AccountName to be of type string, got %T instead", value) 8937 } 8938 sv.Name = ptr.String(jtv) 8939 } 8940 8941 case "Status": 8942 if value != nil { 8943 jtv, ok := value.(string) 8944 if !ok { 8945 return fmt.Errorf("expected AccountStatus to be of type string, got %T instead", value) 8946 } 8947 sv.Status = types.AccountStatus(jtv) 8948 } 8949 8950 default: 8951 _, _ = key, value 8952 8953 } 8954 } 8955 *v = sv 8956 return nil 8957} 8958 8959func awsAwsjson11_deserializeDocumentDelegatedAdministrators(v *[]types.DelegatedAdministrator, value interface{}) error { 8960 if v == nil { 8961 return fmt.Errorf("unexpected nil of type %T", v) 8962 } 8963 if value == nil { 8964 return nil 8965 } 8966 8967 shape, ok := value.([]interface{}) 8968 if !ok { 8969 return fmt.Errorf("unexpected JSON type %v", value) 8970 } 8971 8972 var cv []types.DelegatedAdministrator 8973 if *v == nil { 8974 cv = []types.DelegatedAdministrator{} 8975 } else { 8976 cv = *v 8977 } 8978 8979 for _, value := range shape { 8980 var col types.DelegatedAdministrator 8981 destAddr := &col 8982 if err := awsAwsjson11_deserializeDocumentDelegatedAdministrator(&destAddr, value); err != nil { 8983 return err 8984 } 8985 col = *destAddr 8986 cv = append(cv, col) 8987 8988 } 8989 *v = cv 8990 return nil 8991} 8992 8993func awsAwsjson11_deserializeDocumentDelegatedService(v **types.DelegatedService, value interface{}) error { 8994 if v == nil { 8995 return fmt.Errorf("unexpected nil of type %T", v) 8996 } 8997 if value == nil { 8998 return nil 8999 } 9000 9001 shape, ok := value.(map[string]interface{}) 9002 if !ok { 9003 return fmt.Errorf("unexpected JSON type %v", value) 9004 } 9005 9006 var sv *types.DelegatedService 9007 if *v == nil { 9008 sv = &types.DelegatedService{} 9009 } else { 9010 sv = *v 9011 } 9012 9013 for key, value := range shape { 9014 switch key { 9015 case "DelegationEnabledDate": 9016 if value != nil { 9017 jtv, ok := value.(json.Number) 9018 if !ok { 9019 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 9020 } 9021 f64, err := jtv.Float64() 9022 if err != nil { 9023 return err 9024 } 9025 sv.DelegationEnabledDate = ptr.Time(smithytime.ParseEpochSeconds(f64)) 9026 } 9027 9028 case "ServicePrincipal": 9029 if value != nil { 9030 jtv, ok := value.(string) 9031 if !ok { 9032 return fmt.Errorf("expected ServicePrincipal to be of type string, got %T instead", value) 9033 } 9034 sv.ServicePrincipal = ptr.String(jtv) 9035 } 9036 9037 default: 9038 _, _ = key, value 9039 9040 } 9041 } 9042 *v = sv 9043 return nil 9044} 9045 9046func awsAwsjson11_deserializeDocumentDelegatedServices(v *[]types.DelegatedService, value interface{}) error { 9047 if v == nil { 9048 return fmt.Errorf("unexpected nil of type %T", v) 9049 } 9050 if value == nil { 9051 return nil 9052 } 9053 9054 shape, ok := value.([]interface{}) 9055 if !ok { 9056 return fmt.Errorf("unexpected JSON type %v", value) 9057 } 9058 9059 var cv []types.DelegatedService 9060 if *v == nil { 9061 cv = []types.DelegatedService{} 9062 } else { 9063 cv = *v 9064 } 9065 9066 for _, value := range shape { 9067 var col types.DelegatedService 9068 destAddr := &col 9069 if err := awsAwsjson11_deserializeDocumentDelegatedService(&destAddr, value); err != nil { 9070 return err 9071 } 9072 col = *destAddr 9073 cv = append(cv, col) 9074 9075 } 9076 *v = cv 9077 return nil 9078} 9079 9080func awsAwsjson11_deserializeDocumentDestinationParentNotFoundException(v **types.DestinationParentNotFoundException, value interface{}) error { 9081 if v == nil { 9082 return fmt.Errorf("unexpected nil of type %T", v) 9083 } 9084 if value == nil { 9085 return nil 9086 } 9087 9088 shape, ok := value.(map[string]interface{}) 9089 if !ok { 9090 return fmt.Errorf("unexpected JSON type %v", value) 9091 } 9092 9093 var sv *types.DestinationParentNotFoundException 9094 if *v == nil { 9095 sv = &types.DestinationParentNotFoundException{} 9096 } else { 9097 sv = *v 9098 } 9099 9100 for key, value := range shape { 9101 switch key { 9102 case "Message": 9103 if value != nil { 9104 jtv, ok := value.(string) 9105 if !ok { 9106 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 9107 } 9108 sv.Message = ptr.String(jtv) 9109 } 9110 9111 default: 9112 _, _ = key, value 9113 9114 } 9115 } 9116 *v = sv 9117 return nil 9118} 9119 9120func awsAwsjson11_deserializeDocumentDuplicateAccountException(v **types.DuplicateAccountException, value interface{}) error { 9121 if v == nil { 9122 return fmt.Errorf("unexpected nil of type %T", v) 9123 } 9124 if value == nil { 9125 return nil 9126 } 9127 9128 shape, ok := value.(map[string]interface{}) 9129 if !ok { 9130 return fmt.Errorf("unexpected JSON type %v", value) 9131 } 9132 9133 var sv *types.DuplicateAccountException 9134 if *v == nil { 9135 sv = &types.DuplicateAccountException{} 9136 } else { 9137 sv = *v 9138 } 9139 9140 for key, value := range shape { 9141 switch key { 9142 case "Message": 9143 if value != nil { 9144 jtv, ok := value.(string) 9145 if !ok { 9146 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 9147 } 9148 sv.Message = ptr.String(jtv) 9149 } 9150 9151 default: 9152 _, _ = key, value 9153 9154 } 9155 } 9156 *v = sv 9157 return nil 9158} 9159 9160func awsAwsjson11_deserializeDocumentDuplicateHandshakeException(v **types.DuplicateHandshakeException, value interface{}) error { 9161 if v == nil { 9162 return fmt.Errorf("unexpected nil of type %T", v) 9163 } 9164 if value == nil { 9165 return nil 9166 } 9167 9168 shape, ok := value.(map[string]interface{}) 9169 if !ok { 9170 return fmt.Errorf("unexpected JSON type %v", value) 9171 } 9172 9173 var sv *types.DuplicateHandshakeException 9174 if *v == nil { 9175 sv = &types.DuplicateHandshakeException{} 9176 } else { 9177 sv = *v 9178 } 9179 9180 for key, value := range shape { 9181 switch key { 9182 case "Message": 9183 if value != nil { 9184 jtv, ok := value.(string) 9185 if !ok { 9186 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 9187 } 9188 sv.Message = ptr.String(jtv) 9189 } 9190 9191 default: 9192 _, _ = key, value 9193 9194 } 9195 } 9196 *v = sv 9197 return nil 9198} 9199 9200func awsAwsjson11_deserializeDocumentDuplicateOrganizationalUnitException(v **types.DuplicateOrganizationalUnitException, value interface{}) error { 9201 if v == nil { 9202 return fmt.Errorf("unexpected nil of type %T", v) 9203 } 9204 if value == nil { 9205 return nil 9206 } 9207 9208 shape, ok := value.(map[string]interface{}) 9209 if !ok { 9210 return fmt.Errorf("unexpected JSON type %v", value) 9211 } 9212 9213 var sv *types.DuplicateOrganizationalUnitException 9214 if *v == nil { 9215 sv = &types.DuplicateOrganizationalUnitException{} 9216 } else { 9217 sv = *v 9218 } 9219 9220 for key, value := range shape { 9221 switch key { 9222 case "Message": 9223 if value != nil { 9224 jtv, ok := value.(string) 9225 if !ok { 9226 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 9227 } 9228 sv.Message = ptr.String(jtv) 9229 } 9230 9231 default: 9232 _, _ = key, value 9233 9234 } 9235 } 9236 *v = sv 9237 return nil 9238} 9239 9240func awsAwsjson11_deserializeDocumentDuplicatePolicyAttachmentException(v **types.DuplicatePolicyAttachmentException, value interface{}) error { 9241 if v == nil { 9242 return fmt.Errorf("unexpected nil of type %T", v) 9243 } 9244 if value == nil { 9245 return nil 9246 } 9247 9248 shape, ok := value.(map[string]interface{}) 9249 if !ok { 9250 return fmt.Errorf("unexpected JSON type %v", value) 9251 } 9252 9253 var sv *types.DuplicatePolicyAttachmentException 9254 if *v == nil { 9255 sv = &types.DuplicatePolicyAttachmentException{} 9256 } else { 9257 sv = *v 9258 } 9259 9260 for key, value := range shape { 9261 switch key { 9262 case "Message": 9263 if value != nil { 9264 jtv, ok := value.(string) 9265 if !ok { 9266 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 9267 } 9268 sv.Message = ptr.String(jtv) 9269 } 9270 9271 default: 9272 _, _ = key, value 9273 9274 } 9275 } 9276 *v = sv 9277 return nil 9278} 9279 9280func awsAwsjson11_deserializeDocumentDuplicatePolicyException(v **types.DuplicatePolicyException, value interface{}) error { 9281 if v == nil { 9282 return fmt.Errorf("unexpected nil of type %T", v) 9283 } 9284 if value == nil { 9285 return nil 9286 } 9287 9288 shape, ok := value.(map[string]interface{}) 9289 if !ok { 9290 return fmt.Errorf("unexpected JSON type %v", value) 9291 } 9292 9293 var sv *types.DuplicatePolicyException 9294 if *v == nil { 9295 sv = &types.DuplicatePolicyException{} 9296 } else { 9297 sv = *v 9298 } 9299 9300 for key, value := range shape { 9301 switch key { 9302 case "Message": 9303 if value != nil { 9304 jtv, ok := value.(string) 9305 if !ok { 9306 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 9307 } 9308 sv.Message = ptr.String(jtv) 9309 } 9310 9311 default: 9312 _, _ = key, value 9313 9314 } 9315 } 9316 *v = sv 9317 return nil 9318} 9319 9320func awsAwsjson11_deserializeDocumentEffectivePolicy(v **types.EffectivePolicy, value interface{}) error { 9321 if v == nil { 9322 return fmt.Errorf("unexpected nil of type %T", v) 9323 } 9324 if value == nil { 9325 return nil 9326 } 9327 9328 shape, ok := value.(map[string]interface{}) 9329 if !ok { 9330 return fmt.Errorf("unexpected JSON type %v", value) 9331 } 9332 9333 var sv *types.EffectivePolicy 9334 if *v == nil { 9335 sv = &types.EffectivePolicy{} 9336 } else { 9337 sv = *v 9338 } 9339 9340 for key, value := range shape { 9341 switch key { 9342 case "LastUpdatedTimestamp": 9343 if value != nil { 9344 jtv, ok := value.(json.Number) 9345 if !ok { 9346 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 9347 } 9348 f64, err := jtv.Float64() 9349 if err != nil { 9350 return err 9351 } 9352 sv.LastUpdatedTimestamp = ptr.Time(smithytime.ParseEpochSeconds(f64)) 9353 } 9354 9355 case "PolicyContent": 9356 if value != nil { 9357 jtv, ok := value.(string) 9358 if !ok { 9359 return fmt.Errorf("expected PolicyContent to be of type string, got %T instead", value) 9360 } 9361 sv.PolicyContent = ptr.String(jtv) 9362 } 9363 9364 case "PolicyType": 9365 if value != nil { 9366 jtv, ok := value.(string) 9367 if !ok { 9368 return fmt.Errorf("expected EffectivePolicyType to be of type string, got %T instead", value) 9369 } 9370 sv.PolicyType = types.EffectivePolicyType(jtv) 9371 } 9372 9373 case "TargetId": 9374 if value != nil { 9375 jtv, ok := value.(string) 9376 if !ok { 9377 return fmt.Errorf("expected PolicyTargetId to be of type string, got %T instead", value) 9378 } 9379 sv.TargetId = ptr.String(jtv) 9380 } 9381 9382 default: 9383 _, _ = key, value 9384 9385 } 9386 } 9387 *v = sv 9388 return nil 9389} 9390 9391func awsAwsjson11_deserializeDocumentEffectivePolicyNotFoundException(v **types.EffectivePolicyNotFoundException, value interface{}) error { 9392 if v == nil { 9393 return fmt.Errorf("unexpected nil of type %T", v) 9394 } 9395 if value == nil { 9396 return nil 9397 } 9398 9399 shape, ok := value.(map[string]interface{}) 9400 if !ok { 9401 return fmt.Errorf("unexpected JSON type %v", value) 9402 } 9403 9404 var sv *types.EffectivePolicyNotFoundException 9405 if *v == nil { 9406 sv = &types.EffectivePolicyNotFoundException{} 9407 } else { 9408 sv = *v 9409 } 9410 9411 for key, value := range shape { 9412 switch key { 9413 case "Message": 9414 if value != nil { 9415 jtv, ok := value.(string) 9416 if !ok { 9417 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 9418 } 9419 sv.Message = ptr.String(jtv) 9420 } 9421 9422 default: 9423 _, _ = key, value 9424 9425 } 9426 } 9427 *v = sv 9428 return nil 9429} 9430 9431func awsAwsjson11_deserializeDocumentEnabledServicePrincipal(v **types.EnabledServicePrincipal, value interface{}) error { 9432 if v == nil { 9433 return fmt.Errorf("unexpected nil of type %T", v) 9434 } 9435 if value == nil { 9436 return nil 9437 } 9438 9439 shape, ok := value.(map[string]interface{}) 9440 if !ok { 9441 return fmt.Errorf("unexpected JSON type %v", value) 9442 } 9443 9444 var sv *types.EnabledServicePrincipal 9445 if *v == nil { 9446 sv = &types.EnabledServicePrincipal{} 9447 } else { 9448 sv = *v 9449 } 9450 9451 for key, value := range shape { 9452 switch key { 9453 case "DateEnabled": 9454 if value != nil { 9455 jtv, ok := value.(json.Number) 9456 if !ok { 9457 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 9458 } 9459 f64, err := jtv.Float64() 9460 if err != nil { 9461 return err 9462 } 9463 sv.DateEnabled = ptr.Time(smithytime.ParseEpochSeconds(f64)) 9464 } 9465 9466 case "ServicePrincipal": 9467 if value != nil { 9468 jtv, ok := value.(string) 9469 if !ok { 9470 return fmt.Errorf("expected ServicePrincipal to be of type string, got %T instead", value) 9471 } 9472 sv.ServicePrincipal = ptr.String(jtv) 9473 } 9474 9475 default: 9476 _, _ = key, value 9477 9478 } 9479 } 9480 *v = sv 9481 return nil 9482} 9483 9484func awsAwsjson11_deserializeDocumentEnabledServicePrincipals(v *[]types.EnabledServicePrincipal, value interface{}) error { 9485 if v == nil { 9486 return fmt.Errorf("unexpected nil of type %T", v) 9487 } 9488 if value == nil { 9489 return nil 9490 } 9491 9492 shape, ok := value.([]interface{}) 9493 if !ok { 9494 return fmt.Errorf("unexpected JSON type %v", value) 9495 } 9496 9497 var cv []types.EnabledServicePrincipal 9498 if *v == nil { 9499 cv = []types.EnabledServicePrincipal{} 9500 } else { 9501 cv = *v 9502 } 9503 9504 for _, value := range shape { 9505 var col types.EnabledServicePrincipal 9506 destAddr := &col 9507 if err := awsAwsjson11_deserializeDocumentEnabledServicePrincipal(&destAddr, value); err != nil { 9508 return err 9509 } 9510 col = *destAddr 9511 cv = append(cv, col) 9512 9513 } 9514 *v = cv 9515 return nil 9516} 9517 9518func awsAwsjson11_deserializeDocumentFinalizingOrganizationException(v **types.FinalizingOrganizationException, value interface{}) error { 9519 if v == nil { 9520 return fmt.Errorf("unexpected nil of type %T", v) 9521 } 9522 if value == nil { 9523 return nil 9524 } 9525 9526 shape, ok := value.(map[string]interface{}) 9527 if !ok { 9528 return fmt.Errorf("unexpected JSON type %v", value) 9529 } 9530 9531 var sv *types.FinalizingOrganizationException 9532 if *v == nil { 9533 sv = &types.FinalizingOrganizationException{} 9534 } else { 9535 sv = *v 9536 } 9537 9538 for key, value := range shape { 9539 switch key { 9540 case "Message": 9541 if value != nil { 9542 jtv, ok := value.(string) 9543 if !ok { 9544 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 9545 } 9546 sv.Message = ptr.String(jtv) 9547 } 9548 9549 default: 9550 _, _ = key, value 9551 9552 } 9553 } 9554 *v = sv 9555 return nil 9556} 9557 9558func awsAwsjson11_deserializeDocumentHandshake(v **types.Handshake, value interface{}) error { 9559 if v == nil { 9560 return fmt.Errorf("unexpected nil of type %T", v) 9561 } 9562 if value == nil { 9563 return nil 9564 } 9565 9566 shape, ok := value.(map[string]interface{}) 9567 if !ok { 9568 return fmt.Errorf("unexpected JSON type %v", value) 9569 } 9570 9571 var sv *types.Handshake 9572 if *v == nil { 9573 sv = &types.Handshake{} 9574 } else { 9575 sv = *v 9576 } 9577 9578 for key, value := range shape { 9579 switch key { 9580 case "Action": 9581 if value != nil { 9582 jtv, ok := value.(string) 9583 if !ok { 9584 return fmt.Errorf("expected ActionType to be of type string, got %T instead", value) 9585 } 9586 sv.Action = types.ActionType(jtv) 9587 } 9588 9589 case "Arn": 9590 if value != nil { 9591 jtv, ok := value.(string) 9592 if !ok { 9593 return fmt.Errorf("expected HandshakeArn to be of type string, got %T instead", value) 9594 } 9595 sv.Arn = ptr.String(jtv) 9596 } 9597 9598 case "ExpirationTimestamp": 9599 if value != nil { 9600 jtv, ok := value.(json.Number) 9601 if !ok { 9602 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 9603 } 9604 f64, err := jtv.Float64() 9605 if err != nil { 9606 return err 9607 } 9608 sv.ExpirationTimestamp = ptr.Time(smithytime.ParseEpochSeconds(f64)) 9609 } 9610 9611 case "Id": 9612 if value != nil { 9613 jtv, ok := value.(string) 9614 if !ok { 9615 return fmt.Errorf("expected HandshakeId to be of type string, got %T instead", value) 9616 } 9617 sv.Id = ptr.String(jtv) 9618 } 9619 9620 case "Parties": 9621 if err := awsAwsjson11_deserializeDocumentHandshakeParties(&sv.Parties, value); err != nil { 9622 return err 9623 } 9624 9625 case "RequestedTimestamp": 9626 if value != nil { 9627 jtv, ok := value.(json.Number) 9628 if !ok { 9629 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 9630 } 9631 f64, err := jtv.Float64() 9632 if err != nil { 9633 return err 9634 } 9635 sv.RequestedTimestamp = ptr.Time(smithytime.ParseEpochSeconds(f64)) 9636 } 9637 9638 case "Resources": 9639 if err := awsAwsjson11_deserializeDocumentHandshakeResources(&sv.Resources, value); err != nil { 9640 return err 9641 } 9642 9643 case "State": 9644 if value != nil { 9645 jtv, ok := value.(string) 9646 if !ok { 9647 return fmt.Errorf("expected HandshakeState to be of type string, got %T instead", value) 9648 } 9649 sv.State = types.HandshakeState(jtv) 9650 } 9651 9652 default: 9653 _, _ = key, value 9654 9655 } 9656 } 9657 *v = sv 9658 return nil 9659} 9660 9661func awsAwsjson11_deserializeDocumentHandshakeAlreadyInStateException(v **types.HandshakeAlreadyInStateException, value interface{}) error { 9662 if v == nil { 9663 return fmt.Errorf("unexpected nil of type %T", v) 9664 } 9665 if value == nil { 9666 return nil 9667 } 9668 9669 shape, ok := value.(map[string]interface{}) 9670 if !ok { 9671 return fmt.Errorf("unexpected JSON type %v", value) 9672 } 9673 9674 var sv *types.HandshakeAlreadyInStateException 9675 if *v == nil { 9676 sv = &types.HandshakeAlreadyInStateException{} 9677 } else { 9678 sv = *v 9679 } 9680 9681 for key, value := range shape { 9682 switch key { 9683 case "Message": 9684 if value != nil { 9685 jtv, ok := value.(string) 9686 if !ok { 9687 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 9688 } 9689 sv.Message = ptr.String(jtv) 9690 } 9691 9692 default: 9693 _, _ = key, value 9694 9695 } 9696 } 9697 *v = sv 9698 return nil 9699} 9700 9701func awsAwsjson11_deserializeDocumentHandshakeConstraintViolationException(v **types.HandshakeConstraintViolationException, value interface{}) error { 9702 if v == nil { 9703 return fmt.Errorf("unexpected nil of type %T", v) 9704 } 9705 if value == nil { 9706 return nil 9707 } 9708 9709 shape, ok := value.(map[string]interface{}) 9710 if !ok { 9711 return fmt.Errorf("unexpected JSON type %v", value) 9712 } 9713 9714 var sv *types.HandshakeConstraintViolationException 9715 if *v == nil { 9716 sv = &types.HandshakeConstraintViolationException{} 9717 } else { 9718 sv = *v 9719 } 9720 9721 for key, value := range shape { 9722 switch key { 9723 case "Message": 9724 if value != nil { 9725 jtv, ok := value.(string) 9726 if !ok { 9727 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 9728 } 9729 sv.Message = ptr.String(jtv) 9730 } 9731 9732 case "Reason": 9733 if value != nil { 9734 jtv, ok := value.(string) 9735 if !ok { 9736 return fmt.Errorf("expected HandshakeConstraintViolationExceptionReason to be of type string, got %T instead", value) 9737 } 9738 sv.Reason = types.HandshakeConstraintViolationExceptionReason(jtv) 9739 } 9740 9741 default: 9742 _, _ = key, value 9743 9744 } 9745 } 9746 *v = sv 9747 return nil 9748} 9749 9750func awsAwsjson11_deserializeDocumentHandshakeNotFoundException(v **types.HandshakeNotFoundException, value interface{}) error { 9751 if v == nil { 9752 return fmt.Errorf("unexpected nil of type %T", v) 9753 } 9754 if value == nil { 9755 return nil 9756 } 9757 9758 shape, ok := value.(map[string]interface{}) 9759 if !ok { 9760 return fmt.Errorf("unexpected JSON type %v", value) 9761 } 9762 9763 var sv *types.HandshakeNotFoundException 9764 if *v == nil { 9765 sv = &types.HandshakeNotFoundException{} 9766 } else { 9767 sv = *v 9768 } 9769 9770 for key, value := range shape { 9771 switch key { 9772 case "Message": 9773 if value != nil { 9774 jtv, ok := value.(string) 9775 if !ok { 9776 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 9777 } 9778 sv.Message = ptr.String(jtv) 9779 } 9780 9781 default: 9782 _, _ = key, value 9783 9784 } 9785 } 9786 *v = sv 9787 return nil 9788} 9789 9790func awsAwsjson11_deserializeDocumentHandshakeParties(v *[]types.HandshakeParty, value interface{}) error { 9791 if v == nil { 9792 return fmt.Errorf("unexpected nil of type %T", v) 9793 } 9794 if value == nil { 9795 return nil 9796 } 9797 9798 shape, ok := value.([]interface{}) 9799 if !ok { 9800 return fmt.Errorf("unexpected JSON type %v", value) 9801 } 9802 9803 var cv []types.HandshakeParty 9804 if *v == nil { 9805 cv = []types.HandshakeParty{} 9806 } else { 9807 cv = *v 9808 } 9809 9810 for _, value := range shape { 9811 var col types.HandshakeParty 9812 destAddr := &col 9813 if err := awsAwsjson11_deserializeDocumentHandshakeParty(&destAddr, value); err != nil { 9814 return err 9815 } 9816 col = *destAddr 9817 cv = append(cv, col) 9818 9819 } 9820 *v = cv 9821 return nil 9822} 9823 9824func awsAwsjson11_deserializeDocumentHandshakeParty(v **types.HandshakeParty, value interface{}) error { 9825 if v == nil { 9826 return fmt.Errorf("unexpected nil of type %T", v) 9827 } 9828 if value == nil { 9829 return nil 9830 } 9831 9832 shape, ok := value.(map[string]interface{}) 9833 if !ok { 9834 return fmt.Errorf("unexpected JSON type %v", value) 9835 } 9836 9837 var sv *types.HandshakeParty 9838 if *v == nil { 9839 sv = &types.HandshakeParty{} 9840 } else { 9841 sv = *v 9842 } 9843 9844 for key, value := range shape { 9845 switch key { 9846 case "Id": 9847 if value != nil { 9848 jtv, ok := value.(string) 9849 if !ok { 9850 return fmt.Errorf("expected HandshakePartyId to be of type string, got %T instead", value) 9851 } 9852 sv.Id = ptr.String(jtv) 9853 } 9854 9855 case "Type": 9856 if value != nil { 9857 jtv, ok := value.(string) 9858 if !ok { 9859 return fmt.Errorf("expected HandshakePartyType to be of type string, got %T instead", value) 9860 } 9861 sv.Type = types.HandshakePartyType(jtv) 9862 } 9863 9864 default: 9865 _, _ = key, value 9866 9867 } 9868 } 9869 *v = sv 9870 return nil 9871} 9872 9873func awsAwsjson11_deserializeDocumentHandshakeResource(v **types.HandshakeResource, value interface{}) error { 9874 if v == nil { 9875 return fmt.Errorf("unexpected nil of type %T", v) 9876 } 9877 if value == nil { 9878 return nil 9879 } 9880 9881 shape, ok := value.(map[string]interface{}) 9882 if !ok { 9883 return fmt.Errorf("unexpected JSON type %v", value) 9884 } 9885 9886 var sv *types.HandshakeResource 9887 if *v == nil { 9888 sv = &types.HandshakeResource{} 9889 } else { 9890 sv = *v 9891 } 9892 9893 for key, value := range shape { 9894 switch key { 9895 case "Resources": 9896 if err := awsAwsjson11_deserializeDocumentHandshakeResources(&sv.Resources, value); err != nil { 9897 return err 9898 } 9899 9900 case "Type": 9901 if value != nil { 9902 jtv, ok := value.(string) 9903 if !ok { 9904 return fmt.Errorf("expected HandshakeResourceType to be of type string, got %T instead", value) 9905 } 9906 sv.Type = types.HandshakeResourceType(jtv) 9907 } 9908 9909 case "Value": 9910 if value != nil { 9911 jtv, ok := value.(string) 9912 if !ok { 9913 return fmt.Errorf("expected HandshakeResourceValue to be of type string, got %T instead", value) 9914 } 9915 sv.Value = ptr.String(jtv) 9916 } 9917 9918 default: 9919 _, _ = key, value 9920 9921 } 9922 } 9923 *v = sv 9924 return nil 9925} 9926 9927func awsAwsjson11_deserializeDocumentHandshakeResources(v *[]types.HandshakeResource, value interface{}) error { 9928 if v == nil { 9929 return fmt.Errorf("unexpected nil of type %T", v) 9930 } 9931 if value == nil { 9932 return nil 9933 } 9934 9935 shape, ok := value.([]interface{}) 9936 if !ok { 9937 return fmt.Errorf("unexpected JSON type %v", value) 9938 } 9939 9940 var cv []types.HandshakeResource 9941 if *v == nil { 9942 cv = []types.HandshakeResource{} 9943 } else { 9944 cv = *v 9945 } 9946 9947 for _, value := range shape { 9948 var col types.HandshakeResource 9949 destAddr := &col 9950 if err := awsAwsjson11_deserializeDocumentHandshakeResource(&destAddr, value); err != nil { 9951 return err 9952 } 9953 col = *destAddr 9954 cv = append(cv, col) 9955 9956 } 9957 *v = cv 9958 return nil 9959} 9960 9961func awsAwsjson11_deserializeDocumentHandshakes(v *[]types.Handshake, value interface{}) error { 9962 if v == nil { 9963 return fmt.Errorf("unexpected nil of type %T", v) 9964 } 9965 if value == nil { 9966 return nil 9967 } 9968 9969 shape, ok := value.([]interface{}) 9970 if !ok { 9971 return fmt.Errorf("unexpected JSON type %v", value) 9972 } 9973 9974 var cv []types.Handshake 9975 if *v == nil { 9976 cv = []types.Handshake{} 9977 } else { 9978 cv = *v 9979 } 9980 9981 for _, value := range shape { 9982 var col types.Handshake 9983 destAddr := &col 9984 if err := awsAwsjson11_deserializeDocumentHandshake(&destAddr, value); err != nil { 9985 return err 9986 } 9987 col = *destAddr 9988 cv = append(cv, col) 9989 9990 } 9991 *v = cv 9992 return nil 9993} 9994 9995func awsAwsjson11_deserializeDocumentInvalidHandshakeTransitionException(v **types.InvalidHandshakeTransitionException, value interface{}) error { 9996 if v == nil { 9997 return fmt.Errorf("unexpected nil of type %T", v) 9998 } 9999 if value == nil { 10000 return nil 10001 } 10002 10003 shape, ok := value.(map[string]interface{}) 10004 if !ok { 10005 return fmt.Errorf("unexpected JSON type %v", value) 10006 } 10007 10008 var sv *types.InvalidHandshakeTransitionException 10009 if *v == nil { 10010 sv = &types.InvalidHandshakeTransitionException{} 10011 } else { 10012 sv = *v 10013 } 10014 10015 for key, value := range shape { 10016 switch key { 10017 case "Message": 10018 if value != nil { 10019 jtv, ok := value.(string) 10020 if !ok { 10021 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 10022 } 10023 sv.Message = ptr.String(jtv) 10024 } 10025 10026 default: 10027 _, _ = key, value 10028 10029 } 10030 } 10031 *v = sv 10032 return nil 10033} 10034 10035func awsAwsjson11_deserializeDocumentInvalidInputException(v **types.InvalidInputException, value interface{}) error { 10036 if v == nil { 10037 return fmt.Errorf("unexpected nil of type %T", v) 10038 } 10039 if value == nil { 10040 return nil 10041 } 10042 10043 shape, ok := value.(map[string]interface{}) 10044 if !ok { 10045 return fmt.Errorf("unexpected JSON type %v", value) 10046 } 10047 10048 var sv *types.InvalidInputException 10049 if *v == nil { 10050 sv = &types.InvalidInputException{} 10051 } else { 10052 sv = *v 10053 } 10054 10055 for key, value := range shape { 10056 switch key { 10057 case "Message": 10058 if value != nil { 10059 jtv, ok := value.(string) 10060 if !ok { 10061 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 10062 } 10063 sv.Message = ptr.String(jtv) 10064 } 10065 10066 case "Reason": 10067 if value != nil { 10068 jtv, ok := value.(string) 10069 if !ok { 10070 return fmt.Errorf("expected InvalidInputExceptionReason to be of type string, got %T instead", value) 10071 } 10072 sv.Reason = types.InvalidInputExceptionReason(jtv) 10073 } 10074 10075 default: 10076 _, _ = key, value 10077 10078 } 10079 } 10080 *v = sv 10081 return nil 10082} 10083 10084func awsAwsjson11_deserializeDocumentMalformedPolicyDocumentException(v **types.MalformedPolicyDocumentException, value interface{}) error { 10085 if v == nil { 10086 return fmt.Errorf("unexpected nil of type %T", v) 10087 } 10088 if value == nil { 10089 return nil 10090 } 10091 10092 shape, ok := value.(map[string]interface{}) 10093 if !ok { 10094 return fmt.Errorf("unexpected JSON type %v", value) 10095 } 10096 10097 var sv *types.MalformedPolicyDocumentException 10098 if *v == nil { 10099 sv = &types.MalformedPolicyDocumentException{} 10100 } else { 10101 sv = *v 10102 } 10103 10104 for key, value := range shape { 10105 switch key { 10106 case "Message": 10107 if value != nil { 10108 jtv, ok := value.(string) 10109 if !ok { 10110 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 10111 } 10112 sv.Message = ptr.String(jtv) 10113 } 10114 10115 default: 10116 _, _ = key, value 10117 10118 } 10119 } 10120 *v = sv 10121 return nil 10122} 10123 10124func awsAwsjson11_deserializeDocumentMasterCannotLeaveOrganizationException(v **types.MasterCannotLeaveOrganizationException, value interface{}) error { 10125 if v == nil { 10126 return fmt.Errorf("unexpected nil of type %T", v) 10127 } 10128 if value == nil { 10129 return nil 10130 } 10131 10132 shape, ok := value.(map[string]interface{}) 10133 if !ok { 10134 return fmt.Errorf("unexpected JSON type %v", value) 10135 } 10136 10137 var sv *types.MasterCannotLeaveOrganizationException 10138 if *v == nil { 10139 sv = &types.MasterCannotLeaveOrganizationException{} 10140 } else { 10141 sv = *v 10142 } 10143 10144 for key, value := range shape { 10145 switch key { 10146 case "Message": 10147 if value != nil { 10148 jtv, ok := value.(string) 10149 if !ok { 10150 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 10151 } 10152 sv.Message = ptr.String(jtv) 10153 } 10154 10155 default: 10156 _, _ = key, value 10157 10158 } 10159 } 10160 *v = sv 10161 return nil 10162} 10163 10164func awsAwsjson11_deserializeDocumentOrganization(v **types.Organization, value interface{}) error { 10165 if v == nil { 10166 return fmt.Errorf("unexpected nil of type %T", v) 10167 } 10168 if value == nil { 10169 return nil 10170 } 10171 10172 shape, ok := value.(map[string]interface{}) 10173 if !ok { 10174 return fmt.Errorf("unexpected JSON type %v", value) 10175 } 10176 10177 var sv *types.Organization 10178 if *v == nil { 10179 sv = &types.Organization{} 10180 } else { 10181 sv = *v 10182 } 10183 10184 for key, value := range shape { 10185 switch key { 10186 case "Arn": 10187 if value != nil { 10188 jtv, ok := value.(string) 10189 if !ok { 10190 return fmt.Errorf("expected OrganizationArn to be of type string, got %T instead", value) 10191 } 10192 sv.Arn = ptr.String(jtv) 10193 } 10194 10195 case "AvailablePolicyTypes": 10196 if err := awsAwsjson11_deserializeDocumentPolicyTypes(&sv.AvailablePolicyTypes, value); err != nil { 10197 return err 10198 } 10199 10200 case "FeatureSet": 10201 if value != nil { 10202 jtv, ok := value.(string) 10203 if !ok { 10204 return fmt.Errorf("expected OrganizationFeatureSet to be of type string, got %T instead", value) 10205 } 10206 sv.FeatureSet = types.OrganizationFeatureSet(jtv) 10207 } 10208 10209 case "Id": 10210 if value != nil { 10211 jtv, ok := value.(string) 10212 if !ok { 10213 return fmt.Errorf("expected OrganizationId to be of type string, got %T instead", value) 10214 } 10215 sv.Id = ptr.String(jtv) 10216 } 10217 10218 case "MasterAccountArn": 10219 if value != nil { 10220 jtv, ok := value.(string) 10221 if !ok { 10222 return fmt.Errorf("expected AccountArn to be of type string, got %T instead", value) 10223 } 10224 sv.MasterAccountArn = ptr.String(jtv) 10225 } 10226 10227 case "MasterAccountEmail": 10228 if value != nil { 10229 jtv, ok := value.(string) 10230 if !ok { 10231 return fmt.Errorf("expected Email to be of type string, got %T instead", value) 10232 } 10233 sv.MasterAccountEmail = ptr.String(jtv) 10234 } 10235 10236 case "MasterAccountId": 10237 if value != nil { 10238 jtv, ok := value.(string) 10239 if !ok { 10240 return fmt.Errorf("expected AccountId to be of type string, got %T instead", value) 10241 } 10242 sv.MasterAccountId = ptr.String(jtv) 10243 } 10244 10245 default: 10246 _, _ = key, value 10247 10248 } 10249 } 10250 *v = sv 10251 return nil 10252} 10253 10254func awsAwsjson11_deserializeDocumentOrganizationalUnit(v **types.OrganizationalUnit, value interface{}) error { 10255 if v == nil { 10256 return fmt.Errorf("unexpected nil of type %T", v) 10257 } 10258 if value == nil { 10259 return nil 10260 } 10261 10262 shape, ok := value.(map[string]interface{}) 10263 if !ok { 10264 return fmt.Errorf("unexpected JSON type %v", value) 10265 } 10266 10267 var sv *types.OrganizationalUnit 10268 if *v == nil { 10269 sv = &types.OrganizationalUnit{} 10270 } else { 10271 sv = *v 10272 } 10273 10274 for key, value := range shape { 10275 switch key { 10276 case "Arn": 10277 if value != nil { 10278 jtv, ok := value.(string) 10279 if !ok { 10280 return fmt.Errorf("expected OrganizationalUnitArn to be of type string, got %T instead", value) 10281 } 10282 sv.Arn = ptr.String(jtv) 10283 } 10284 10285 case "Id": 10286 if value != nil { 10287 jtv, ok := value.(string) 10288 if !ok { 10289 return fmt.Errorf("expected OrganizationalUnitId to be of type string, got %T instead", value) 10290 } 10291 sv.Id = ptr.String(jtv) 10292 } 10293 10294 case "Name": 10295 if value != nil { 10296 jtv, ok := value.(string) 10297 if !ok { 10298 return fmt.Errorf("expected OrganizationalUnitName to be of type string, got %T instead", value) 10299 } 10300 sv.Name = ptr.String(jtv) 10301 } 10302 10303 default: 10304 _, _ = key, value 10305 10306 } 10307 } 10308 *v = sv 10309 return nil 10310} 10311 10312func awsAwsjson11_deserializeDocumentOrganizationalUnitNotEmptyException(v **types.OrganizationalUnitNotEmptyException, value interface{}) error { 10313 if v == nil { 10314 return fmt.Errorf("unexpected nil of type %T", v) 10315 } 10316 if value == nil { 10317 return nil 10318 } 10319 10320 shape, ok := value.(map[string]interface{}) 10321 if !ok { 10322 return fmt.Errorf("unexpected JSON type %v", value) 10323 } 10324 10325 var sv *types.OrganizationalUnitNotEmptyException 10326 if *v == nil { 10327 sv = &types.OrganizationalUnitNotEmptyException{} 10328 } else { 10329 sv = *v 10330 } 10331 10332 for key, value := range shape { 10333 switch key { 10334 case "Message": 10335 if value != nil { 10336 jtv, ok := value.(string) 10337 if !ok { 10338 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 10339 } 10340 sv.Message = ptr.String(jtv) 10341 } 10342 10343 default: 10344 _, _ = key, value 10345 10346 } 10347 } 10348 *v = sv 10349 return nil 10350} 10351 10352func awsAwsjson11_deserializeDocumentOrganizationalUnitNotFoundException(v **types.OrganizationalUnitNotFoundException, value interface{}) error { 10353 if v == nil { 10354 return fmt.Errorf("unexpected nil of type %T", v) 10355 } 10356 if value == nil { 10357 return nil 10358 } 10359 10360 shape, ok := value.(map[string]interface{}) 10361 if !ok { 10362 return fmt.Errorf("unexpected JSON type %v", value) 10363 } 10364 10365 var sv *types.OrganizationalUnitNotFoundException 10366 if *v == nil { 10367 sv = &types.OrganizationalUnitNotFoundException{} 10368 } else { 10369 sv = *v 10370 } 10371 10372 for key, value := range shape { 10373 switch key { 10374 case "Message": 10375 if value != nil { 10376 jtv, ok := value.(string) 10377 if !ok { 10378 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 10379 } 10380 sv.Message = ptr.String(jtv) 10381 } 10382 10383 default: 10384 _, _ = key, value 10385 10386 } 10387 } 10388 *v = sv 10389 return nil 10390} 10391 10392func awsAwsjson11_deserializeDocumentOrganizationalUnits(v *[]types.OrganizationalUnit, value interface{}) error { 10393 if v == nil { 10394 return fmt.Errorf("unexpected nil of type %T", v) 10395 } 10396 if value == nil { 10397 return nil 10398 } 10399 10400 shape, ok := value.([]interface{}) 10401 if !ok { 10402 return fmt.Errorf("unexpected JSON type %v", value) 10403 } 10404 10405 var cv []types.OrganizationalUnit 10406 if *v == nil { 10407 cv = []types.OrganizationalUnit{} 10408 } else { 10409 cv = *v 10410 } 10411 10412 for _, value := range shape { 10413 var col types.OrganizationalUnit 10414 destAddr := &col 10415 if err := awsAwsjson11_deserializeDocumentOrganizationalUnit(&destAddr, value); err != nil { 10416 return err 10417 } 10418 col = *destAddr 10419 cv = append(cv, col) 10420 10421 } 10422 *v = cv 10423 return nil 10424} 10425 10426func awsAwsjson11_deserializeDocumentOrganizationNotEmptyException(v **types.OrganizationNotEmptyException, value interface{}) error { 10427 if v == nil { 10428 return fmt.Errorf("unexpected nil of type %T", v) 10429 } 10430 if value == nil { 10431 return nil 10432 } 10433 10434 shape, ok := value.(map[string]interface{}) 10435 if !ok { 10436 return fmt.Errorf("unexpected JSON type %v", value) 10437 } 10438 10439 var sv *types.OrganizationNotEmptyException 10440 if *v == nil { 10441 sv = &types.OrganizationNotEmptyException{} 10442 } else { 10443 sv = *v 10444 } 10445 10446 for key, value := range shape { 10447 switch key { 10448 case "Message": 10449 if value != nil { 10450 jtv, ok := value.(string) 10451 if !ok { 10452 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 10453 } 10454 sv.Message = ptr.String(jtv) 10455 } 10456 10457 default: 10458 _, _ = key, value 10459 10460 } 10461 } 10462 *v = sv 10463 return nil 10464} 10465 10466func awsAwsjson11_deserializeDocumentParent(v **types.Parent, value interface{}) error { 10467 if v == nil { 10468 return fmt.Errorf("unexpected nil of type %T", v) 10469 } 10470 if value == nil { 10471 return nil 10472 } 10473 10474 shape, ok := value.(map[string]interface{}) 10475 if !ok { 10476 return fmt.Errorf("unexpected JSON type %v", value) 10477 } 10478 10479 var sv *types.Parent 10480 if *v == nil { 10481 sv = &types.Parent{} 10482 } else { 10483 sv = *v 10484 } 10485 10486 for key, value := range shape { 10487 switch key { 10488 case "Id": 10489 if value != nil { 10490 jtv, ok := value.(string) 10491 if !ok { 10492 return fmt.Errorf("expected ParentId to be of type string, got %T instead", value) 10493 } 10494 sv.Id = ptr.String(jtv) 10495 } 10496 10497 case "Type": 10498 if value != nil { 10499 jtv, ok := value.(string) 10500 if !ok { 10501 return fmt.Errorf("expected ParentType to be of type string, got %T instead", value) 10502 } 10503 sv.Type = types.ParentType(jtv) 10504 } 10505 10506 default: 10507 _, _ = key, value 10508 10509 } 10510 } 10511 *v = sv 10512 return nil 10513} 10514 10515func awsAwsjson11_deserializeDocumentParentNotFoundException(v **types.ParentNotFoundException, value interface{}) error { 10516 if v == nil { 10517 return fmt.Errorf("unexpected nil of type %T", v) 10518 } 10519 if value == nil { 10520 return nil 10521 } 10522 10523 shape, ok := value.(map[string]interface{}) 10524 if !ok { 10525 return fmt.Errorf("unexpected JSON type %v", value) 10526 } 10527 10528 var sv *types.ParentNotFoundException 10529 if *v == nil { 10530 sv = &types.ParentNotFoundException{} 10531 } else { 10532 sv = *v 10533 } 10534 10535 for key, value := range shape { 10536 switch key { 10537 case "Message": 10538 if value != nil { 10539 jtv, ok := value.(string) 10540 if !ok { 10541 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 10542 } 10543 sv.Message = ptr.String(jtv) 10544 } 10545 10546 default: 10547 _, _ = key, value 10548 10549 } 10550 } 10551 *v = sv 10552 return nil 10553} 10554 10555func awsAwsjson11_deserializeDocumentParents(v *[]types.Parent, value interface{}) error { 10556 if v == nil { 10557 return fmt.Errorf("unexpected nil of type %T", v) 10558 } 10559 if value == nil { 10560 return nil 10561 } 10562 10563 shape, ok := value.([]interface{}) 10564 if !ok { 10565 return fmt.Errorf("unexpected JSON type %v", value) 10566 } 10567 10568 var cv []types.Parent 10569 if *v == nil { 10570 cv = []types.Parent{} 10571 } else { 10572 cv = *v 10573 } 10574 10575 for _, value := range shape { 10576 var col types.Parent 10577 destAddr := &col 10578 if err := awsAwsjson11_deserializeDocumentParent(&destAddr, value); err != nil { 10579 return err 10580 } 10581 col = *destAddr 10582 cv = append(cv, col) 10583 10584 } 10585 *v = cv 10586 return nil 10587} 10588 10589func awsAwsjson11_deserializeDocumentPolicies(v *[]types.PolicySummary, value interface{}) error { 10590 if v == nil { 10591 return fmt.Errorf("unexpected nil of type %T", v) 10592 } 10593 if value == nil { 10594 return nil 10595 } 10596 10597 shape, ok := value.([]interface{}) 10598 if !ok { 10599 return fmt.Errorf("unexpected JSON type %v", value) 10600 } 10601 10602 var cv []types.PolicySummary 10603 if *v == nil { 10604 cv = []types.PolicySummary{} 10605 } else { 10606 cv = *v 10607 } 10608 10609 for _, value := range shape { 10610 var col types.PolicySummary 10611 destAddr := &col 10612 if err := awsAwsjson11_deserializeDocumentPolicySummary(&destAddr, value); err != nil { 10613 return err 10614 } 10615 col = *destAddr 10616 cv = append(cv, col) 10617 10618 } 10619 *v = cv 10620 return nil 10621} 10622 10623func awsAwsjson11_deserializeDocumentPolicy(v **types.Policy, value interface{}) error { 10624 if v == nil { 10625 return fmt.Errorf("unexpected nil of type %T", v) 10626 } 10627 if value == nil { 10628 return nil 10629 } 10630 10631 shape, ok := value.(map[string]interface{}) 10632 if !ok { 10633 return fmt.Errorf("unexpected JSON type %v", value) 10634 } 10635 10636 var sv *types.Policy 10637 if *v == nil { 10638 sv = &types.Policy{} 10639 } else { 10640 sv = *v 10641 } 10642 10643 for key, value := range shape { 10644 switch key { 10645 case "Content": 10646 if value != nil { 10647 jtv, ok := value.(string) 10648 if !ok { 10649 return fmt.Errorf("expected PolicyContent to be of type string, got %T instead", value) 10650 } 10651 sv.Content = ptr.String(jtv) 10652 } 10653 10654 case "PolicySummary": 10655 if err := awsAwsjson11_deserializeDocumentPolicySummary(&sv.PolicySummary, value); err != nil { 10656 return err 10657 } 10658 10659 default: 10660 _, _ = key, value 10661 10662 } 10663 } 10664 *v = sv 10665 return nil 10666} 10667 10668func awsAwsjson11_deserializeDocumentPolicyChangesInProgressException(v **types.PolicyChangesInProgressException, value interface{}) error { 10669 if v == nil { 10670 return fmt.Errorf("unexpected nil of type %T", v) 10671 } 10672 if value == nil { 10673 return nil 10674 } 10675 10676 shape, ok := value.(map[string]interface{}) 10677 if !ok { 10678 return fmt.Errorf("unexpected JSON type %v", value) 10679 } 10680 10681 var sv *types.PolicyChangesInProgressException 10682 if *v == nil { 10683 sv = &types.PolicyChangesInProgressException{} 10684 } else { 10685 sv = *v 10686 } 10687 10688 for key, value := range shape { 10689 switch key { 10690 case "Message": 10691 if value != nil { 10692 jtv, ok := value.(string) 10693 if !ok { 10694 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 10695 } 10696 sv.Message = ptr.String(jtv) 10697 } 10698 10699 default: 10700 _, _ = key, value 10701 10702 } 10703 } 10704 *v = sv 10705 return nil 10706} 10707 10708func awsAwsjson11_deserializeDocumentPolicyInUseException(v **types.PolicyInUseException, value interface{}) error { 10709 if v == nil { 10710 return fmt.Errorf("unexpected nil of type %T", v) 10711 } 10712 if value == nil { 10713 return nil 10714 } 10715 10716 shape, ok := value.(map[string]interface{}) 10717 if !ok { 10718 return fmt.Errorf("unexpected JSON type %v", value) 10719 } 10720 10721 var sv *types.PolicyInUseException 10722 if *v == nil { 10723 sv = &types.PolicyInUseException{} 10724 } else { 10725 sv = *v 10726 } 10727 10728 for key, value := range shape { 10729 switch key { 10730 case "Message": 10731 if value != nil { 10732 jtv, ok := value.(string) 10733 if !ok { 10734 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 10735 } 10736 sv.Message = ptr.String(jtv) 10737 } 10738 10739 default: 10740 _, _ = key, value 10741 10742 } 10743 } 10744 *v = sv 10745 return nil 10746} 10747 10748func awsAwsjson11_deserializeDocumentPolicyNotAttachedException(v **types.PolicyNotAttachedException, value interface{}) error { 10749 if v == nil { 10750 return fmt.Errorf("unexpected nil of type %T", v) 10751 } 10752 if value == nil { 10753 return nil 10754 } 10755 10756 shape, ok := value.(map[string]interface{}) 10757 if !ok { 10758 return fmt.Errorf("unexpected JSON type %v", value) 10759 } 10760 10761 var sv *types.PolicyNotAttachedException 10762 if *v == nil { 10763 sv = &types.PolicyNotAttachedException{} 10764 } else { 10765 sv = *v 10766 } 10767 10768 for key, value := range shape { 10769 switch key { 10770 case "Message": 10771 if value != nil { 10772 jtv, ok := value.(string) 10773 if !ok { 10774 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 10775 } 10776 sv.Message = ptr.String(jtv) 10777 } 10778 10779 default: 10780 _, _ = key, value 10781 10782 } 10783 } 10784 *v = sv 10785 return nil 10786} 10787 10788func awsAwsjson11_deserializeDocumentPolicyNotFoundException(v **types.PolicyNotFoundException, value interface{}) error { 10789 if v == nil { 10790 return fmt.Errorf("unexpected nil of type %T", v) 10791 } 10792 if value == nil { 10793 return nil 10794 } 10795 10796 shape, ok := value.(map[string]interface{}) 10797 if !ok { 10798 return fmt.Errorf("unexpected JSON type %v", value) 10799 } 10800 10801 var sv *types.PolicyNotFoundException 10802 if *v == nil { 10803 sv = &types.PolicyNotFoundException{} 10804 } else { 10805 sv = *v 10806 } 10807 10808 for key, value := range shape { 10809 switch key { 10810 case "Message": 10811 if value != nil { 10812 jtv, ok := value.(string) 10813 if !ok { 10814 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 10815 } 10816 sv.Message = ptr.String(jtv) 10817 } 10818 10819 default: 10820 _, _ = key, value 10821 10822 } 10823 } 10824 *v = sv 10825 return nil 10826} 10827 10828func awsAwsjson11_deserializeDocumentPolicySummary(v **types.PolicySummary, value interface{}) error { 10829 if v == nil { 10830 return fmt.Errorf("unexpected nil of type %T", v) 10831 } 10832 if value == nil { 10833 return nil 10834 } 10835 10836 shape, ok := value.(map[string]interface{}) 10837 if !ok { 10838 return fmt.Errorf("unexpected JSON type %v", value) 10839 } 10840 10841 var sv *types.PolicySummary 10842 if *v == nil { 10843 sv = &types.PolicySummary{} 10844 } else { 10845 sv = *v 10846 } 10847 10848 for key, value := range shape { 10849 switch key { 10850 case "Arn": 10851 if value != nil { 10852 jtv, ok := value.(string) 10853 if !ok { 10854 return fmt.Errorf("expected PolicyArn to be of type string, got %T instead", value) 10855 } 10856 sv.Arn = ptr.String(jtv) 10857 } 10858 10859 case "AwsManaged": 10860 if value != nil { 10861 jtv, ok := value.(bool) 10862 if !ok { 10863 return fmt.Errorf("expected AwsManagedPolicy to be of type *bool, got %T instead", value) 10864 } 10865 sv.AwsManaged = jtv 10866 } 10867 10868 case "Description": 10869 if value != nil { 10870 jtv, ok := value.(string) 10871 if !ok { 10872 return fmt.Errorf("expected PolicyDescription to be of type string, got %T instead", value) 10873 } 10874 sv.Description = ptr.String(jtv) 10875 } 10876 10877 case "Id": 10878 if value != nil { 10879 jtv, ok := value.(string) 10880 if !ok { 10881 return fmt.Errorf("expected PolicyId to be of type string, got %T instead", value) 10882 } 10883 sv.Id = ptr.String(jtv) 10884 } 10885 10886 case "Name": 10887 if value != nil { 10888 jtv, ok := value.(string) 10889 if !ok { 10890 return fmt.Errorf("expected PolicyName to be of type string, got %T instead", value) 10891 } 10892 sv.Name = ptr.String(jtv) 10893 } 10894 10895 case "Type": 10896 if value != nil { 10897 jtv, ok := value.(string) 10898 if !ok { 10899 return fmt.Errorf("expected PolicyType to be of type string, got %T instead", value) 10900 } 10901 sv.Type = types.PolicyType(jtv) 10902 } 10903 10904 default: 10905 _, _ = key, value 10906 10907 } 10908 } 10909 *v = sv 10910 return nil 10911} 10912 10913func awsAwsjson11_deserializeDocumentPolicyTargets(v *[]types.PolicyTargetSummary, value interface{}) error { 10914 if v == nil { 10915 return fmt.Errorf("unexpected nil of type %T", v) 10916 } 10917 if value == nil { 10918 return nil 10919 } 10920 10921 shape, ok := value.([]interface{}) 10922 if !ok { 10923 return fmt.Errorf("unexpected JSON type %v", value) 10924 } 10925 10926 var cv []types.PolicyTargetSummary 10927 if *v == nil { 10928 cv = []types.PolicyTargetSummary{} 10929 } else { 10930 cv = *v 10931 } 10932 10933 for _, value := range shape { 10934 var col types.PolicyTargetSummary 10935 destAddr := &col 10936 if err := awsAwsjson11_deserializeDocumentPolicyTargetSummary(&destAddr, value); err != nil { 10937 return err 10938 } 10939 col = *destAddr 10940 cv = append(cv, col) 10941 10942 } 10943 *v = cv 10944 return nil 10945} 10946 10947func awsAwsjson11_deserializeDocumentPolicyTargetSummary(v **types.PolicyTargetSummary, value interface{}) error { 10948 if v == nil { 10949 return fmt.Errorf("unexpected nil of type %T", v) 10950 } 10951 if value == nil { 10952 return nil 10953 } 10954 10955 shape, ok := value.(map[string]interface{}) 10956 if !ok { 10957 return fmt.Errorf("unexpected JSON type %v", value) 10958 } 10959 10960 var sv *types.PolicyTargetSummary 10961 if *v == nil { 10962 sv = &types.PolicyTargetSummary{} 10963 } else { 10964 sv = *v 10965 } 10966 10967 for key, value := range shape { 10968 switch key { 10969 case "Arn": 10970 if value != nil { 10971 jtv, ok := value.(string) 10972 if !ok { 10973 return fmt.Errorf("expected GenericArn to be of type string, got %T instead", value) 10974 } 10975 sv.Arn = ptr.String(jtv) 10976 } 10977 10978 case "Name": 10979 if value != nil { 10980 jtv, ok := value.(string) 10981 if !ok { 10982 return fmt.Errorf("expected TargetName to be of type string, got %T instead", value) 10983 } 10984 sv.Name = ptr.String(jtv) 10985 } 10986 10987 case "TargetId": 10988 if value != nil { 10989 jtv, ok := value.(string) 10990 if !ok { 10991 return fmt.Errorf("expected PolicyTargetId to be of type string, got %T instead", value) 10992 } 10993 sv.TargetId = ptr.String(jtv) 10994 } 10995 10996 case "Type": 10997 if value != nil { 10998 jtv, ok := value.(string) 10999 if !ok { 11000 return fmt.Errorf("expected TargetType to be of type string, got %T instead", value) 11001 } 11002 sv.Type = types.TargetType(jtv) 11003 } 11004 11005 default: 11006 _, _ = key, value 11007 11008 } 11009 } 11010 *v = sv 11011 return nil 11012} 11013 11014func awsAwsjson11_deserializeDocumentPolicyTypeAlreadyEnabledException(v **types.PolicyTypeAlreadyEnabledException, value interface{}) error { 11015 if v == nil { 11016 return fmt.Errorf("unexpected nil of type %T", v) 11017 } 11018 if value == nil { 11019 return nil 11020 } 11021 11022 shape, ok := value.(map[string]interface{}) 11023 if !ok { 11024 return fmt.Errorf("unexpected JSON type %v", value) 11025 } 11026 11027 var sv *types.PolicyTypeAlreadyEnabledException 11028 if *v == nil { 11029 sv = &types.PolicyTypeAlreadyEnabledException{} 11030 } else { 11031 sv = *v 11032 } 11033 11034 for key, value := range shape { 11035 switch key { 11036 case "Message": 11037 if value != nil { 11038 jtv, ok := value.(string) 11039 if !ok { 11040 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 11041 } 11042 sv.Message = ptr.String(jtv) 11043 } 11044 11045 default: 11046 _, _ = key, value 11047 11048 } 11049 } 11050 *v = sv 11051 return nil 11052} 11053 11054func awsAwsjson11_deserializeDocumentPolicyTypeNotAvailableForOrganizationException(v **types.PolicyTypeNotAvailableForOrganizationException, value interface{}) error { 11055 if v == nil { 11056 return fmt.Errorf("unexpected nil of type %T", v) 11057 } 11058 if value == nil { 11059 return nil 11060 } 11061 11062 shape, ok := value.(map[string]interface{}) 11063 if !ok { 11064 return fmt.Errorf("unexpected JSON type %v", value) 11065 } 11066 11067 var sv *types.PolicyTypeNotAvailableForOrganizationException 11068 if *v == nil { 11069 sv = &types.PolicyTypeNotAvailableForOrganizationException{} 11070 } else { 11071 sv = *v 11072 } 11073 11074 for key, value := range shape { 11075 switch key { 11076 case "Message": 11077 if value != nil { 11078 jtv, ok := value.(string) 11079 if !ok { 11080 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 11081 } 11082 sv.Message = ptr.String(jtv) 11083 } 11084 11085 default: 11086 _, _ = key, value 11087 11088 } 11089 } 11090 *v = sv 11091 return nil 11092} 11093 11094func awsAwsjson11_deserializeDocumentPolicyTypeNotEnabledException(v **types.PolicyTypeNotEnabledException, value interface{}) error { 11095 if v == nil { 11096 return fmt.Errorf("unexpected nil of type %T", v) 11097 } 11098 if value == nil { 11099 return nil 11100 } 11101 11102 shape, ok := value.(map[string]interface{}) 11103 if !ok { 11104 return fmt.Errorf("unexpected JSON type %v", value) 11105 } 11106 11107 var sv *types.PolicyTypeNotEnabledException 11108 if *v == nil { 11109 sv = &types.PolicyTypeNotEnabledException{} 11110 } else { 11111 sv = *v 11112 } 11113 11114 for key, value := range shape { 11115 switch key { 11116 case "Message": 11117 if value != nil { 11118 jtv, ok := value.(string) 11119 if !ok { 11120 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 11121 } 11122 sv.Message = ptr.String(jtv) 11123 } 11124 11125 default: 11126 _, _ = key, value 11127 11128 } 11129 } 11130 *v = sv 11131 return nil 11132} 11133 11134func awsAwsjson11_deserializeDocumentPolicyTypes(v *[]types.PolicyTypeSummary, value interface{}) error { 11135 if v == nil { 11136 return fmt.Errorf("unexpected nil of type %T", v) 11137 } 11138 if value == nil { 11139 return nil 11140 } 11141 11142 shape, ok := value.([]interface{}) 11143 if !ok { 11144 return fmt.Errorf("unexpected JSON type %v", value) 11145 } 11146 11147 var cv []types.PolicyTypeSummary 11148 if *v == nil { 11149 cv = []types.PolicyTypeSummary{} 11150 } else { 11151 cv = *v 11152 } 11153 11154 for _, value := range shape { 11155 var col types.PolicyTypeSummary 11156 destAddr := &col 11157 if err := awsAwsjson11_deserializeDocumentPolicyTypeSummary(&destAddr, value); err != nil { 11158 return err 11159 } 11160 col = *destAddr 11161 cv = append(cv, col) 11162 11163 } 11164 *v = cv 11165 return nil 11166} 11167 11168func awsAwsjson11_deserializeDocumentPolicyTypeSummary(v **types.PolicyTypeSummary, value interface{}) error { 11169 if v == nil { 11170 return fmt.Errorf("unexpected nil of type %T", v) 11171 } 11172 if value == nil { 11173 return nil 11174 } 11175 11176 shape, ok := value.(map[string]interface{}) 11177 if !ok { 11178 return fmt.Errorf("unexpected JSON type %v", value) 11179 } 11180 11181 var sv *types.PolicyTypeSummary 11182 if *v == nil { 11183 sv = &types.PolicyTypeSummary{} 11184 } else { 11185 sv = *v 11186 } 11187 11188 for key, value := range shape { 11189 switch key { 11190 case "Status": 11191 if value != nil { 11192 jtv, ok := value.(string) 11193 if !ok { 11194 return fmt.Errorf("expected PolicyTypeStatus to be of type string, got %T instead", value) 11195 } 11196 sv.Status = types.PolicyTypeStatus(jtv) 11197 } 11198 11199 case "Type": 11200 if value != nil { 11201 jtv, ok := value.(string) 11202 if !ok { 11203 return fmt.Errorf("expected PolicyType to be of type string, got %T instead", value) 11204 } 11205 sv.Type = types.PolicyType(jtv) 11206 } 11207 11208 default: 11209 _, _ = key, value 11210 11211 } 11212 } 11213 *v = sv 11214 return nil 11215} 11216 11217func awsAwsjson11_deserializeDocumentRoot(v **types.Root, value interface{}) error { 11218 if v == nil { 11219 return fmt.Errorf("unexpected nil of type %T", v) 11220 } 11221 if value == nil { 11222 return nil 11223 } 11224 11225 shape, ok := value.(map[string]interface{}) 11226 if !ok { 11227 return fmt.Errorf("unexpected JSON type %v", value) 11228 } 11229 11230 var sv *types.Root 11231 if *v == nil { 11232 sv = &types.Root{} 11233 } else { 11234 sv = *v 11235 } 11236 11237 for key, value := range shape { 11238 switch key { 11239 case "Arn": 11240 if value != nil { 11241 jtv, ok := value.(string) 11242 if !ok { 11243 return fmt.Errorf("expected RootArn to be of type string, got %T instead", value) 11244 } 11245 sv.Arn = ptr.String(jtv) 11246 } 11247 11248 case "Id": 11249 if value != nil { 11250 jtv, ok := value.(string) 11251 if !ok { 11252 return fmt.Errorf("expected RootId to be of type string, got %T instead", value) 11253 } 11254 sv.Id = ptr.String(jtv) 11255 } 11256 11257 case "Name": 11258 if value != nil { 11259 jtv, ok := value.(string) 11260 if !ok { 11261 return fmt.Errorf("expected RootName to be of type string, got %T instead", value) 11262 } 11263 sv.Name = ptr.String(jtv) 11264 } 11265 11266 case "PolicyTypes": 11267 if err := awsAwsjson11_deserializeDocumentPolicyTypes(&sv.PolicyTypes, value); err != nil { 11268 return err 11269 } 11270 11271 default: 11272 _, _ = key, value 11273 11274 } 11275 } 11276 *v = sv 11277 return nil 11278} 11279 11280func awsAwsjson11_deserializeDocumentRootNotFoundException(v **types.RootNotFoundException, value interface{}) error { 11281 if v == nil { 11282 return fmt.Errorf("unexpected nil of type %T", v) 11283 } 11284 if value == nil { 11285 return nil 11286 } 11287 11288 shape, ok := value.(map[string]interface{}) 11289 if !ok { 11290 return fmt.Errorf("unexpected JSON type %v", value) 11291 } 11292 11293 var sv *types.RootNotFoundException 11294 if *v == nil { 11295 sv = &types.RootNotFoundException{} 11296 } else { 11297 sv = *v 11298 } 11299 11300 for key, value := range shape { 11301 switch key { 11302 case "Message": 11303 if value != nil { 11304 jtv, ok := value.(string) 11305 if !ok { 11306 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 11307 } 11308 sv.Message = ptr.String(jtv) 11309 } 11310 11311 default: 11312 _, _ = key, value 11313 11314 } 11315 } 11316 *v = sv 11317 return nil 11318} 11319 11320func awsAwsjson11_deserializeDocumentRoots(v *[]types.Root, value interface{}) error { 11321 if v == nil { 11322 return fmt.Errorf("unexpected nil of type %T", v) 11323 } 11324 if value == nil { 11325 return nil 11326 } 11327 11328 shape, ok := value.([]interface{}) 11329 if !ok { 11330 return fmt.Errorf("unexpected JSON type %v", value) 11331 } 11332 11333 var cv []types.Root 11334 if *v == nil { 11335 cv = []types.Root{} 11336 } else { 11337 cv = *v 11338 } 11339 11340 for _, value := range shape { 11341 var col types.Root 11342 destAddr := &col 11343 if err := awsAwsjson11_deserializeDocumentRoot(&destAddr, value); err != nil { 11344 return err 11345 } 11346 col = *destAddr 11347 cv = append(cv, col) 11348 11349 } 11350 *v = cv 11351 return nil 11352} 11353 11354func awsAwsjson11_deserializeDocumentServiceException(v **types.ServiceException, value interface{}) error { 11355 if v == nil { 11356 return fmt.Errorf("unexpected nil of type %T", v) 11357 } 11358 if value == nil { 11359 return nil 11360 } 11361 11362 shape, ok := value.(map[string]interface{}) 11363 if !ok { 11364 return fmt.Errorf("unexpected JSON type %v", value) 11365 } 11366 11367 var sv *types.ServiceException 11368 if *v == nil { 11369 sv = &types.ServiceException{} 11370 } else { 11371 sv = *v 11372 } 11373 11374 for key, value := range shape { 11375 switch key { 11376 case "Message": 11377 if value != nil { 11378 jtv, ok := value.(string) 11379 if !ok { 11380 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 11381 } 11382 sv.Message = ptr.String(jtv) 11383 } 11384 11385 default: 11386 _, _ = key, value 11387 11388 } 11389 } 11390 *v = sv 11391 return nil 11392} 11393 11394func awsAwsjson11_deserializeDocumentSourceParentNotFoundException(v **types.SourceParentNotFoundException, value interface{}) error { 11395 if v == nil { 11396 return fmt.Errorf("unexpected nil of type %T", v) 11397 } 11398 if value == nil { 11399 return nil 11400 } 11401 11402 shape, ok := value.(map[string]interface{}) 11403 if !ok { 11404 return fmt.Errorf("unexpected JSON type %v", value) 11405 } 11406 11407 var sv *types.SourceParentNotFoundException 11408 if *v == nil { 11409 sv = &types.SourceParentNotFoundException{} 11410 } else { 11411 sv = *v 11412 } 11413 11414 for key, value := range shape { 11415 switch key { 11416 case "Message": 11417 if value != nil { 11418 jtv, ok := value.(string) 11419 if !ok { 11420 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 11421 } 11422 sv.Message = ptr.String(jtv) 11423 } 11424 11425 default: 11426 _, _ = key, value 11427 11428 } 11429 } 11430 *v = sv 11431 return nil 11432} 11433 11434func awsAwsjson11_deserializeDocumentTag(v **types.Tag, value interface{}) error { 11435 if v == nil { 11436 return fmt.Errorf("unexpected nil of type %T", v) 11437 } 11438 if value == nil { 11439 return nil 11440 } 11441 11442 shape, ok := value.(map[string]interface{}) 11443 if !ok { 11444 return fmt.Errorf("unexpected JSON type %v", value) 11445 } 11446 11447 var sv *types.Tag 11448 if *v == nil { 11449 sv = &types.Tag{} 11450 } else { 11451 sv = *v 11452 } 11453 11454 for key, value := range shape { 11455 switch key { 11456 case "Key": 11457 if value != nil { 11458 jtv, ok := value.(string) 11459 if !ok { 11460 return fmt.Errorf("expected TagKey to be of type string, got %T instead", value) 11461 } 11462 sv.Key = ptr.String(jtv) 11463 } 11464 11465 case "Value": 11466 if value != nil { 11467 jtv, ok := value.(string) 11468 if !ok { 11469 return fmt.Errorf("expected TagValue to be of type string, got %T instead", value) 11470 } 11471 sv.Value = ptr.String(jtv) 11472 } 11473 11474 default: 11475 _, _ = key, value 11476 11477 } 11478 } 11479 *v = sv 11480 return nil 11481} 11482 11483func awsAwsjson11_deserializeDocumentTags(v *[]types.Tag, value interface{}) error { 11484 if v == nil { 11485 return fmt.Errorf("unexpected nil of type %T", v) 11486 } 11487 if value == nil { 11488 return nil 11489 } 11490 11491 shape, ok := value.([]interface{}) 11492 if !ok { 11493 return fmt.Errorf("unexpected JSON type %v", value) 11494 } 11495 11496 var cv []types.Tag 11497 if *v == nil { 11498 cv = []types.Tag{} 11499 } else { 11500 cv = *v 11501 } 11502 11503 for _, value := range shape { 11504 var col types.Tag 11505 destAddr := &col 11506 if err := awsAwsjson11_deserializeDocumentTag(&destAddr, value); err != nil { 11507 return err 11508 } 11509 col = *destAddr 11510 cv = append(cv, col) 11511 11512 } 11513 *v = cv 11514 return nil 11515} 11516 11517func awsAwsjson11_deserializeDocumentTargetNotFoundException(v **types.TargetNotFoundException, value interface{}) error { 11518 if v == nil { 11519 return fmt.Errorf("unexpected nil of type %T", v) 11520 } 11521 if value == nil { 11522 return nil 11523 } 11524 11525 shape, ok := value.(map[string]interface{}) 11526 if !ok { 11527 return fmt.Errorf("unexpected JSON type %v", value) 11528 } 11529 11530 var sv *types.TargetNotFoundException 11531 if *v == nil { 11532 sv = &types.TargetNotFoundException{} 11533 } else { 11534 sv = *v 11535 } 11536 11537 for key, value := range shape { 11538 switch key { 11539 case "Message": 11540 if value != nil { 11541 jtv, ok := value.(string) 11542 if !ok { 11543 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 11544 } 11545 sv.Message = ptr.String(jtv) 11546 } 11547 11548 default: 11549 _, _ = key, value 11550 11551 } 11552 } 11553 *v = sv 11554 return nil 11555} 11556 11557func awsAwsjson11_deserializeDocumentTooManyRequestsException(v **types.TooManyRequestsException, value interface{}) error { 11558 if v == nil { 11559 return fmt.Errorf("unexpected nil of type %T", v) 11560 } 11561 if value == nil { 11562 return nil 11563 } 11564 11565 shape, ok := value.(map[string]interface{}) 11566 if !ok { 11567 return fmt.Errorf("unexpected JSON type %v", value) 11568 } 11569 11570 var sv *types.TooManyRequestsException 11571 if *v == nil { 11572 sv = &types.TooManyRequestsException{} 11573 } else { 11574 sv = *v 11575 } 11576 11577 for key, value := range shape { 11578 switch key { 11579 case "Message": 11580 if value != nil { 11581 jtv, ok := value.(string) 11582 if !ok { 11583 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 11584 } 11585 sv.Message = ptr.String(jtv) 11586 } 11587 11588 case "Type": 11589 if value != nil { 11590 jtv, ok := value.(string) 11591 if !ok { 11592 return fmt.Errorf("expected ExceptionType to be of type string, got %T instead", value) 11593 } 11594 sv.Type = ptr.String(jtv) 11595 } 11596 11597 default: 11598 _, _ = key, value 11599 11600 } 11601 } 11602 *v = sv 11603 return nil 11604} 11605 11606func awsAwsjson11_deserializeDocumentUnsupportedAPIEndpointException(v **types.UnsupportedAPIEndpointException, value interface{}) error { 11607 if v == nil { 11608 return fmt.Errorf("unexpected nil of type %T", v) 11609 } 11610 if value == nil { 11611 return nil 11612 } 11613 11614 shape, ok := value.(map[string]interface{}) 11615 if !ok { 11616 return fmt.Errorf("unexpected JSON type %v", value) 11617 } 11618 11619 var sv *types.UnsupportedAPIEndpointException 11620 if *v == nil { 11621 sv = &types.UnsupportedAPIEndpointException{} 11622 } else { 11623 sv = *v 11624 } 11625 11626 for key, value := range shape { 11627 switch key { 11628 case "Message": 11629 if value != nil { 11630 jtv, ok := value.(string) 11631 if !ok { 11632 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 11633 } 11634 sv.Message = ptr.String(jtv) 11635 } 11636 11637 default: 11638 _, _ = key, value 11639 11640 } 11641 } 11642 *v = sv 11643 return nil 11644} 11645 11646func awsAwsjson11_deserializeOpDocumentAcceptHandshakeOutput(v **AcceptHandshakeOutput, value interface{}) error { 11647 if v == nil { 11648 return fmt.Errorf("unexpected nil of type %T", v) 11649 } 11650 if value == nil { 11651 return nil 11652 } 11653 11654 shape, ok := value.(map[string]interface{}) 11655 if !ok { 11656 return fmt.Errorf("unexpected JSON type %v", value) 11657 } 11658 11659 var sv *AcceptHandshakeOutput 11660 if *v == nil { 11661 sv = &AcceptHandshakeOutput{} 11662 } else { 11663 sv = *v 11664 } 11665 11666 for key, value := range shape { 11667 switch key { 11668 case "Handshake": 11669 if err := awsAwsjson11_deserializeDocumentHandshake(&sv.Handshake, value); err != nil { 11670 return err 11671 } 11672 11673 default: 11674 _, _ = key, value 11675 11676 } 11677 } 11678 *v = sv 11679 return nil 11680} 11681 11682func awsAwsjson11_deserializeOpDocumentCancelHandshakeOutput(v **CancelHandshakeOutput, value interface{}) error { 11683 if v == nil { 11684 return fmt.Errorf("unexpected nil of type %T", v) 11685 } 11686 if value == nil { 11687 return nil 11688 } 11689 11690 shape, ok := value.(map[string]interface{}) 11691 if !ok { 11692 return fmt.Errorf("unexpected JSON type %v", value) 11693 } 11694 11695 var sv *CancelHandshakeOutput 11696 if *v == nil { 11697 sv = &CancelHandshakeOutput{} 11698 } else { 11699 sv = *v 11700 } 11701 11702 for key, value := range shape { 11703 switch key { 11704 case "Handshake": 11705 if err := awsAwsjson11_deserializeDocumentHandshake(&sv.Handshake, value); err != nil { 11706 return err 11707 } 11708 11709 default: 11710 _, _ = key, value 11711 11712 } 11713 } 11714 *v = sv 11715 return nil 11716} 11717 11718func awsAwsjson11_deserializeOpDocumentCreateAccountOutput(v **CreateAccountOutput, value interface{}) error { 11719 if v == nil { 11720 return fmt.Errorf("unexpected nil of type %T", v) 11721 } 11722 if value == nil { 11723 return nil 11724 } 11725 11726 shape, ok := value.(map[string]interface{}) 11727 if !ok { 11728 return fmt.Errorf("unexpected JSON type %v", value) 11729 } 11730 11731 var sv *CreateAccountOutput 11732 if *v == nil { 11733 sv = &CreateAccountOutput{} 11734 } else { 11735 sv = *v 11736 } 11737 11738 for key, value := range shape { 11739 switch key { 11740 case "CreateAccountStatus": 11741 if err := awsAwsjson11_deserializeDocumentCreateAccountStatus(&sv.CreateAccountStatus, value); err != nil { 11742 return err 11743 } 11744 11745 default: 11746 _, _ = key, value 11747 11748 } 11749 } 11750 *v = sv 11751 return nil 11752} 11753 11754func awsAwsjson11_deserializeOpDocumentCreateGovCloudAccountOutput(v **CreateGovCloudAccountOutput, value interface{}) error { 11755 if v == nil { 11756 return fmt.Errorf("unexpected nil of type %T", v) 11757 } 11758 if value == nil { 11759 return nil 11760 } 11761 11762 shape, ok := value.(map[string]interface{}) 11763 if !ok { 11764 return fmt.Errorf("unexpected JSON type %v", value) 11765 } 11766 11767 var sv *CreateGovCloudAccountOutput 11768 if *v == nil { 11769 sv = &CreateGovCloudAccountOutput{} 11770 } else { 11771 sv = *v 11772 } 11773 11774 for key, value := range shape { 11775 switch key { 11776 case "CreateAccountStatus": 11777 if err := awsAwsjson11_deserializeDocumentCreateAccountStatus(&sv.CreateAccountStatus, value); err != nil { 11778 return err 11779 } 11780 11781 default: 11782 _, _ = key, value 11783 11784 } 11785 } 11786 *v = sv 11787 return nil 11788} 11789 11790func awsAwsjson11_deserializeOpDocumentCreateOrganizationalUnitOutput(v **CreateOrganizationalUnitOutput, value interface{}) error { 11791 if v == nil { 11792 return fmt.Errorf("unexpected nil of type %T", v) 11793 } 11794 if value == nil { 11795 return nil 11796 } 11797 11798 shape, ok := value.(map[string]interface{}) 11799 if !ok { 11800 return fmt.Errorf("unexpected JSON type %v", value) 11801 } 11802 11803 var sv *CreateOrganizationalUnitOutput 11804 if *v == nil { 11805 sv = &CreateOrganizationalUnitOutput{} 11806 } else { 11807 sv = *v 11808 } 11809 11810 for key, value := range shape { 11811 switch key { 11812 case "OrganizationalUnit": 11813 if err := awsAwsjson11_deserializeDocumentOrganizationalUnit(&sv.OrganizationalUnit, value); err != nil { 11814 return err 11815 } 11816 11817 default: 11818 _, _ = key, value 11819 11820 } 11821 } 11822 *v = sv 11823 return nil 11824} 11825 11826func awsAwsjson11_deserializeOpDocumentCreateOrganizationOutput(v **CreateOrganizationOutput, value interface{}) error { 11827 if v == nil { 11828 return fmt.Errorf("unexpected nil of type %T", v) 11829 } 11830 if value == nil { 11831 return nil 11832 } 11833 11834 shape, ok := value.(map[string]interface{}) 11835 if !ok { 11836 return fmt.Errorf("unexpected JSON type %v", value) 11837 } 11838 11839 var sv *CreateOrganizationOutput 11840 if *v == nil { 11841 sv = &CreateOrganizationOutput{} 11842 } else { 11843 sv = *v 11844 } 11845 11846 for key, value := range shape { 11847 switch key { 11848 case "Organization": 11849 if err := awsAwsjson11_deserializeDocumentOrganization(&sv.Organization, value); err != nil { 11850 return err 11851 } 11852 11853 default: 11854 _, _ = key, value 11855 11856 } 11857 } 11858 *v = sv 11859 return nil 11860} 11861 11862func awsAwsjson11_deserializeOpDocumentCreatePolicyOutput(v **CreatePolicyOutput, value interface{}) error { 11863 if v == nil { 11864 return fmt.Errorf("unexpected nil of type %T", v) 11865 } 11866 if value == nil { 11867 return nil 11868 } 11869 11870 shape, ok := value.(map[string]interface{}) 11871 if !ok { 11872 return fmt.Errorf("unexpected JSON type %v", value) 11873 } 11874 11875 var sv *CreatePolicyOutput 11876 if *v == nil { 11877 sv = &CreatePolicyOutput{} 11878 } else { 11879 sv = *v 11880 } 11881 11882 for key, value := range shape { 11883 switch key { 11884 case "Policy": 11885 if err := awsAwsjson11_deserializeDocumentPolicy(&sv.Policy, value); err != nil { 11886 return err 11887 } 11888 11889 default: 11890 _, _ = key, value 11891 11892 } 11893 } 11894 *v = sv 11895 return nil 11896} 11897 11898func awsAwsjson11_deserializeOpDocumentDeclineHandshakeOutput(v **DeclineHandshakeOutput, value interface{}) error { 11899 if v == nil { 11900 return fmt.Errorf("unexpected nil of type %T", v) 11901 } 11902 if value == nil { 11903 return nil 11904 } 11905 11906 shape, ok := value.(map[string]interface{}) 11907 if !ok { 11908 return fmt.Errorf("unexpected JSON type %v", value) 11909 } 11910 11911 var sv *DeclineHandshakeOutput 11912 if *v == nil { 11913 sv = &DeclineHandshakeOutput{} 11914 } else { 11915 sv = *v 11916 } 11917 11918 for key, value := range shape { 11919 switch key { 11920 case "Handshake": 11921 if err := awsAwsjson11_deserializeDocumentHandshake(&sv.Handshake, value); err != nil { 11922 return err 11923 } 11924 11925 default: 11926 _, _ = key, value 11927 11928 } 11929 } 11930 *v = sv 11931 return nil 11932} 11933 11934func awsAwsjson11_deserializeOpDocumentDescribeAccountOutput(v **DescribeAccountOutput, value interface{}) error { 11935 if v == nil { 11936 return fmt.Errorf("unexpected nil of type %T", v) 11937 } 11938 if value == nil { 11939 return nil 11940 } 11941 11942 shape, ok := value.(map[string]interface{}) 11943 if !ok { 11944 return fmt.Errorf("unexpected JSON type %v", value) 11945 } 11946 11947 var sv *DescribeAccountOutput 11948 if *v == nil { 11949 sv = &DescribeAccountOutput{} 11950 } else { 11951 sv = *v 11952 } 11953 11954 for key, value := range shape { 11955 switch key { 11956 case "Account": 11957 if err := awsAwsjson11_deserializeDocumentAccount(&sv.Account, value); err != nil { 11958 return err 11959 } 11960 11961 default: 11962 _, _ = key, value 11963 11964 } 11965 } 11966 *v = sv 11967 return nil 11968} 11969 11970func awsAwsjson11_deserializeOpDocumentDescribeCreateAccountStatusOutput(v **DescribeCreateAccountStatusOutput, value interface{}) error { 11971 if v == nil { 11972 return fmt.Errorf("unexpected nil of type %T", v) 11973 } 11974 if value == nil { 11975 return nil 11976 } 11977 11978 shape, ok := value.(map[string]interface{}) 11979 if !ok { 11980 return fmt.Errorf("unexpected JSON type %v", value) 11981 } 11982 11983 var sv *DescribeCreateAccountStatusOutput 11984 if *v == nil { 11985 sv = &DescribeCreateAccountStatusOutput{} 11986 } else { 11987 sv = *v 11988 } 11989 11990 for key, value := range shape { 11991 switch key { 11992 case "CreateAccountStatus": 11993 if err := awsAwsjson11_deserializeDocumentCreateAccountStatus(&sv.CreateAccountStatus, value); err != nil { 11994 return err 11995 } 11996 11997 default: 11998 _, _ = key, value 11999 12000 } 12001 } 12002 *v = sv 12003 return nil 12004} 12005 12006func awsAwsjson11_deserializeOpDocumentDescribeEffectivePolicyOutput(v **DescribeEffectivePolicyOutput, value interface{}) error { 12007 if v == nil { 12008 return fmt.Errorf("unexpected nil of type %T", v) 12009 } 12010 if value == nil { 12011 return nil 12012 } 12013 12014 shape, ok := value.(map[string]interface{}) 12015 if !ok { 12016 return fmt.Errorf("unexpected JSON type %v", value) 12017 } 12018 12019 var sv *DescribeEffectivePolicyOutput 12020 if *v == nil { 12021 sv = &DescribeEffectivePolicyOutput{} 12022 } else { 12023 sv = *v 12024 } 12025 12026 for key, value := range shape { 12027 switch key { 12028 case "EffectivePolicy": 12029 if err := awsAwsjson11_deserializeDocumentEffectivePolicy(&sv.EffectivePolicy, value); err != nil { 12030 return err 12031 } 12032 12033 default: 12034 _, _ = key, value 12035 12036 } 12037 } 12038 *v = sv 12039 return nil 12040} 12041 12042func awsAwsjson11_deserializeOpDocumentDescribeHandshakeOutput(v **DescribeHandshakeOutput, value interface{}) error { 12043 if v == nil { 12044 return fmt.Errorf("unexpected nil of type %T", v) 12045 } 12046 if value == nil { 12047 return nil 12048 } 12049 12050 shape, ok := value.(map[string]interface{}) 12051 if !ok { 12052 return fmt.Errorf("unexpected JSON type %v", value) 12053 } 12054 12055 var sv *DescribeHandshakeOutput 12056 if *v == nil { 12057 sv = &DescribeHandshakeOutput{} 12058 } else { 12059 sv = *v 12060 } 12061 12062 for key, value := range shape { 12063 switch key { 12064 case "Handshake": 12065 if err := awsAwsjson11_deserializeDocumentHandshake(&sv.Handshake, value); err != nil { 12066 return err 12067 } 12068 12069 default: 12070 _, _ = key, value 12071 12072 } 12073 } 12074 *v = sv 12075 return nil 12076} 12077 12078func awsAwsjson11_deserializeOpDocumentDescribeOrganizationalUnitOutput(v **DescribeOrganizationalUnitOutput, value interface{}) error { 12079 if v == nil { 12080 return fmt.Errorf("unexpected nil of type %T", v) 12081 } 12082 if value == nil { 12083 return nil 12084 } 12085 12086 shape, ok := value.(map[string]interface{}) 12087 if !ok { 12088 return fmt.Errorf("unexpected JSON type %v", value) 12089 } 12090 12091 var sv *DescribeOrganizationalUnitOutput 12092 if *v == nil { 12093 sv = &DescribeOrganizationalUnitOutput{} 12094 } else { 12095 sv = *v 12096 } 12097 12098 for key, value := range shape { 12099 switch key { 12100 case "OrganizationalUnit": 12101 if err := awsAwsjson11_deserializeDocumentOrganizationalUnit(&sv.OrganizationalUnit, value); err != nil { 12102 return err 12103 } 12104 12105 default: 12106 _, _ = key, value 12107 12108 } 12109 } 12110 *v = sv 12111 return nil 12112} 12113 12114func awsAwsjson11_deserializeOpDocumentDescribeOrganizationOutput(v **DescribeOrganizationOutput, value interface{}) error { 12115 if v == nil { 12116 return fmt.Errorf("unexpected nil of type %T", v) 12117 } 12118 if value == nil { 12119 return nil 12120 } 12121 12122 shape, ok := value.(map[string]interface{}) 12123 if !ok { 12124 return fmt.Errorf("unexpected JSON type %v", value) 12125 } 12126 12127 var sv *DescribeOrganizationOutput 12128 if *v == nil { 12129 sv = &DescribeOrganizationOutput{} 12130 } else { 12131 sv = *v 12132 } 12133 12134 for key, value := range shape { 12135 switch key { 12136 case "Organization": 12137 if err := awsAwsjson11_deserializeDocumentOrganization(&sv.Organization, value); err != nil { 12138 return err 12139 } 12140 12141 default: 12142 _, _ = key, value 12143 12144 } 12145 } 12146 *v = sv 12147 return nil 12148} 12149 12150func awsAwsjson11_deserializeOpDocumentDescribePolicyOutput(v **DescribePolicyOutput, value interface{}) error { 12151 if v == nil { 12152 return fmt.Errorf("unexpected nil of type %T", v) 12153 } 12154 if value == nil { 12155 return nil 12156 } 12157 12158 shape, ok := value.(map[string]interface{}) 12159 if !ok { 12160 return fmt.Errorf("unexpected JSON type %v", value) 12161 } 12162 12163 var sv *DescribePolicyOutput 12164 if *v == nil { 12165 sv = &DescribePolicyOutput{} 12166 } else { 12167 sv = *v 12168 } 12169 12170 for key, value := range shape { 12171 switch key { 12172 case "Policy": 12173 if err := awsAwsjson11_deserializeDocumentPolicy(&sv.Policy, value); err != nil { 12174 return err 12175 } 12176 12177 default: 12178 _, _ = key, value 12179 12180 } 12181 } 12182 *v = sv 12183 return nil 12184} 12185 12186func awsAwsjson11_deserializeOpDocumentDisablePolicyTypeOutput(v **DisablePolicyTypeOutput, value interface{}) error { 12187 if v == nil { 12188 return fmt.Errorf("unexpected nil of type %T", v) 12189 } 12190 if value == nil { 12191 return nil 12192 } 12193 12194 shape, ok := value.(map[string]interface{}) 12195 if !ok { 12196 return fmt.Errorf("unexpected JSON type %v", value) 12197 } 12198 12199 var sv *DisablePolicyTypeOutput 12200 if *v == nil { 12201 sv = &DisablePolicyTypeOutput{} 12202 } else { 12203 sv = *v 12204 } 12205 12206 for key, value := range shape { 12207 switch key { 12208 case "Root": 12209 if err := awsAwsjson11_deserializeDocumentRoot(&sv.Root, value); err != nil { 12210 return err 12211 } 12212 12213 default: 12214 _, _ = key, value 12215 12216 } 12217 } 12218 *v = sv 12219 return nil 12220} 12221 12222func awsAwsjson11_deserializeOpDocumentEnableAllFeaturesOutput(v **EnableAllFeaturesOutput, value interface{}) error { 12223 if v == nil { 12224 return fmt.Errorf("unexpected nil of type %T", v) 12225 } 12226 if value == nil { 12227 return nil 12228 } 12229 12230 shape, ok := value.(map[string]interface{}) 12231 if !ok { 12232 return fmt.Errorf("unexpected JSON type %v", value) 12233 } 12234 12235 var sv *EnableAllFeaturesOutput 12236 if *v == nil { 12237 sv = &EnableAllFeaturesOutput{} 12238 } else { 12239 sv = *v 12240 } 12241 12242 for key, value := range shape { 12243 switch key { 12244 case "Handshake": 12245 if err := awsAwsjson11_deserializeDocumentHandshake(&sv.Handshake, value); err != nil { 12246 return err 12247 } 12248 12249 default: 12250 _, _ = key, value 12251 12252 } 12253 } 12254 *v = sv 12255 return nil 12256} 12257 12258func awsAwsjson11_deserializeOpDocumentEnablePolicyTypeOutput(v **EnablePolicyTypeOutput, value interface{}) error { 12259 if v == nil { 12260 return fmt.Errorf("unexpected nil of type %T", v) 12261 } 12262 if value == nil { 12263 return nil 12264 } 12265 12266 shape, ok := value.(map[string]interface{}) 12267 if !ok { 12268 return fmt.Errorf("unexpected JSON type %v", value) 12269 } 12270 12271 var sv *EnablePolicyTypeOutput 12272 if *v == nil { 12273 sv = &EnablePolicyTypeOutput{} 12274 } else { 12275 sv = *v 12276 } 12277 12278 for key, value := range shape { 12279 switch key { 12280 case "Root": 12281 if err := awsAwsjson11_deserializeDocumentRoot(&sv.Root, value); err != nil { 12282 return err 12283 } 12284 12285 default: 12286 _, _ = key, value 12287 12288 } 12289 } 12290 *v = sv 12291 return nil 12292} 12293 12294func awsAwsjson11_deserializeOpDocumentInviteAccountToOrganizationOutput(v **InviteAccountToOrganizationOutput, value interface{}) error { 12295 if v == nil { 12296 return fmt.Errorf("unexpected nil of type %T", v) 12297 } 12298 if value == nil { 12299 return nil 12300 } 12301 12302 shape, ok := value.(map[string]interface{}) 12303 if !ok { 12304 return fmt.Errorf("unexpected JSON type %v", value) 12305 } 12306 12307 var sv *InviteAccountToOrganizationOutput 12308 if *v == nil { 12309 sv = &InviteAccountToOrganizationOutput{} 12310 } else { 12311 sv = *v 12312 } 12313 12314 for key, value := range shape { 12315 switch key { 12316 case "Handshake": 12317 if err := awsAwsjson11_deserializeDocumentHandshake(&sv.Handshake, value); err != nil { 12318 return err 12319 } 12320 12321 default: 12322 _, _ = key, value 12323 12324 } 12325 } 12326 *v = sv 12327 return nil 12328} 12329 12330func awsAwsjson11_deserializeOpDocumentListAccountsForParentOutput(v **ListAccountsForParentOutput, value interface{}) error { 12331 if v == nil { 12332 return fmt.Errorf("unexpected nil of type %T", v) 12333 } 12334 if value == nil { 12335 return nil 12336 } 12337 12338 shape, ok := value.(map[string]interface{}) 12339 if !ok { 12340 return fmt.Errorf("unexpected JSON type %v", value) 12341 } 12342 12343 var sv *ListAccountsForParentOutput 12344 if *v == nil { 12345 sv = &ListAccountsForParentOutput{} 12346 } else { 12347 sv = *v 12348 } 12349 12350 for key, value := range shape { 12351 switch key { 12352 case "Accounts": 12353 if err := awsAwsjson11_deserializeDocumentAccounts(&sv.Accounts, value); err != nil { 12354 return err 12355 } 12356 12357 case "NextToken": 12358 if value != nil { 12359 jtv, ok := value.(string) 12360 if !ok { 12361 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 12362 } 12363 sv.NextToken = ptr.String(jtv) 12364 } 12365 12366 default: 12367 _, _ = key, value 12368 12369 } 12370 } 12371 *v = sv 12372 return nil 12373} 12374 12375func awsAwsjson11_deserializeOpDocumentListAccountsOutput(v **ListAccountsOutput, value interface{}) error { 12376 if v == nil { 12377 return fmt.Errorf("unexpected nil of type %T", v) 12378 } 12379 if value == nil { 12380 return nil 12381 } 12382 12383 shape, ok := value.(map[string]interface{}) 12384 if !ok { 12385 return fmt.Errorf("unexpected JSON type %v", value) 12386 } 12387 12388 var sv *ListAccountsOutput 12389 if *v == nil { 12390 sv = &ListAccountsOutput{} 12391 } else { 12392 sv = *v 12393 } 12394 12395 for key, value := range shape { 12396 switch key { 12397 case "Accounts": 12398 if err := awsAwsjson11_deserializeDocumentAccounts(&sv.Accounts, value); err != nil { 12399 return err 12400 } 12401 12402 case "NextToken": 12403 if value != nil { 12404 jtv, ok := value.(string) 12405 if !ok { 12406 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 12407 } 12408 sv.NextToken = ptr.String(jtv) 12409 } 12410 12411 default: 12412 _, _ = key, value 12413 12414 } 12415 } 12416 *v = sv 12417 return nil 12418} 12419 12420func awsAwsjson11_deserializeOpDocumentListAWSServiceAccessForOrganizationOutput(v **ListAWSServiceAccessForOrganizationOutput, value interface{}) error { 12421 if v == nil { 12422 return fmt.Errorf("unexpected nil of type %T", v) 12423 } 12424 if value == nil { 12425 return nil 12426 } 12427 12428 shape, ok := value.(map[string]interface{}) 12429 if !ok { 12430 return fmt.Errorf("unexpected JSON type %v", value) 12431 } 12432 12433 var sv *ListAWSServiceAccessForOrganizationOutput 12434 if *v == nil { 12435 sv = &ListAWSServiceAccessForOrganizationOutput{} 12436 } else { 12437 sv = *v 12438 } 12439 12440 for key, value := range shape { 12441 switch key { 12442 case "EnabledServicePrincipals": 12443 if err := awsAwsjson11_deserializeDocumentEnabledServicePrincipals(&sv.EnabledServicePrincipals, value); err != nil { 12444 return err 12445 } 12446 12447 case "NextToken": 12448 if value != nil { 12449 jtv, ok := value.(string) 12450 if !ok { 12451 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 12452 } 12453 sv.NextToken = ptr.String(jtv) 12454 } 12455 12456 default: 12457 _, _ = key, value 12458 12459 } 12460 } 12461 *v = sv 12462 return nil 12463} 12464 12465func awsAwsjson11_deserializeOpDocumentListChildrenOutput(v **ListChildrenOutput, value interface{}) error { 12466 if v == nil { 12467 return fmt.Errorf("unexpected nil of type %T", v) 12468 } 12469 if value == nil { 12470 return nil 12471 } 12472 12473 shape, ok := value.(map[string]interface{}) 12474 if !ok { 12475 return fmt.Errorf("unexpected JSON type %v", value) 12476 } 12477 12478 var sv *ListChildrenOutput 12479 if *v == nil { 12480 sv = &ListChildrenOutput{} 12481 } else { 12482 sv = *v 12483 } 12484 12485 for key, value := range shape { 12486 switch key { 12487 case "Children": 12488 if err := awsAwsjson11_deserializeDocumentChildren(&sv.Children, value); err != nil { 12489 return err 12490 } 12491 12492 case "NextToken": 12493 if value != nil { 12494 jtv, ok := value.(string) 12495 if !ok { 12496 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 12497 } 12498 sv.NextToken = ptr.String(jtv) 12499 } 12500 12501 default: 12502 _, _ = key, value 12503 12504 } 12505 } 12506 *v = sv 12507 return nil 12508} 12509 12510func awsAwsjson11_deserializeOpDocumentListCreateAccountStatusOutput(v **ListCreateAccountStatusOutput, value interface{}) error { 12511 if v == nil { 12512 return fmt.Errorf("unexpected nil of type %T", v) 12513 } 12514 if value == nil { 12515 return nil 12516 } 12517 12518 shape, ok := value.(map[string]interface{}) 12519 if !ok { 12520 return fmt.Errorf("unexpected JSON type %v", value) 12521 } 12522 12523 var sv *ListCreateAccountStatusOutput 12524 if *v == nil { 12525 sv = &ListCreateAccountStatusOutput{} 12526 } else { 12527 sv = *v 12528 } 12529 12530 for key, value := range shape { 12531 switch key { 12532 case "CreateAccountStatuses": 12533 if err := awsAwsjson11_deserializeDocumentCreateAccountStatuses(&sv.CreateAccountStatuses, value); err != nil { 12534 return err 12535 } 12536 12537 case "NextToken": 12538 if value != nil { 12539 jtv, ok := value.(string) 12540 if !ok { 12541 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 12542 } 12543 sv.NextToken = ptr.String(jtv) 12544 } 12545 12546 default: 12547 _, _ = key, value 12548 12549 } 12550 } 12551 *v = sv 12552 return nil 12553} 12554 12555func awsAwsjson11_deserializeOpDocumentListDelegatedAdministratorsOutput(v **ListDelegatedAdministratorsOutput, value interface{}) error { 12556 if v == nil { 12557 return fmt.Errorf("unexpected nil of type %T", v) 12558 } 12559 if value == nil { 12560 return nil 12561 } 12562 12563 shape, ok := value.(map[string]interface{}) 12564 if !ok { 12565 return fmt.Errorf("unexpected JSON type %v", value) 12566 } 12567 12568 var sv *ListDelegatedAdministratorsOutput 12569 if *v == nil { 12570 sv = &ListDelegatedAdministratorsOutput{} 12571 } else { 12572 sv = *v 12573 } 12574 12575 for key, value := range shape { 12576 switch key { 12577 case "DelegatedAdministrators": 12578 if err := awsAwsjson11_deserializeDocumentDelegatedAdministrators(&sv.DelegatedAdministrators, value); err != nil { 12579 return err 12580 } 12581 12582 case "NextToken": 12583 if value != nil { 12584 jtv, ok := value.(string) 12585 if !ok { 12586 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 12587 } 12588 sv.NextToken = ptr.String(jtv) 12589 } 12590 12591 default: 12592 _, _ = key, value 12593 12594 } 12595 } 12596 *v = sv 12597 return nil 12598} 12599 12600func awsAwsjson11_deserializeOpDocumentListDelegatedServicesForAccountOutput(v **ListDelegatedServicesForAccountOutput, value interface{}) error { 12601 if v == nil { 12602 return fmt.Errorf("unexpected nil of type %T", v) 12603 } 12604 if value == nil { 12605 return nil 12606 } 12607 12608 shape, ok := value.(map[string]interface{}) 12609 if !ok { 12610 return fmt.Errorf("unexpected JSON type %v", value) 12611 } 12612 12613 var sv *ListDelegatedServicesForAccountOutput 12614 if *v == nil { 12615 sv = &ListDelegatedServicesForAccountOutput{} 12616 } else { 12617 sv = *v 12618 } 12619 12620 for key, value := range shape { 12621 switch key { 12622 case "DelegatedServices": 12623 if err := awsAwsjson11_deserializeDocumentDelegatedServices(&sv.DelegatedServices, value); err != nil { 12624 return err 12625 } 12626 12627 case "NextToken": 12628 if value != nil { 12629 jtv, ok := value.(string) 12630 if !ok { 12631 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 12632 } 12633 sv.NextToken = ptr.String(jtv) 12634 } 12635 12636 default: 12637 _, _ = key, value 12638 12639 } 12640 } 12641 *v = sv 12642 return nil 12643} 12644 12645func awsAwsjson11_deserializeOpDocumentListHandshakesForAccountOutput(v **ListHandshakesForAccountOutput, value interface{}) error { 12646 if v == nil { 12647 return fmt.Errorf("unexpected nil of type %T", v) 12648 } 12649 if value == nil { 12650 return nil 12651 } 12652 12653 shape, ok := value.(map[string]interface{}) 12654 if !ok { 12655 return fmt.Errorf("unexpected JSON type %v", value) 12656 } 12657 12658 var sv *ListHandshakesForAccountOutput 12659 if *v == nil { 12660 sv = &ListHandshakesForAccountOutput{} 12661 } else { 12662 sv = *v 12663 } 12664 12665 for key, value := range shape { 12666 switch key { 12667 case "Handshakes": 12668 if err := awsAwsjson11_deserializeDocumentHandshakes(&sv.Handshakes, value); err != nil { 12669 return err 12670 } 12671 12672 case "NextToken": 12673 if value != nil { 12674 jtv, ok := value.(string) 12675 if !ok { 12676 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 12677 } 12678 sv.NextToken = ptr.String(jtv) 12679 } 12680 12681 default: 12682 _, _ = key, value 12683 12684 } 12685 } 12686 *v = sv 12687 return nil 12688} 12689 12690func awsAwsjson11_deserializeOpDocumentListHandshakesForOrganizationOutput(v **ListHandshakesForOrganizationOutput, value interface{}) error { 12691 if v == nil { 12692 return fmt.Errorf("unexpected nil of type %T", v) 12693 } 12694 if value == nil { 12695 return nil 12696 } 12697 12698 shape, ok := value.(map[string]interface{}) 12699 if !ok { 12700 return fmt.Errorf("unexpected JSON type %v", value) 12701 } 12702 12703 var sv *ListHandshakesForOrganizationOutput 12704 if *v == nil { 12705 sv = &ListHandshakesForOrganizationOutput{} 12706 } else { 12707 sv = *v 12708 } 12709 12710 for key, value := range shape { 12711 switch key { 12712 case "Handshakes": 12713 if err := awsAwsjson11_deserializeDocumentHandshakes(&sv.Handshakes, value); err != nil { 12714 return err 12715 } 12716 12717 case "NextToken": 12718 if value != nil { 12719 jtv, ok := value.(string) 12720 if !ok { 12721 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 12722 } 12723 sv.NextToken = ptr.String(jtv) 12724 } 12725 12726 default: 12727 _, _ = key, value 12728 12729 } 12730 } 12731 *v = sv 12732 return nil 12733} 12734 12735func awsAwsjson11_deserializeOpDocumentListOrganizationalUnitsForParentOutput(v **ListOrganizationalUnitsForParentOutput, value interface{}) error { 12736 if v == nil { 12737 return fmt.Errorf("unexpected nil of type %T", v) 12738 } 12739 if value == nil { 12740 return nil 12741 } 12742 12743 shape, ok := value.(map[string]interface{}) 12744 if !ok { 12745 return fmt.Errorf("unexpected JSON type %v", value) 12746 } 12747 12748 var sv *ListOrganizationalUnitsForParentOutput 12749 if *v == nil { 12750 sv = &ListOrganizationalUnitsForParentOutput{} 12751 } else { 12752 sv = *v 12753 } 12754 12755 for key, value := range shape { 12756 switch key { 12757 case "NextToken": 12758 if value != nil { 12759 jtv, ok := value.(string) 12760 if !ok { 12761 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 12762 } 12763 sv.NextToken = ptr.String(jtv) 12764 } 12765 12766 case "OrganizationalUnits": 12767 if err := awsAwsjson11_deserializeDocumentOrganizationalUnits(&sv.OrganizationalUnits, value); err != nil { 12768 return err 12769 } 12770 12771 default: 12772 _, _ = key, value 12773 12774 } 12775 } 12776 *v = sv 12777 return nil 12778} 12779 12780func awsAwsjson11_deserializeOpDocumentListParentsOutput(v **ListParentsOutput, value interface{}) error { 12781 if v == nil { 12782 return fmt.Errorf("unexpected nil of type %T", v) 12783 } 12784 if value == nil { 12785 return nil 12786 } 12787 12788 shape, ok := value.(map[string]interface{}) 12789 if !ok { 12790 return fmt.Errorf("unexpected JSON type %v", value) 12791 } 12792 12793 var sv *ListParentsOutput 12794 if *v == nil { 12795 sv = &ListParentsOutput{} 12796 } else { 12797 sv = *v 12798 } 12799 12800 for key, value := range shape { 12801 switch key { 12802 case "NextToken": 12803 if value != nil { 12804 jtv, ok := value.(string) 12805 if !ok { 12806 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 12807 } 12808 sv.NextToken = ptr.String(jtv) 12809 } 12810 12811 case "Parents": 12812 if err := awsAwsjson11_deserializeDocumentParents(&sv.Parents, value); err != nil { 12813 return err 12814 } 12815 12816 default: 12817 _, _ = key, value 12818 12819 } 12820 } 12821 *v = sv 12822 return nil 12823} 12824 12825func awsAwsjson11_deserializeOpDocumentListPoliciesForTargetOutput(v **ListPoliciesForTargetOutput, value interface{}) error { 12826 if v == nil { 12827 return fmt.Errorf("unexpected nil of type %T", v) 12828 } 12829 if value == nil { 12830 return nil 12831 } 12832 12833 shape, ok := value.(map[string]interface{}) 12834 if !ok { 12835 return fmt.Errorf("unexpected JSON type %v", value) 12836 } 12837 12838 var sv *ListPoliciesForTargetOutput 12839 if *v == nil { 12840 sv = &ListPoliciesForTargetOutput{} 12841 } else { 12842 sv = *v 12843 } 12844 12845 for key, value := range shape { 12846 switch key { 12847 case "NextToken": 12848 if value != nil { 12849 jtv, ok := value.(string) 12850 if !ok { 12851 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 12852 } 12853 sv.NextToken = ptr.String(jtv) 12854 } 12855 12856 case "Policies": 12857 if err := awsAwsjson11_deserializeDocumentPolicies(&sv.Policies, value); err != nil { 12858 return err 12859 } 12860 12861 default: 12862 _, _ = key, value 12863 12864 } 12865 } 12866 *v = sv 12867 return nil 12868} 12869 12870func awsAwsjson11_deserializeOpDocumentListPoliciesOutput(v **ListPoliciesOutput, value interface{}) error { 12871 if v == nil { 12872 return fmt.Errorf("unexpected nil of type %T", v) 12873 } 12874 if value == nil { 12875 return nil 12876 } 12877 12878 shape, ok := value.(map[string]interface{}) 12879 if !ok { 12880 return fmt.Errorf("unexpected JSON type %v", value) 12881 } 12882 12883 var sv *ListPoliciesOutput 12884 if *v == nil { 12885 sv = &ListPoliciesOutput{} 12886 } else { 12887 sv = *v 12888 } 12889 12890 for key, value := range shape { 12891 switch key { 12892 case "NextToken": 12893 if value != nil { 12894 jtv, ok := value.(string) 12895 if !ok { 12896 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 12897 } 12898 sv.NextToken = ptr.String(jtv) 12899 } 12900 12901 case "Policies": 12902 if err := awsAwsjson11_deserializeDocumentPolicies(&sv.Policies, value); err != nil { 12903 return err 12904 } 12905 12906 default: 12907 _, _ = key, value 12908 12909 } 12910 } 12911 *v = sv 12912 return nil 12913} 12914 12915func awsAwsjson11_deserializeOpDocumentListRootsOutput(v **ListRootsOutput, value interface{}) error { 12916 if v == nil { 12917 return fmt.Errorf("unexpected nil of type %T", v) 12918 } 12919 if value == nil { 12920 return nil 12921 } 12922 12923 shape, ok := value.(map[string]interface{}) 12924 if !ok { 12925 return fmt.Errorf("unexpected JSON type %v", value) 12926 } 12927 12928 var sv *ListRootsOutput 12929 if *v == nil { 12930 sv = &ListRootsOutput{} 12931 } else { 12932 sv = *v 12933 } 12934 12935 for key, value := range shape { 12936 switch key { 12937 case "NextToken": 12938 if value != nil { 12939 jtv, ok := value.(string) 12940 if !ok { 12941 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 12942 } 12943 sv.NextToken = ptr.String(jtv) 12944 } 12945 12946 case "Roots": 12947 if err := awsAwsjson11_deserializeDocumentRoots(&sv.Roots, value); err != nil { 12948 return err 12949 } 12950 12951 default: 12952 _, _ = key, value 12953 12954 } 12955 } 12956 *v = sv 12957 return nil 12958} 12959 12960func awsAwsjson11_deserializeOpDocumentListTagsForResourceOutput(v **ListTagsForResourceOutput, value interface{}) error { 12961 if v == nil { 12962 return fmt.Errorf("unexpected nil of type %T", v) 12963 } 12964 if value == nil { 12965 return nil 12966 } 12967 12968 shape, ok := value.(map[string]interface{}) 12969 if !ok { 12970 return fmt.Errorf("unexpected JSON type %v", value) 12971 } 12972 12973 var sv *ListTagsForResourceOutput 12974 if *v == nil { 12975 sv = &ListTagsForResourceOutput{} 12976 } else { 12977 sv = *v 12978 } 12979 12980 for key, value := range shape { 12981 switch key { 12982 case "NextToken": 12983 if value != nil { 12984 jtv, ok := value.(string) 12985 if !ok { 12986 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 12987 } 12988 sv.NextToken = ptr.String(jtv) 12989 } 12990 12991 case "Tags": 12992 if err := awsAwsjson11_deserializeDocumentTags(&sv.Tags, value); err != nil { 12993 return err 12994 } 12995 12996 default: 12997 _, _ = key, value 12998 12999 } 13000 } 13001 *v = sv 13002 return nil 13003} 13004 13005func awsAwsjson11_deserializeOpDocumentListTargetsForPolicyOutput(v **ListTargetsForPolicyOutput, value interface{}) error { 13006 if v == nil { 13007 return fmt.Errorf("unexpected nil of type %T", v) 13008 } 13009 if value == nil { 13010 return nil 13011 } 13012 13013 shape, ok := value.(map[string]interface{}) 13014 if !ok { 13015 return fmt.Errorf("unexpected JSON type %v", value) 13016 } 13017 13018 var sv *ListTargetsForPolicyOutput 13019 if *v == nil { 13020 sv = &ListTargetsForPolicyOutput{} 13021 } else { 13022 sv = *v 13023 } 13024 13025 for key, value := range shape { 13026 switch key { 13027 case "NextToken": 13028 if value != nil { 13029 jtv, ok := value.(string) 13030 if !ok { 13031 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 13032 } 13033 sv.NextToken = ptr.String(jtv) 13034 } 13035 13036 case "Targets": 13037 if err := awsAwsjson11_deserializeDocumentPolicyTargets(&sv.Targets, value); err != nil { 13038 return err 13039 } 13040 13041 default: 13042 _, _ = key, value 13043 13044 } 13045 } 13046 *v = sv 13047 return nil 13048} 13049 13050func awsAwsjson11_deserializeOpDocumentUpdateOrganizationalUnitOutput(v **UpdateOrganizationalUnitOutput, value interface{}) error { 13051 if v == nil { 13052 return fmt.Errorf("unexpected nil of type %T", v) 13053 } 13054 if value == nil { 13055 return nil 13056 } 13057 13058 shape, ok := value.(map[string]interface{}) 13059 if !ok { 13060 return fmt.Errorf("unexpected JSON type %v", value) 13061 } 13062 13063 var sv *UpdateOrganizationalUnitOutput 13064 if *v == nil { 13065 sv = &UpdateOrganizationalUnitOutput{} 13066 } else { 13067 sv = *v 13068 } 13069 13070 for key, value := range shape { 13071 switch key { 13072 case "OrganizationalUnit": 13073 if err := awsAwsjson11_deserializeDocumentOrganizationalUnit(&sv.OrganizationalUnit, value); err != nil { 13074 return err 13075 } 13076 13077 default: 13078 _, _ = key, value 13079 13080 } 13081 } 13082 *v = sv 13083 return nil 13084} 13085 13086func awsAwsjson11_deserializeOpDocumentUpdatePolicyOutput(v **UpdatePolicyOutput, value interface{}) error { 13087 if v == nil { 13088 return fmt.Errorf("unexpected nil of type %T", v) 13089 } 13090 if value == nil { 13091 return nil 13092 } 13093 13094 shape, ok := value.(map[string]interface{}) 13095 if !ok { 13096 return fmt.Errorf("unexpected JSON type %v", value) 13097 } 13098 13099 var sv *UpdatePolicyOutput 13100 if *v == nil { 13101 sv = &UpdatePolicyOutput{} 13102 } else { 13103 sv = *v 13104 } 13105 13106 for key, value := range shape { 13107 switch key { 13108 case "Policy": 13109 if err := awsAwsjson11_deserializeDocumentPolicy(&sv.Policy, value); err != nil { 13110 return err 13111 } 13112 13113 default: 13114 _, _ = key, value 13115 13116 } 13117 } 13118 *v = sv 13119 return nil 13120} 13121