1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package servicecatalog 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/servicecatalog/types" 12 smithy "github.com/aws/smithy-go" 13 smithyio "github.com/aws/smithy-go/io" 14 "github.com/aws/smithy-go/middleware" 15 "github.com/aws/smithy-go/ptr" 16 smithytime "github.com/aws/smithy-go/time" 17 smithyhttp "github.com/aws/smithy-go/transport/http" 18 "io" 19 "strings" 20) 21 22type awsAwsjson11_deserializeOpAcceptPortfolioShare struct { 23} 24 25func (*awsAwsjson11_deserializeOpAcceptPortfolioShare) ID() string { 26 return "OperationDeserializer" 27} 28 29func (m *awsAwsjson11_deserializeOpAcceptPortfolioShare) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 30 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 31) { 32 out, metadata, err = next.HandleDeserialize(ctx, in) 33 if err != nil { 34 return out, metadata, err 35 } 36 37 response, ok := out.RawResponse.(*smithyhttp.Response) 38 if !ok { 39 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 40 } 41 42 if response.StatusCode < 200 || response.StatusCode >= 300 { 43 return out, metadata, awsAwsjson11_deserializeOpErrorAcceptPortfolioShare(response, &metadata) 44 } 45 output := &AcceptPortfolioShareOutput{} 46 out.Result = output 47 48 var buff [1024]byte 49 ringBuffer := smithyio.NewRingBuffer(buff[:]) 50 51 body := io.TeeReader(response.Body, ringBuffer) 52 decoder := json.NewDecoder(body) 53 decoder.UseNumber() 54 var shape interface{} 55 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 56 var snapshot bytes.Buffer 57 io.Copy(&snapshot, ringBuffer) 58 err = &smithy.DeserializationError{ 59 Err: fmt.Errorf("failed to decode response body, %w", err), 60 Snapshot: snapshot.Bytes(), 61 } 62 return out, metadata, err 63 } 64 65 err = awsAwsjson11_deserializeOpDocumentAcceptPortfolioShareOutput(&output, shape) 66 if err != nil { 67 var snapshot bytes.Buffer 68 io.Copy(&snapshot, ringBuffer) 69 err = &smithy.DeserializationError{ 70 Err: fmt.Errorf("failed to decode response body, %w", err), 71 Snapshot: snapshot.Bytes(), 72 } 73 return out, metadata, err 74 } 75 76 return out, metadata, err 77} 78 79func awsAwsjson11_deserializeOpErrorAcceptPortfolioShare(response *smithyhttp.Response, metadata *middleware.Metadata) error { 80 var errorBuffer bytes.Buffer 81 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 82 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 83 } 84 errorBody := bytes.NewReader(errorBuffer.Bytes()) 85 86 errorCode := "UnknownError" 87 errorMessage := errorCode 88 89 code := response.Header.Get("X-Amzn-ErrorType") 90 if len(code) != 0 { 91 errorCode = restjson.SanitizeErrorCode(code) 92 } 93 94 var buff [1024]byte 95 ringBuffer := smithyio.NewRingBuffer(buff[:]) 96 97 body := io.TeeReader(errorBody, ringBuffer) 98 decoder := json.NewDecoder(body) 99 decoder.UseNumber() 100 code, message, err := restjson.GetErrorInfo(decoder) 101 if err != nil { 102 var snapshot bytes.Buffer 103 io.Copy(&snapshot, ringBuffer) 104 err = &smithy.DeserializationError{ 105 Err: fmt.Errorf("failed to decode response body, %w", err), 106 Snapshot: snapshot.Bytes(), 107 } 108 return err 109 } 110 111 errorBody.Seek(0, io.SeekStart) 112 if len(code) != 0 { 113 errorCode = restjson.SanitizeErrorCode(code) 114 } 115 if len(message) != 0 { 116 errorMessage = message 117 } 118 119 switch { 120 case strings.EqualFold("InvalidParametersException", errorCode): 121 return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody) 122 123 case strings.EqualFold("LimitExceededException", errorCode): 124 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 125 126 case strings.EqualFold("ResourceNotFoundException", errorCode): 127 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 128 129 default: 130 genericError := &smithy.GenericAPIError{ 131 Code: errorCode, 132 Message: errorMessage, 133 } 134 return genericError 135 136 } 137} 138 139type awsAwsjson11_deserializeOpAssociateBudgetWithResource struct { 140} 141 142func (*awsAwsjson11_deserializeOpAssociateBudgetWithResource) ID() string { 143 return "OperationDeserializer" 144} 145 146func (m *awsAwsjson11_deserializeOpAssociateBudgetWithResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 147 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 148) { 149 out, metadata, err = next.HandleDeserialize(ctx, in) 150 if err != nil { 151 return out, metadata, err 152 } 153 154 response, ok := out.RawResponse.(*smithyhttp.Response) 155 if !ok { 156 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 157 } 158 159 if response.StatusCode < 200 || response.StatusCode >= 300 { 160 return out, metadata, awsAwsjson11_deserializeOpErrorAssociateBudgetWithResource(response, &metadata) 161 } 162 output := &AssociateBudgetWithResourceOutput{} 163 out.Result = output 164 165 var buff [1024]byte 166 ringBuffer := smithyio.NewRingBuffer(buff[:]) 167 168 body := io.TeeReader(response.Body, ringBuffer) 169 decoder := json.NewDecoder(body) 170 decoder.UseNumber() 171 var shape interface{} 172 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 173 var snapshot bytes.Buffer 174 io.Copy(&snapshot, ringBuffer) 175 err = &smithy.DeserializationError{ 176 Err: fmt.Errorf("failed to decode response body, %w", err), 177 Snapshot: snapshot.Bytes(), 178 } 179 return out, metadata, err 180 } 181 182 err = awsAwsjson11_deserializeOpDocumentAssociateBudgetWithResourceOutput(&output, shape) 183 if err != nil { 184 var snapshot bytes.Buffer 185 io.Copy(&snapshot, ringBuffer) 186 err = &smithy.DeserializationError{ 187 Err: fmt.Errorf("failed to decode response body, %w", err), 188 Snapshot: snapshot.Bytes(), 189 } 190 return out, metadata, err 191 } 192 193 return out, metadata, err 194} 195 196func awsAwsjson11_deserializeOpErrorAssociateBudgetWithResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 197 var errorBuffer bytes.Buffer 198 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 199 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 200 } 201 errorBody := bytes.NewReader(errorBuffer.Bytes()) 202 203 errorCode := "UnknownError" 204 errorMessage := errorCode 205 206 code := response.Header.Get("X-Amzn-ErrorType") 207 if len(code) != 0 { 208 errorCode = restjson.SanitizeErrorCode(code) 209 } 210 211 var buff [1024]byte 212 ringBuffer := smithyio.NewRingBuffer(buff[:]) 213 214 body := io.TeeReader(errorBody, ringBuffer) 215 decoder := json.NewDecoder(body) 216 decoder.UseNumber() 217 code, message, err := restjson.GetErrorInfo(decoder) 218 if err != nil { 219 var snapshot bytes.Buffer 220 io.Copy(&snapshot, ringBuffer) 221 err = &smithy.DeserializationError{ 222 Err: fmt.Errorf("failed to decode response body, %w", err), 223 Snapshot: snapshot.Bytes(), 224 } 225 return err 226 } 227 228 errorBody.Seek(0, io.SeekStart) 229 if len(code) != 0 { 230 errorCode = restjson.SanitizeErrorCode(code) 231 } 232 if len(message) != 0 { 233 errorMessage = message 234 } 235 236 switch { 237 case strings.EqualFold("DuplicateResourceException", errorCode): 238 return awsAwsjson11_deserializeErrorDuplicateResourceException(response, errorBody) 239 240 case strings.EqualFold("InvalidParametersException", errorCode): 241 return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody) 242 243 case strings.EqualFold("LimitExceededException", errorCode): 244 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 245 246 case strings.EqualFold("ResourceNotFoundException", errorCode): 247 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 248 249 default: 250 genericError := &smithy.GenericAPIError{ 251 Code: errorCode, 252 Message: errorMessage, 253 } 254 return genericError 255 256 } 257} 258 259type awsAwsjson11_deserializeOpAssociatePrincipalWithPortfolio struct { 260} 261 262func (*awsAwsjson11_deserializeOpAssociatePrincipalWithPortfolio) ID() string { 263 return "OperationDeserializer" 264} 265 266func (m *awsAwsjson11_deserializeOpAssociatePrincipalWithPortfolio) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 267 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 268) { 269 out, metadata, err = next.HandleDeserialize(ctx, in) 270 if err != nil { 271 return out, metadata, err 272 } 273 274 response, ok := out.RawResponse.(*smithyhttp.Response) 275 if !ok { 276 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 277 } 278 279 if response.StatusCode < 200 || response.StatusCode >= 300 { 280 return out, metadata, awsAwsjson11_deserializeOpErrorAssociatePrincipalWithPortfolio(response, &metadata) 281 } 282 output := &AssociatePrincipalWithPortfolioOutput{} 283 out.Result = output 284 285 var buff [1024]byte 286 ringBuffer := smithyio.NewRingBuffer(buff[:]) 287 288 body := io.TeeReader(response.Body, ringBuffer) 289 decoder := json.NewDecoder(body) 290 decoder.UseNumber() 291 var shape interface{} 292 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 293 var snapshot bytes.Buffer 294 io.Copy(&snapshot, ringBuffer) 295 err = &smithy.DeserializationError{ 296 Err: fmt.Errorf("failed to decode response body, %w", err), 297 Snapshot: snapshot.Bytes(), 298 } 299 return out, metadata, err 300 } 301 302 err = awsAwsjson11_deserializeOpDocumentAssociatePrincipalWithPortfolioOutput(&output, shape) 303 if err != nil { 304 var snapshot bytes.Buffer 305 io.Copy(&snapshot, ringBuffer) 306 err = &smithy.DeserializationError{ 307 Err: fmt.Errorf("failed to decode response body, %w", err), 308 Snapshot: snapshot.Bytes(), 309 } 310 return out, metadata, err 311 } 312 313 return out, metadata, err 314} 315 316func awsAwsjson11_deserializeOpErrorAssociatePrincipalWithPortfolio(response *smithyhttp.Response, metadata *middleware.Metadata) error { 317 var errorBuffer bytes.Buffer 318 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 319 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 320 } 321 errorBody := bytes.NewReader(errorBuffer.Bytes()) 322 323 errorCode := "UnknownError" 324 errorMessage := errorCode 325 326 code := response.Header.Get("X-Amzn-ErrorType") 327 if len(code) != 0 { 328 errorCode = restjson.SanitizeErrorCode(code) 329 } 330 331 var buff [1024]byte 332 ringBuffer := smithyio.NewRingBuffer(buff[:]) 333 334 body := io.TeeReader(errorBody, ringBuffer) 335 decoder := json.NewDecoder(body) 336 decoder.UseNumber() 337 code, message, err := restjson.GetErrorInfo(decoder) 338 if err != nil { 339 var snapshot bytes.Buffer 340 io.Copy(&snapshot, ringBuffer) 341 err = &smithy.DeserializationError{ 342 Err: fmt.Errorf("failed to decode response body, %w", err), 343 Snapshot: snapshot.Bytes(), 344 } 345 return err 346 } 347 348 errorBody.Seek(0, io.SeekStart) 349 if len(code) != 0 { 350 errorCode = restjson.SanitizeErrorCode(code) 351 } 352 if len(message) != 0 { 353 errorMessage = message 354 } 355 356 switch { 357 case strings.EqualFold("InvalidParametersException", errorCode): 358 return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody) 359 360 case strings.EqualFold("LimitExceededException", errorCode): 361 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 362 363 case strings.EqualFold("ResourceNotFoundException", errorCode): 364 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 365 366 default: 367 genericError := &smithy.GenericAPIError{ 368 Code: errorCode, 369 Message: errorMessage, 370 } 371 return genericError 372 373 } 374} 375 376type awsAwsjson11_deserializeOpAssociateProductWithPortfolio struct { 377} 378 379func (*awsAwsjson11_deserializeOpAssociateProductWithPortfolio) ID() string { 380 return "OperationDeserializer" 381} 382 383func (m *awsAwsjson11_deserializeOpAssociateProductWithPortfolio) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 384 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 385) { 386 out, metadata, err = next.HandleDeserialize(ctx, in) 387 if err != nil { 388 return out, metadata, err 389 } 390 391 response, ok := out.RawResponse.(*smithyhttp.Response) 392 if !ok { 393 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 394 } 395 396 if response.StatusCode < 200 || response.StatusCode >= 300 { 397 return out, metadata, awsAwsjson11_deserializeOpErrorAssociateProductWithPortfolio(response, &metadata) 398 } 399 output := &AssociateProductWithPortfolioOutput{} 400 out.Result = output 401 402 var buff [1024]byte 403 ringBuffer := smithyio.NewRingBuffer(buff[:]) 404 405 body := io.TeeReader(response.Body, ringBuffer) 406 decoder := json.NewDecoder(body) 407 decoder.UseNumber() 408 var shape interface{} 409 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 410 var snapshot bytes.Buffer 411 io.Copy(&snapshot, ringBuffer) 412 err = &smithy.DeserializationError{ 413 Err: fmt.Errorf("failed to decode response body, %w", err), 414 Snapshot: snapshot.Bytes(), 415 } 416 return out, metadata, err 417 } 418 419 err = awsAwsjson11_deserializeOpDocumentAssociateProductWithPortfolioOutput(&output, shape) 420 if err != nil { 421 var snapshot bytes.Buffer 422 io.Copy(&snapshot, ringBuffer) 423 err = &smithy.DeserializationError{ 424 Err: fmt.Errorf("failed to decode response body, %w", err), 425 Snapshot: snapshot.Bytes(), 426 } 427 return out, metadata, err 428 } 429 430 return out, metadata, err 431} 432 433func awsAwsjson11_deserializeOpErrorAssociateProductWithPortfolio(response *smithyhttp.Response, metadata *middleware.Metadata) error { 434 var errorBuffer bytes.Buffer 435 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 436 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 437 } 438 errorBody := bytes.NewReader(errorBuffer.Bytes()) 439 440 errorCode := "UnknownError" 441 errorMessage := errorCode 442 443 code := response.Header.Get("X-Amzn-ErrorType") 444 if len(code) != 0 { 445 errorCode = restjson.SanitizeErrorCode(code) 446 } 447 448 var buff [1024]byte 449 ringBuffer := smithyio.NewRingBuffer(buff[:]) 450 451 body := io.TeeReader(errorBody, ringBuffer) 452 decoder := json.NewDecoder(body) 453 decoder.UseNumber() 454 code, message, err := restjson.GetErrorInfo(decoder) 455 if err != nil { 456 var snapshot bytes.Buffer 457 io.Copy(&snapshot, ringBuffer) 458 err = &smithy.DeserializationError{ 459 Err: fmt.Errorf("failed to decode response body, %w", err), 460 Snapshot: snapshot.Bytes(), 461 } 462 return err 463 } 464 465 errorBody.Seek(0, io.SeekStart) 466 if len(code) != 0 { 467 errorCode = restjson.SanitizeErrorCode(code) 468 } 469 if len(message) != 0 { 470 errorMessage = message 471 } 472 473 switch { 474 case strings.EqualFold("InvalidParametersException", errorCode): 475 return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody) 476 477 case strings.EqualFold("LimitExceededException", errorCode): 478 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 479 480 case strings.EqualFold("ResourceNotFoundException", errorCode): 481 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 482 483 default: 484 genericError := &smithy.GenericAPIError{ 485 Code: errorCode, 486 Message: errorMessage, 487 } 488 return genericError 489 490 } 491} 492 493type awsAwsjson11_deserializeOpAssociateServiceActionWithProvisioningArtifact struct { 494} 495 496func (*awsAwsjson11_deserializeOpAssociateServiceActionWithProvisioningArtifact) ID() string { 497 return "OperationDeserializer" 498} 499 500func (m *awsAwsjson11_deserializeOpAssociateServiceActionWithProvisioningArtifact) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 501 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 502) { 503 out, metadata, err = next.HandleDeserialize(ctx, in) 504 if err != nil { 505 return out, metadata, err 506 } 507 508 response, ok := out.RawResponse.(*smithyhttp.Response) 509 if !ok { 510 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 511 } 512 513 if response.StatusCode < 200 || response.StatusCode >= 300 { 514 return out, metadata, awsAwsjson11_deserializeOpErrorAssociateServiceActionWithProvisioningArtifact(response, &metadata) 515 } 516 output := &AssociateServiceActionWithProvisioningArtifactOutput{} 517 out.Result = output 518 519 var buff [1024]byte 520 ringBuffer := smithyio.NewRingBuffer(buff[:]) 521 522 body := io.TeeReader(response.Body, ringBuffer) 523 decoder := json.NewDecoder(body) 524 decoder.UseNumber() 525 var shape interface{} 526 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 527 var snapshot bytes.Buffer 528 io.Copy(&snapshot, ringBuffer) 529 err = &smithy.DeserializationError{ 530 Err: fmt.Errorf("failed to decode response body, %w", err), 531 Snapshot: snapshot.Bytes(), 532 } 533 return out, metadata, err 534 } 535 536 err = awsAwsjson11_deserializeOpDocumentAssociateServiceActionWithProvisioningArtifactOutput(&output, shape) 537 if err != nil { 538 var snapshot bytes.Buffer 539 io.Copy(&snapshot, ringBuffer) 540 err = &smithy.DeserializationError{ 541 Err: fmt.Errorf("failed to decode response body, %w", err), 542 Snapshot: snapshot.Bytes(), 543 } 544 return out, metadata, err 545 } 546 547 return out, metadata, err 548} 549 550func awsAwsjson11_deserializeOpErrorAssociateServiceActionWithProvisioningArtifact(response *smithyhttp.Response, metadata *middleware.Metadata) error { 551 var errorBuffer bytes.Buffer 552 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 553 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 554 } 555 errorBody := bytes.NewReader(errorBuffer.Bytes()) 556 557 errorCode := "UnknownError" 558 errorMessage := errorCode 559 560 code := response.Header.Get("X-Amzn-ErrorType") 561 if len(code) != 0 { 562 errorCode = restjson.SanitizeErrorCode(code) 563 } 564 565 var buff [1024]byte 566 ringBuffer := smithyio.NewRingBuffer(buff[:]) 567 568 body := io.TeeReader(errorBody, ringBuffer) 569 decoder := json.NewDecoder(body) 570 decoder.UseNumber() 571 code, message, err := restjson.GetErrorInfo(decoder) 572 if err != nil { 573 var snapshot bytes.Buffer 574 io.Copy(&snapshot, ringBuffer) 575 err = &smithy.DeserializationError{ 576 Err: fmt.Errorf("failed to decode response body, %w", err), 577 Snapshot: snapshot.Bytes(), 578 } 579 return err 580 } 581 582 errorBody.Seek(0, io.SeekStart) 583 if len(code) != 0 { 584 errorCode = restjson.SanitizeErrorCode(code) 585 } 586 if len(message) != 0 { 587 errorMessage = message 588 } 589 590 switch { 591 case strings.EqualFold("DuplicateResourceException", errorCode): 592 return awsAwsjson11_deserializeErrorDuplicateResourceException(response, errorBody) 593 594 case strings.EqualFold("LimitExceededException", errorCode): 595 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 596 597 case strings.EqualFold("ResourceNotFoundException", errorCode): 598 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 599 600 default: 601 genericError := &smithy.GenericAPIError{ 602 Code: errorCode, 603 Message: errorMessage, 604 } 605 return genericError 606 607 } 608} 609 610type awsAwsjson11_deserializeOpAssociateTagOptionWithResource struct { 611} 612 613func (*awsAwsjson11_deserializeOpAssociateTagOptionWithResource) ID() string { 614 return "OperationDeserializer" 615} 616 617func (m *awsAwsjson11_deserializeOpAssociateTagOptionWithResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 618 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 619) { 620 out, metadata, err = next.HandleDeserialize(ctx, in) 621 if err != nil { 622 return out, metadata, err 623 } 624 625 response, ok := out.RawResponse.(*smithyhttp.Response) 626 if !ok { 627 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 628 } 629 630 if response.StatusCode < 200 || response.StatusCode >= 300 { 631 return out, metadata, awsAwsjson11_deserializeOpErrorAssociateTagOptionWithResource(response, &metadata) 632 } 633 output := &AssociateTagOptionWithResourceOutput{} 634 out.Result = output 635 636 var buff [1024]byte 637 ringBuffer := smithyio.NewRingBuffer(buff[:]) 638 639 body := io.TeeReader(response.Body, ringBuffer) 640 decoder := json.NewDecoder(body) 641 decoder.UseNumber() 642 var shape interface{} 643 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 644 var snapshot bytes.Buffer 645 io.Copy(&snapshot, ringBuffer) 646 err = &smithy.DeserializationError{ 647 Err: fmt.Errorf("failed to decode response body, %w", err), 648 Snapshot: snapshot.Bytes(), 649 } 650 return out, metadata, err 651 } 652 653 err = awsAwsjson11_deserializeOpDocumentAssociateTagOptionWithResourceOutput(&output, shape) 654 if err != nil { 655 var snapshot bytes.Buffer 656 io.Copy(&snapshot, ringBuffer) 657 err = &smithy.DeserializationError{ 658 Err: fmt.Errorf("failed to decode response body, %w", err), 659 Snapshot: snapshot.Bytes(), 660 } 661 return out, metadata, err 662 } 663 664 return out, metadata, err 665} 666 667func awsAwsjson11_deserializeOpErrorAssociateTagOptionWithResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 668 var errorBuffer bytes.Buffer 669 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 670 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 671 } 672 errorBody := bytes.NewReader(errorBuffer.Bytes()) 673 674 errorCode := "UnknownError" 675 errorMessage := errorCode 676 677 code := response.Header.Get("X-Amzn-ErrorType") 678 if len(code) != 0 { 679 errorCode = restjson.SanitizeErrorCode(code) 680 } 681 682 var buff [1024]byte 683 ringBuffer := smithyio.NewRingBuffer(buff[:]) 684 685 body := io.TeeReader(errorBody, ringBuffer) 686 decoder := json.NewDecoder(body) 687 decoder.UseNumber() 688 code, message, err := restjson.GetErrorInfo(decoder) 689 if err != nil { 690 var snapshot bytes.Buffer 691 io.Copy(&snapshot, ringBuffer) 692 err = &smithy.DeserializationError{ 693 Err: fmt.Errorf("failed to decode response body, %w", err), 694 Snapshot: snapshot.Bytes(), 695 } 696 return err 697 } 698 699 errorBody.Seek(0, io.SeekStart) 700 if len(code) != 0 { 701 errorCode = restjson.SanitizeErrorCode(code) 702 } 703 if len(message) != 0 { 704 errorMessage = message 705 } 706 707 switch { 708 case strings.EqualFold("DuplicateResourceException", errorCode): 709 return awsAwsjson11_deserializeErrorDuplicateResourceException(response, errorBody) 710 711 case strings.EqualFold("InvalidParametersException", errorCode): 712 return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody) 713 714 case strings.EqualFold("InvalidStateException", errorCode): 715 return awsAwsjson11_deserializeErrorInvalidStateException(response, errorBody) 716 717 case strings.EqualFold("LimitExceededException", errorCode): 718 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 719 720 case strings.EqualFold("ResourceNotFoundException", errorCode): 721 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 722 723 case strings.EqualFold("TagOptionNotMigratedException", errorCode): 724 return awsAwsjson11_deserializeErrorTagOptionNotMigratedException(response, errorBody) 725 726 default: 727 genericError := &smithy.GenericAPIError{ 728 Code: errorCode, 729 Message: errorMessage, 730 } 731 return genericError 732 733 } 734} 735 736type awsAwsjson11_deserializeOpBatchAssociateServiceActionWithProvisioningArtifact struct { 737} 738 739func (*awsAwsjson11_deserializeOpBatchAssociateServiceActionWithProvisioningArtifact) ID() string { 740 return "OperationDeserializer" 741} 742 743func (m *awsAwsjson11_deserializeOpBatchAssociateServiceActionWithProvisioningArtifact) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 744 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 745) { 746 out, metadata, err = next.HandleDeserialize(ctx, in) 747 if err != nil { 748 return out, metadata, err 749 } 750 751 response, ok := out.RawResponse.(*smithyhttp.Response) 752 if !ok { 753 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 754 } 755 756 if response.StatusCode < 200 || response.StatusCode >= 300 { 757 return out, metadata, awsAwsjson11_deserializeOpErrorBatchAssociateServiceActionWithProvisioningArtifact(response, &metadata) 758 } 759 output := &BatchAssociateServiceActionWithProvisioningArtifactOutput{} 760 out.Result = output 761 762 var buff [1024]byte 763 ringBuffer := smithyio.NewRingBuffer(buff[:]) 764 765 body := io.TeeReader(response.Body, ringBuffer) 766 decoder := json.NewDecoder(body) 767 decoder.UseNumber() 768 var shape interface{} 769 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 770 var snapshot bytes.Buffer 771 io.Copy(&snapshot, ringBuffer) 772 err = &smithy.DeserializationError{ 773 Err: fmt.Errorf("failed to decode response body, %w", err), 774 Snapshot: snapshot.Bytes(), 775 } 776 return out, metadata, err 777 } 778 779 err = awsAwsjson11_deserializeOpDocumentBatchAssociateServiceActionWithProvisioningArtifactOutput(&output, shape) 780 if err != nil { 781 var snapshot bytes.Buffer 782 io.Copy(&snapshot, ringBuffer) 783 err = &smithy.DeserializationError{ 784 Err: fmt.Errorf("failed to decode response body, %w", err), 785 Snapshot: snapshot.Bytes(), 786 } 787 return out, metadata, err 788 } 789 790 return out, metadata, err 791} 792 793func awsAwsjson11_deserializeOpErrorBatchAssociateServiceActionWithProvisioningArtifact(response *smithyhttp.Response, metadata *middleware.Metadata) error { 794 var errorBuffer bytes.Buffer 795 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 796 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 797 } 798 errorBody := bytes.NewReader(errorBuffer.Bytes()) 799 800 errorCode := "UnknownError" 801 errorMessage := errorCode 802 803 code := response.Header.Get("X-Amzn-ErrorType") 804 if len(code) != 0 { 805 errorCode = restjson.SanitizeErrorCode(code) 806 } 807 808 var buff [1024]byte 809 ringBuffer := smithyio.NewRingBuffer(buff[:]) 810 811 body := io.TeeReader(errorBody, ringBuffer) 812 decoder := json.NewDecoder(body) 813 decoder.UseNumber() 814 code, message, err := restjson.GetErrorInfo(decoder) 815 if err != nil { 816 var snapshot bytes.Buffer 817 io.Copy(&snapshot, ringBuffer) 818 err = &smithy.DeserializationError{ 819 Err: fmt.Errorf("failed to decode response body, %w", err), 820 Snapshot: snapshot.Bytes(), 821 } 822 return err 823 } 824 825 errorBody.Seek(0, io.SeekStart) 826 if len(code) != 0 { 827 errorCode = restjson.SanitizeErrorCode(code) 828 } 829 if len(message) != 0 { 830 errorMessage = message 831 } 832 833 switch { 834 case strings.EqualFold("InvalidParametersException", errorCode): 835 return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody) 836 837 default: 838 genericError := &smithy.GenericAPIError{ 839 Code: errorCode, 840 Message: errorMessage, 841 } 842 return genericError 843 844 } 845} 846 847type awsAwsjson11_deserializeOpBatchDisassociateServiceActionFromProvisioningArtifact struct { 848} 849 850func (*awsAwsjson11_deserializeOpBatchDisassociateServiceActionFromProvisioningArtifact) ID() string { 851 return "OperationDeserializer" 852} 853 854func (m *awsAwsjson11_deserializeOpBatchDisassociateServiceActionFromProvisioningArtifact) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 855 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 856) { 857 out, metadata, err = next.HandleDeserialize(ctx, in) 858 if err != nil { 859 return out, metadata, err 860 } 861 862 response, ok := out.RawResponse.(*smithyhttp.Response) 863 if !ok { 864 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 865 } 866 867 if response.StatusCode < 200 || response.StatusCode >= 300 { 868 return out, metadata, awsAwsjson11_deserializeOpErrorBatchDisassociateServiceActionFromProvisioningArtifact(response, &metadata) 869 } 870 output := &BatchDisassociateServiceActionFromProvisioningArtifactOutput{} 871 out.Result = output 872 873 var buff [1024]byte 874 ringBuffer := smithyio.NewRingBuffer(buff[:]) 875 876 body := io.TeeReader(response.Body, ringBuffer) 877 decoder := json.NewDecoder(body) 878 decoder.UseNumber() 879 var shape interface{} 880 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 881 var snapshot bytes.Buffer 882 io.Copy(&snapshot, ringBuffer) 883 err = &smithy.DeserializationError{ 884 Err: fmt.Errorf("failed to decode response body, %w", err), 885 Snapshot: snapshot.Bytes(), 886 } 887 return out, metadata, err 888 } 889 890 err = awsAwsjson11_deserializeOpDocumentBatchDisassociateServiceActionFromProvisioningArtifactOutput(&output, shape) 891 if err != nil { 892 var snapshot bytes.Buffer 893 io.Copy(&snapshot, ringBuffer) 894 err = &smithy.DeserializationError{ 895 Err: fmt.Errorf("failed to decode response body, %w", err), 896 Snapshot: snapshot.Bytes(), 897 } 898 return out, metadata, err 899 } 900 901 return out, metadata, err 902} 903 904func awsAwsjson11_deserializeOpErrorBatchDisassociateServiceActionFromProvisioningArtifact(response *smithyhttp.Response, metadata *middleware.Metadata) error { 905 var errorBuffer bytes.Buffer 906 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 907 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 908 } 909 errorBody := bytes.NewReader(errorBuffer.Bytes()) 910 911 errorCode := "UnknownError" 912 errorMessage := errorCode 913 914 code := response.Header.Get("X-Amzn-ErrorType") 915 if len(code) != 0 { 916 errorCode = restjson.SanitizeErrorCode(code) 917 } 918 919 var buff [1024]byte 920 ringBuffer := smithyio.NewRingBuffer(buff[:]) 921 922 body := io.TeeReader(errorBody, ringBuffer) 923 decoder := json.NewDecoder(body) 924 decoder.UseNumber() 925 code, message, err := restjson.GetErrorInfo(decoder) 926 if err != nil { 927 var snapshot bytes.Buffer 928 io.Copy(&snapshot, ringBuffer) 929 err = &smithy.DeserializationError{ 930 Err: fmt.Errorf("failed to decode response body, %w", err), 931 Snapshot: snapshot.Bytes(), 932 } 933 return err 934 } 935 936 errorBody.Seek(0, io.SeekStart) 937 if len(code) != 0 { 938 errorCode = restjson.SanitizeErrorCode(code) 939 } 940 if len(message) != 0 { 941 errorMessage = message 942 } 943 944 switch { 945 case strings.EqualFold("InvalidParametersException", errorCode): 946 return awsAwsjson11_deserializeErrorInvalidParametersException(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_deserializeOpCopyProduct struct { 959} 960 961func (*awsAwsjson11_deserializeOpCopyProduct) ID() string { 962 return "OperationDeserializer" 963} 964 965func (m *awsAwsjson11_deserializeOpCopyProduct) 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_deserializeOpErrorCopyProduct(response, &metadata) 980 } 981 output := &CopyProductOutput{} 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_deserializeOpDocumentCopyProductOutput(&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_deserializeOpErrorCopyProduct(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("InvalidParametersException", errorCode): 1057 return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody) 1058 1059 case strings.EqualFold("ResourceNotFoundException", errorCode): 1060 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 1061 1062 default: 1063 genericError := &smithy.GenericAPIError{ 1064 Code: errorCode, 1065 Message: errorMessage, 1066 } 1067 return genericError 1068 1069 } 1070} 1071 1072type awsAwsjson11_deserializeOpCreateConstraint struct { 1073} 1074 1075func (*awsAwsjson11_deserializeOpCreateConstraint) ID() string { 1076 return "OperationDeserializer" 1077} 1078 1079func (m *awsAwsjson11_deserializeOpCreateConstraint) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1080 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1081) { 1082 out, metadata, err = next.HandleDeserialize(ctx, in) 1083 if err != nil { 1084 return out, metadata, err 1085 } 1086 1087 response, ok := out.RawResponse.(*smithyhttp.Response) 1088 if !ok { 1089 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1090 } 1091 1092 if response.StatusCode < 200 || response.StatusCode >= 300 { 1093 return out, metadata, awsAwsjson11_deserializeOpErrorCreateConstraint(response, &metadata) 1094 } 1095 output := &CreateConstraintOutput{} 1096 out.Result = output 1097 1098 var buff [1024]byte 1099 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1100 1101 body := io.TeeReader(response.Body, ringBuffer) 1102 decoder := json.NewDecoder(body) 1103 decoder.UseNumber() 1104 var shape interface{} 1105 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1106 var snapshot bytes.Buffer 1107 io.Copy(&snapshot, ringBuffer) 1108 err = &smithy.DeserializationError{ 1109 Err: fmt.Errorf("failed to decode response body, %w", err), 1110 Snapshot: snapshot.Bytes(), 1111 } 1112 return out, metadata, err 1113 } 1114 1115 err = awsAwsjson11_deserializeOpDocumentCreateConstraintOutput(&output, shape) 1116 if err != nil { 1117 var snapshot bytes.Buffer 1118 io.Copy(&snapshot, ringBuffer) 1119 err = &smithy.DeserializationError{ 1120 Err: fmt.Errorf("failed to decode response body, %w", err), 1121 Snapshot: snapshot.Bytes(), 1122 } 1123 return out, metadata, err 1124 } 1125 1126 return out, metadata, err 1127} 1128 1129func awsAwsjson11_deserializeOpErrorCreateConstraint(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1130 var errorBuffer bytes.Buffer 1131 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1132 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1133 } 1134 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1135 1136 errorCode := "UnknownError" 1137 errorMessage := errorCode 1138 1139 code := response.Header.Get("X-Amzn-ErrorType") 1140 if len(code) != 0 { 1141 errorCode = restjson.SanitizeErrorCode(code) 1142 } 1143 1144 var buff [1024]byte 1145 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1146 1147 body := io.TeeReader(errorBody, ringBuffer) 1148 decoder := json.NewDecoder(body) 1149 decoder.UseNumber() 1150 code, message, err := restjson.GetErrorInfo(decoder) 1151 if err != nil { 1152 var snapshot bytes.Buffer 1153 io.Copy(&snapshot, ringBuffer) 1154 err = &smithy.DeserializationError{ 1155 Err: fmt.Errorf("failed to decode response body, %w", err), 1156 Snapshot: snapshot.Bytes(), 1157 } 1158 return err 1159 } 1160 1161 errorBody.Seek(0, io.SeekStart) 1162 if len(code) != 0 { 1163 errorCode = restjson.SanitizeErrorCode(code) 1164 } 1165 if len(message) != 0 { 1166 errorMessage = message 1167 } 1168 1169 switch { 1170 case strings.EqualFold("DuplicateResourceException", errorCode): 1171 return awsAwsjson11_deserializeErrorDuplicateResourceException(response, errorBody) 1172 1173 case strings.EqualFold("InvalidParametersException", errorCode): 1174 return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody) 1175 1176 case strings.EqualFold("LimitExceededException", errorCode): 1177 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 1178 1179 case strings.EqualFold("ResourceNotFoundException", errorCode): 1180 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 1181 1182 default: 1183 genericError := &smithy.GenericAPIError{ 1184 Code: errorCode, 1185 Message: errorMessage, 1186 } 1187 return genericError 1188 1189 } 1190} 1191 1192type awsAwsjson11_deserializeOpCreatePortfolio struct { 1193} 1194 1195func (*awsAwsjson11_deserializeOpCreatePortfolio) ID() string { 1196 return "OperationDeserializer" 1197} 1198 1199func (m *awsAwsjson11_deserializeOpCreatePortfolio) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1200 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1201) { 1202 out, metadata, err = next.HandleDeserialize(ctx, in) 1203 if err != nil { 1204 return out, metadata, err 1205 } 1206 1207 response, ok := out.RawResponse.(*smithyhttp.Response) 1208 if !ok { 1209 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1210 } 1211 1212 if response.StatusCode < 200 || response.StatusCode >= 300 { 1213 return out, metadata, awsAwsjson11_deserializeOpErrorCreatePortfolio(response, &metadata) 1214 } 1215 output := &CreatePortfolioOutput{} 1216 out.Result = output 1217 1218 var buff [1024]byte 1219 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1220 1221 body := io.TeeReader(response.Body, ringBuffer) 1222 decoder := json.NewDecoder(body) 1223 decoder.UseNumber() 1224 var shape interface{} 1225 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1226 var snapshot bytes.Buffer 1227 io.Copy(&snapshot, ringBuffer) 1228 err = &smithy.DeserializationError{ 1229 Err: fmt.Errorf("failed to decode response body, %w", err), 1230 Snapshot: snapshot.Bytes(), 1231 } 1232 return out, metadata, err 1233 } 1234 1235 err = awsAwsjson11_deserializeOpDocumentCreatePortfolioOutput(&output, shape) 1236 if err != nil { 1237 var snapshot bytes.Buffer 1238 io.Copy(&snapshot, ringBuffer) 1239 err = &smithy.DeserializationError{ 1240 Err: fmt.Errorf("failed to decode response body, %w", err), 1241 Snapshot: snapshot.Bytes(), 1242 } 1243 return out, metadata, err 1244 } 1245 1246 return out, metadata, err 1247} 1248 1249func awsAwsjson11_deserializeOpErrorCreatePortfolio(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1250 var errorBuffer bytes.Buffer 1251 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1252 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1253 } 1254 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1255 1256 errorCode := "UnknownError" 1257 errorMessage := errorCode 1258 1259 code := response.Header.Get("X-Amzn-ErrorType") 1260 if len(code) != 0 { 1261 errorCode = restjson.SanitizeErrorCode(code) 1262 } 1263 1264 var buff [1024]byte 1265 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1266 1267 body := io.TeeReader(errorBody, ringBuffer) 1268 decoder := json.NewDecoder(body) 1269 decoder.UseNumber() 1270 code, message, err := restjson.GetErrorInfo(decoder) 1271 if err != nil { 1272 var snapshot bytes.Buffer 1273 io.Copy(&snapshot, ringBuffer) 1274 err = &smithy.DeserializationError{ 1275 Err: fmt.Errorf("failed to decode response body, %w", err), 1276 Snapshot: snapshot.Bytes(), 1277 } 1278 return err 1279 } 1280 1281 errorBody.Seek(0, io.SeekStart) 1282 if len(code) != 0 { 1283 errorCode = restjson.SanitizeErrorCode(code) 1284 } 1285 if len(message) != 0 { 1286 errorMessage = message 1287 } 1288 1289 switch { 1290 case strings.EqualFold("InvalidParametersException", errorCode): 1291 return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody) 1292 1293 case strings.EqualFold("LimitExceededException", errorCode): 1294 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 1295 1296 case strings.EqualFold("TagOptionNotMigratedException", errorCode): 1297 return awsAwsjson11_deserializeErrorTagOptionNotMigratedException(response, errorBody) 1298 1299 default: 1300 genericError := &smithy.GenericAPIError{ 1301 Code: errorCode, 1302 Message: errorMessage, 1303 } 1304 return genericError 1305 1306 } 1307} 1308 1309type awsAwsjson11_deserializeOpCreatePortfolioShare struct { 1310} 1311 1312func (*awsAwsjson11_deserializeOpCreatePortfolioShare) ID() string { 1313 return "OperationDeserializer" 1314} 1315 1316func (m *awsAwsjson11_deserializeOpCreatePortfolioShare) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1317 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1318) { 1319 out, metadata, err = next.HandleDeserialize(ctx, in) 1320 if err != nil { 1321 return out, metadata, err 1322 } 1323 1324 response, ok := out.RawResponse.(*smithyhttp.Response) 1325 if !ok { 1326 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1327 } 1328 1329 if response.StatusCode < 200 || response.StatusCode >= 300 { 1330 return out, metadata, awsAwsjson11_deserializeOpErrorCreatePortfolioShare(response, &metadata) 1331 } 1332 output := &CreatePortfolioShareOutput{} 1333 out.Result = output 1334 1335 var buff [1024]byte 1336 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1337 1338 body := io.TeeReader(response.Body, ringBuffer) 1339 decoder := json.NewDecoder(body) 1340 decoder.UseNumber() 1341 var shape interface{} 1342 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1343 var snapshot bytes.Buffer 1344 io.Copy(&snapshot, ringBuffer) 1345 err = &smithy.DeserializationError{ 1346 Err: fmt.Errorf("failed to decode response body, %w", err), 1347 Snapshot: snapshot.Bytes(), 1348 } 1349 return out, metadata, err 1350 } 1351 1352 err = awsAwsjson11_deserializeOpDocumentCreatePortfolioShareOutput(&output, shape) 1353 if err != nil { 1354 var snapshot bytes.Buffer 1355 io.Copy(&snapshot, ringBuffer) 1356 err = &smithy.DeserializationError{ 1357 Err: fmt.Errorf("failed to decode response body, %w", err), 1358 Snapshot: snapshot.Bytes(), 1359 } 1360 return out, metadata, err 1361 } 1362 1363 return out, metadata, err 1364} 1365 1366func awsAwsjson11_deserializeOpErrorCreatePortfolioShare(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1367 var errorBuffer bytes.Buffer 1368 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1369 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1370 } 1371 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1372 1373 errorCode := "UnknownError" 1374 errorMessage := errorCode 1375 1376 code := response.Header.Get("X-Amzn-ErrorType") 1377 if len(code) != 0 { 1378 errorCode = restjson.SanitizeErrorCode(code) 1379 } 1380 1381 var buff [1024]byte 1382 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1383 1384 body := io.TeeReader(errorBody, ringBuffer) 1385 decoder := json.NewDecoder(body) 1386 decoder.UseNumber() 1387 code, message, err := restjson.GetErrorInfo(decoder) 1388 if err != nil { 1389 var snapshot bytes.Buffer 1390 io.Copy(&snapshot, ringBuffer) 1391 err = &smithy.DeserializationError{ 1392 Err: fmt.Errorf("failed to decode response body, %w", err), 1393 Snapshot: snapshot.Bytes(), 1394 } 1395 return err 1396 } 1397 1398 errorBody.Seek(0, io.SeekStart) 1399 if len(code) != 0 { 1400 errorCode = restjson.SanitizeErrorCode(code) 1401 } 1402 if len(message) != 0 { 1403 errorMessage = message 1404 } 1405 1406 switch { 1407 case strings.EqualFold("InvalidParametersException", errorCode): 1408 return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody) 1409 1410 case strings.EqualFold("InvalidStateException", errorCode): 1411 return awsAwsjson11_deserializeErrorInvalidStateException(response, errorBody) 1412 1413 case strings.EqualFold("LimitExceededException", errorCode): 1414 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 1415 1416 case strings.EqualFold("OperationNotSupportedException", errorCode): 1417 return awsAwsjson11_deserializeErrorOperationNotSupportedException(response, errorBody) 1418 1419 case strings.EqualFold("ResourceNotFoundException", errorCode): 1420 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 1421 1422 default: 1423 genericError := &smithy.GenericAPIError{ 1424 Code: errorCode, 1425 Message: errorMessage, 1426 } 1427 return genericError 1428 1429 } 1430} 1431 1432type awsAwsjson11_deserializeOpCreateProduct struct { 1433} 1434 1435func (*awsAwsjson11_deserializeOpCreateProduct) ID() string { 1436 return "OperationDeserializer" 1437} 1438 1439func (m *awsAwsjson11_deserializeOpCreateProduct) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1440 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1441) { 1442 out, metadata, err = next.HandleDeserialize(ctx, in) 1443 if err != nil { 1444 return out, metadata, err 1445 } 1446 1447 response, ok := out.RawResponse.(*smithyhttp.Response) 1448 if !ok { 1449 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1450 } 1451 1452 if response.StatusCode < 200 || response.StatusCode >= 300 { 1453 return out, metadata, awsAwsjson11_deserializeOpErrorCreateProduct(response, &metadata) 1454 } 1455 output := &CreateProductOutput{} 1456 out.Result = output 1457 1458 var buff [1024]byte 1459 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1460 1461 body := io.TeeReader(response.Body, ringBuffer) 1462 decoder := json.NewDecoder(body) 1463 decoder.UseNumber() 1464 var shape interface{} 1465 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1466 var snapshot bytes.Buffer 1467 io.Copy(&snapshot, ringBuffer) 1468 err = &smithy.DeserializationError{ 1469 Err: fmt.Errorf("failed to decode response body, %w", err), 1470 Snapshot: snapshot.Bytes(), 1471 } 1472 return out, metadata, err 1473 } 1474 1475 err = awsAwsjson11_deserializeOpDocumentCreateProductOutput(&output, shape) 1476 if err != nil { 1477 var snapshot bytes.Buffer 1478 io.Copy(&snapshot, ringBuffer) 1479 err = &smithy.DeserializationError{ 1480 Err: fmt.Errorf("failed to decode response body, %w", err), 1481 Snapshot: snapshot.Bytes(), 1482 } 1483 return out, metadata, err 1484 } 1485 1486 return out, metadata, err 1487} 1488 1489func awsAwsjson11_deserializeOpErrorCreateProduct(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1490 var errorBuffer bytes.Buffer 1491 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1492 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1493 } 1494 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1495 1496 errorCode := "UnknownError" 1497 errorMessage := errorCode 1498 1499 code := response.Header.Get("X-Amzn-ErrorType") 1500 if len(code) != 0 { 1501 errorCode = restjson.SanitizeErrorCode(code) 1502 } 1503 1504 var buff [1024]byte 1505 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1506 1507 body := io.TeeReader(errorBody, ringBuffer) 1508 decoder := json.NewDecoder(body) 1509 decoder.UseNumber() 1510 code, message, err := restjson.GetErrorInfo(decoder) 1511 if err != nil { 1512 var snapshot bytes.Buffer 1513 io.Copy(&snapshot, ringBuffer) 1514 err = &smithy.DeserializationError{ 1515 Err: fmt.Errorf("failed to decode response body, %w", err), 1516 Snapshot: snapshot.Bytes(), 1517 } 1518 return err 1519 } 1520 1521 errorBody.Seek(0, io.SeekStart) 1522 if len(code) != 0 { 1523 errorCode = restjson.SanitizeErrorCode(code) 1524 } 1525 if len(message) != 0 { 1526 errorMessage = message 1527 } 1528 1529 switch { 1530 case strings.EqualFold("InvalidParametersException", errorCode): 1531 return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody) 1532 1533 case strings.EqualFold("LimitExceededException", errorCode): 1534 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 1535 1536 case strings.EqualFold("TagOptionNotMigratedException", errorCode): 1537 return awsAwsjson11_deserializeErrorTagOptionNotMigratedException(response, errorBody) 1538 1539 default: 1540 genericError := &smithy.GenericAPIError{ 1541 Code: errorCode, 1542 Message: errorMessage, 1543 } 1544 return genericError 1545 1546 } 1547} 1548 1549type awsAwsjson11_deserializeOpCreateProvisionedProductPlan struct { 1550} 1551 1552func (*awsAwsjson11_deserializeOpCreateProvisionedProductPlan) ID() string { 1553 return "OperationDeserializer" 1554} 1555 1556func (m *awsAwsjson11_deserializeOpCreateProvisionedProductPlan) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1557 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1558) { 1559 out, metadata, err = next.HandleDeserialize(ctx, in) 1560 if err != nil { 1561 return out, metadata, err 1562 } 1563 1564 response, ok := out.RawResponse.(*smithyhttp.Response) 1565 if !ok { 1566 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1567 } 1568 1569 if response.StatusCode < 200 || response.StatusCode >= 300 { 1570 return out, metadata, awsAwsjson11_deserializeOpErrorCreateProvisionedProductPlan(response, &metadata) 1571 } 1572 output := &CreateProvisionedProductPlanOutput{} 1573 out.Result = output 1574 1575 var buff [1024]byte 1576 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1577 1578 body := io.TeeReader(response.Body, ringBuffer) 1579 decoder := json.NewDecoder(body) 1580 decoder.UseNumber() 1581 var shape interface{} 1582 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1583 var snapshot bytes.Buffer 1584 io.Copy(&snapshot, ringBuffer) 1585 err = &smithy.DeserializationError{ 1586 Err: fmt.Errorf("failed to decode response body, %w", err), 1587 Snapshot: snapshot.Bytes(), 1588 } 1589 return out, metadata, err 1590 } 1591 1592 err = awsAwsjson11_deserializeOpDocumentCreateProvisionedProductPlanOutput(&output, shape) 1593 if err != nil { 1594 var snapshot bytes.Buffer 1595 io.Copy(&snapshot, ringBuffer) 1596 err = &smithy.DeserializationError{ 1597 Err: fmt.Errorf("failed to decode response body, %w", err), 1598 Snapshot: snapshot.Bytes(), 1599 } 1600 return out, metadata, err 1601 } 1602 1603 return out, metadata, err 1604} 1605 1606func awsAwsjson11_deserializeOpErrorCreateProvisionedProductPlan(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1607 var errorBuffer bytes.Buffer 1608 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1609 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1610 } 1611 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1612 1613 errorCode := "UnknownError" 1614 errorMessage := errorCode 1615 1616 code := response.Header.Get("X-Amzn-ErrorType") 1617 if len(code) != 0 { 1618 errorCode = restjson.SanitizeErrorCode(code) 1619 } 1620 1621 var buff [1024]byte 1622 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1623 1624 body := io.TeeReader(errorBody, ringBuffer) 1625 decoder := json.NewDecoder(body) 1626 decoder.UseNumber() 1627 code, message, err := restjson.GetErrorInfo(decoder) 1628 if err != nil { 1629 var snapshot bytes.Buffer 1630 io.Copy(&snapshot, ringBuffer) 1631 err = &smithy.DeserializationError{ 1632 Err: fmt.Errorf("failed to decode response body, %w", err), 1633 Snapshot: snapshot.Bytes(), 1634 } 1635 return err 1636 } 1637 1638 errorBody.Seek(0, io.SeekStart) 1639 if len(code) != 0 { 1640 errorCode = restjson.SanitizeErrorCode(code) 1641 } 1642 if len(message) != 0 { 1643 errorMessage = message 1644 } 1645 1646 switch { 1647 case strings.EqualFold("InvalidParametersException", errorCode): 1648 return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody) 1649 1650 case strings.EqualFold("InvalidStateException", errorCode): 1651 return awsAwsjson11_deserializeErrorInvalidStateException(response, errorBody) 1652 1653 case strings.EqualFold("ResourceNotFoundException", errorCode): 1654 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 1655 1656 default: 1657 genericError := &smithy.GenericAPIError{ 1658 Code: errorCode, 1659 Message: errorMessage, 1660 } 1661 return genericError 1662 1663 } 1664} 1665 1666type awsAwsjson11_deserializeOpCreateProvisioningArtifact struct { 1667} 1668 1669func (*awsAwsjson11_deserializeOpCreateProvisioningArtifact) ID() string { 1670 return "OperationDeserializer" 1671} 1672 1673func (m *awsAwsjson11_deserializeOpCreateProvisioningArtifact) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1674 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1675) { 1676 out, metadata, err = next.HandleDeserialize(ctx, in) 1677 if err != nil { 1678 return out, metadata, err 1679 } 1680 1681 response, ok := out.RawResponse.(*smithyhttp.Response) 1682 if !ok { 1683 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1684 } 1685 1686 if response.StatusCode < 200 || response.StatusCode >= 300 { 1687 return out, metadata, awsAwsjson11_deserializeOpErrorCreateProvisioningArtifact(response, &metadata) 1688 } 1689 output := &CreateProvisioningArtifactOutput{} 1690 out.Result = output 1691 1692 var buff [1024]byte 1693 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1694 1695 body := io.TeeReader(response.Body, ringBuffer) 1696 decoder := json.NewDecoder(body) 1697 decoder.UseNumber() 1698 var shape interface{} 1699 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1700 var snapshot bytes.Buffer 1701 io.Copy(&snapshot, ringBuffer) 1702 err = &smithy.DeserializationError{ 1703 Err: fmt.Errorf("failed to decode response body, %w", err), 1704 Snapshot: snapshot.Bytes(), 1705 } 1706 return out, metadata, err 1707 } 1708 1709 err = awsAwsjson11_deserializeOpDocumentCreateProvisioningArtifactOutput(&output, shape) 1710 if err != nil { 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 return out, metadata, err 1721} 1722 1723func awsAwsjson11_deserializeOpErrorCreateProvisioningArtifact(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1724 var errorBuffer bytes.Buffer 1725 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1726 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1727 } 1728 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1729 1730 errorCode := "UnknownError" 1731 errorMessage := errorCode 1732 1733 code := response.Header.Get("X-Amzn-ErrorType") 1734 if len(code) != 0 { 1735 errorCode = restjson.SanitizeErrorCode(code) 1736 } 1737 1738 var buff [1024]byte 1739 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1740 1741 body := io.TeeReader(errorBody, ringBuffer) 1742 decoder := json.NewDecoder(body) 1743 decoder.UseNumber() 1744 code, message, err := restjson.GetErrorInfo(decoder) 1745 if err != nil { 1746 var snapshot bytes.Buffer 1747 io.Copy(&snapshot, ringBuffer) 1748 err = &smithy.DeserializationError{ 1749 Err: fmt.Errorf("failed to decode response body, %w", err), 1750 Snapshot: snapshot.Bytes(), 1751 } 1752 return err 1753 } 1754 1755 errorBody.Seek(0, io.SeekStart) 1756 if len(code) != 0 { 1757 errorCode = restjson.SanitizeErrorCode(code) 1758 } 1759 if len(message) != 0 { 1760 errorMessage = message 1761 } 1762 1763 switch { 1764 case strings.EqualFold("InvalidParametersException", errorCode): 1765 return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody) 1766 1767 case strings.EqualFold("LimitExceededException", errorCode): 1768 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 1769 1770 case strings.EqualFold("ResourceNotFoundException", errorCode): 1771 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 1772 1773 default: 1774 genericError := &smithy.GenericAPIError{ 1775 Code: errorCode, 1776 Message: errorMessage, 1777 } 1778 return genericError 1779 1780 } 1781} 1782 1783type awsAwsjson11_deserializeOpCreateServiceAction struct { 1784} 1785 1786func (*awsAwsjson11_deserializeOpCreateServiceAction) ID() string { 1787 return "OperationDeserializer" 1788} 1789 1790func (m *awsAwsjson11_deserializeOpCreateServiceAction) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1791 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1792) { 1793 out, metadata, err = next.HandleDeserialize(ctx, in) 1794 if err != nil { 1795 return out, metadata, err 1796 } 1797 1798 response, ok := out.RawResponse.(*smithyhttp.Response) 1799 if !ok { 1800 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1801 } 1802 1803 if response.StatusCode < 200 || response.StatusCode >= 300 { 1804 return out, metadata, awsAwsjson11_deserializeOpErrorCreateServiceAction(response, &metadata) 1805 } 1806 output := &CreateServiceActionOutput{} 1807 out.Result = output 1808 1809 var buff [1024]byte 1810 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1811 1812 body := io.TeeReader(response.Body, ringBuffer) 1813 decoder := json.NewDecoder(body) 1814 decoder.UseNumber() 1815 var shape interface{} 1816 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1817 var snapshot bytes.Buffer 1818 io.Copy(&snapshot, ringBuffer) 1819 err = &smithy.DeserializationError{ 1820 Err: fmt.Errorf("failed to decode response body, %w", err), 1821 Snapshot: snapshot.Bytes(), 1822 } 1823 return out, metadata, err 1824 } 1825 1826 err = awsAwsjson11_deserializeOpDocumentCreateServiceActionOutput(&output, shape) 1827 if err != nil { 1828 var snapshot bytes.Buffer 1829 io.Copy(&snapshot, ringBuffer) 1830 err = &smithy.DeserializationError{ 1831 Err: fmt.Errorf("failed to decode response body, %w", err), 1832 Snapshot: snapshot.Bytes(), 1833 } 1834 return out, metadata, err 1835 } 1836 1837 return out, metadata, err 1838} 1839 1840func awsAwsjson11_deserializeOpErrorCreateServiceAction(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1841 var errorBuffer bytes.Buffer 1842 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1843 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1844 } 1845 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1846 1847 errorCode := "UnknownError" 1848 errorMessage := errorCode 1849 1850 code := response.Header.Get("X-Amzn-ErrorType") 1851 if len(code) != 0 { 1852 errorCode = restjson.SanitizeErrorCode(code) 1853 } 1854 1855 var buff [1024]byte 1856 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1857 1858 body := io.TeeReader(errorBody, ringBuffer) 1859 decoder := json.NewDecoder(body) 1860 decoder.UseNumber() 1861 code, message, err := restjson.GetErrorInfo(decoder) 1862 if err != nil { 1863 var snapshot bytes.Buffer 1864 io.Copy(&snapshot, ringBuffer) 1865 err = &smithy.DeserializationError{ 1866 Err: fmt.Errorf("failed to decode response body, %w", err), 1867 Snapshot: snapshot.Bytes(), 1868 } 1869 return err 1870 } 1871 1872 errorBody.Seek(0, io.SeekStart) 1873 if len(code) != 0 { 1874 errorCode = restjson.SanitizeErrorCode(code) 1875 } 1876 if len(message) != 0 { 1877 errorMessage = message 1878 } 1879 1880 switch { 1881 case strings.EqualFold("InvalidParametersException", errorCode): 1882 return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody) 1883 1884 case strings.EqualFold("LimitExceededException", errorCode): 1885 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 1886 1887 default: 1888 genericError := &smithy.GenericAPIError{ 1889 Code: errorCode, 1890 Message: errorMessage, 1891 } 1892 return genericError 1893 1894 } 1895} 1896 1897type awsAwsjson11_deserializeOpCreateTagOption struct { 1898} 1899 1900func (*awsAwsjson11_deserializeOpCreateTagOption) ID() string { 1901 return "OperationDeserializer" 1902} 1903 1904func (m *awsAwsjson11_deserializeOpCreateTagOption) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1905 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1906) { 1907 out, metadata, err = next.HandleDeserialize(ctx, in) 1908 if err != nil { 1909 return out, metadata, err 1910 } 1911 1912 response, ok := out.RawResponse.(*smithyhttp.Response) 1913 if !ok { 1914 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1915 } 1916 1917 if response.StatusCode < 200 || response.StatusCode >= 300 { 1918 return out, metadata, awsAwsjson11_deserializeOpErrorCreateTagOption(response, &metadata) 1919 } 1920 output := &CreateTagOptionOutput{} 1921 out.Result = output 1922 1923 var buff [1024]byte 1924 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1925 1926 body := io.TeeReader(response.Body, ringBuffer) 1927 decoder := json.NewDecoder(body) 1928 decoder.UseNumber() 1929 var shape interface{} 1930 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1931 var snapshot bytes.Buffer 1932 io.Copy(&snapshot, ringBuffer) 1933 err = &smithy.DeserializationError{ 1934 Err: fmt.Errorf("failed to decode response body, %w", err), 1935 Snapshot: snapshot.Bytes(), 1936 } 1937 return out, metadata, err 1938 } 1939 1940 err = awsAwsjson11_deserializeOpDocumentCreateTagOptionOutput(&output, shape) 1941 if err != nil { 1942 var snapshot bytes.Buffer 1943 io.Copy(&snapshot, ringBuffer) 1944 err = &smithy.DeserializationError{ 1945 Err: fmt.Errorf("failed to decode response body, %w", err), 1946 Snapshot: snapshot.Bytes(), 1947 } 1948 return out, metadata, err 1949 } 1950 1951 return out, metadata, err 1952} 1953 1954func awsAwsjson11_deserializeOpErrorCreateTagOption(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1955 var errorBuffer bytes.Buffer 1956 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1957 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1958 } 1959 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1960 1961 errorCode := "UnknownError" 1962 errorMessage := errorCode 1963 1964 code := response.Header.Get("X-Amzn-ErrorType") 1965 if len(code) != 0 { 1966 errorCode = restjson.SanitizeErrorCode(code) 1967 } 1968 1969 var buff [1024]byte 1970 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1971 1972 body := io.TeeReader(errorBody, ringBuffer) 1973 decoder := json.NewDecoder(body) 1974 decoder.UseNumber() 1975 code, message, err := restjson.GetErrorInfo(decoder) 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 err 1984 } 1985 1986 errorBody.Seek(0, io.SeekStart) 1987 if len(code) != 0 { 1988 errorCode = restjson.SanitizeErrorCode(code) 1989 } 1990 if len(message) != 0 { 1991 errorMessage = message 1992 } 1993 1994 switch { 1995 case strings.EqualFold("DuplicateResourceException", errorCode): 1996 return awsAwsjson11_deserializeErrorDuplicateResourceException(response, errorBody) 1997 1998 case strings.EqualFold("LimitExceededException", errorCode): 1999 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 2000 2001 case strings.EqualFold("TagOptionNotMigratedException", errorCode): 2002 return awsAwsjson11_deserializeErrorTagOptionNotMigratedException(response, errorBody) 2003 2004 default: 2005 genericError := &smithy.GenericAPIError{ 2006 Code: errorCode, 2007 Message: errorMessage, 2008 } 2009 return genericError 2010 2011 } 2012} 2013 2014type awsAwsjson11_deserializeOpDeleteConstraint struct { 2015} 2016 2017func (*awsAwsjson11_deserializeOpDeleteConstraint) ID() string { 2018 return "OperationDeserializer" 2019} 2020 2021func (m *awsAwsjson11_deserializeOpDeleteConstraint) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2022 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2023) { 2024 out, metadata, err = next.HandleDeserialize(ctx, in) 2025 if err != nil { 2026 return out, metadata, err 2027 } 2028 2029 response, ok := out.RawResponse.(*smithyhttp.Response) 2030 if !ok { 2031 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2032 } 2033 2034 if response.StatusCode < 200 || response.StatusCode >= 300 { 2035 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteConstraint(response, &metadata) 2036 } 2037 output := &DeleteConstraintOutput{} 2038 out.Result = output 2039 2040 var buff [1024]byte 2041 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2042 2043 body := io.TeeReader(response.Body, ringBuffer) 2044 decoder := json.NewDecoder(body) 2045 decoder.UseNumber() 2046 var shape interface{} 2047 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2048 var snapshot bytes.Buffer 2049 io.Copy(&snapshot, ringBuffer) 2050 err = &smithy.DeserializationError{ 2051 Err: fmt.Errorf("failed to decode response body, %w", err), 2052 Snapshot: snapshot.Bytes(), 2053 } 2054 return out, metadata, err 2055 } 2056 2057 err = awsAwsjson11_deserializeOpDocumentDeleteConstraintOutput(&output, shape) 2058 if err != nil { 2059 var snapshot bytes.Buffer 2060 io.Copy(&snapshot, ringBuffer) 2061 err = &smithy.DeserializationError{ 2062 Err: fmt.Errorf("failed to decode response body, %w", err), 2063 Snapshot: snapshot.Bytes(), 2064 } 2065 return out, metadata, err 2066 } 2067 2068 return out, metadata, err 2069} 2070 2071func awsAwsjson11_deserializeOpErrorDeleteConstraint(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2072 var errorBuffer bytes.Buffer 2073 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2074 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2075 } 2076 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2077 2078 errorCode := "UnknownError" 2079 errorMessage := errorCode 2080 2081 code := response.Header.Get("X-Amzn-ErrorType") 2082 if len(code) != 0 { 2083 errorCode = restjson.SanitizeErrorCode(code) 2084 } 2085 2086 var buff [1024]byte 2087 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2088 2089 body := io.TeeReader(errorBody, ringBuffer) 2090 decoder := json.NewDecoder(body) 2091 decoder.UseNumber() 2092 code, message, err := restjson.GetErrorInfo(decoder) 2093 if err != nil { 2094 var snapshot bytes.Buffer 2095 io.Copy(&snapshot, ringBuffer) 2096 err = &smithy.DeserializationError{ 2097 Err: fmt.Errorf("failed to decode response body, %w", err), 2098 Snapshot: snapshot.Bytes(), 2099 } 2100 return err 2101 } 2102 2103 errorBody.Seek(0, io.SeekStart) 2104 if len(code) != 0 { 2105 errorCode = restjson.SanitizeErrorCode(code) 2106 } 2107 if len(message) != 0 { 2108 errorMessage = message 2109 } 2110 2111 switch { 2112 case strings.EqualFold("InvalidParametersException", errorCode): 2113 return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody) 2114 2115 case strings.EqualFold("ResourceNotFoundException", errorCode): 2116 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 2117 2118 default: 2119 genericError := &smithy.GenericAPIError{ 2120 Code: errorCode, 2121 Message: errorMessage, 2122 } 2123 return genericError 2124 2125 } 2126} 2127 2128type awsAwsjson11_deserializeOpDeletePortfolio struct { 2129} 2130 2131func (*awsAwsjson11_deserializeOpDeletePortfolio) ID() string { 2132 return "OperationDeserializer" 2133} 2134 2135func (m *awsAwsjson11_deserializeOpDeletePortfolio) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2136 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2137) { 2138 out, metadata, err = next.HandleDeserialize(ctx, in) 2139 if err != nil { 2140 return out, metadata, err 2141 } 2142 2143 response, ok := out.RawResponse.(*smithyhttp.Response) 2144 if !ok { 2145 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2146 } 2147 2148 if response.StatusCode < 200 || response.StatusCode >= 300 { 2149 return out, metadata, awsAwsjson11_deserializeOpErrorDeletePortfolio(response, &metadata) 2150 } 2151 output := &DeletePortfolioOutput{} 2152 out.Result = output 2153 2154 var buff [1024]byte 2155 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2156 2157 body := io.TeeReader(response.Body, ringBuffer) 2158 decoder := json.NewDecoder(body) 2159 decoder.UseNumber() 2160 var shape interface{} 2161 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2162 var snapshot bytes.Buffer 2163 io.Copy(&snapshot, ringBuffer) 2164 err = &smithy.DeserializationError{ 2165 Err: fmt.Errorf("failed to decode response body, %w", err), 2166 Snapshot: snapshot.Bytes(), 2167 } 2168 return out, metadata, err 2169 } 2170 2171 err = awsAwsjson11_deserializeOpDocumentDeletePortfolioOutput(&output, shape) 2172 if err != nil { 2173 var snapshot bytes.Buffer 2174 io.Copy(&snapshot, ringBuffer) 2175 err = &smithy.DeserializationError{ 2176 Err: fmt.Errorf("failed to decode response body, %w", err), 2177 Snapshot: snapshot.Bytes(), 2178 } 2179 return out, metadata, err 2180 } 2181 2182 return out, metadata, err 2183} 2184 2185func awsAwsjson11_deserializeOpErrorDeletePortfolio(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2186 var errorBuffer bytes.Buffer 2187 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2188 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2189 } 2190 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2191 2192 errorCode := "UnknownError" 2193 errorMessage := errorCode 2194 2195 code := response.Header.Get("X-Amzn-ErrorType") 2196 if len(code) != 0 { 2197 errorCode = restjson.SanitizeErrorCode(code) 2198 } 2199 2200 var buff [1024]byte 2201 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2202 2203 body := io.TeeReader(errorBody, ringBuffer) 2204 decoder := json.NewDecoder(body) 2205 decoder.UseNumber() 2206 code, message, err := restjson.GetErrorInfo(decoder) 2207 if err != nil { 2208 var snapshot bytes.Buffer 2209 io.Copy(&snapshot, ringBuffer) 2210 err = &smithy.DeserializationError{ 2211 Err: fmt.Errorf("failed to decode response body, %w", err), 2212 Snapshot: snapshot.Bytes(), 2213 } 2214 return err 2215 } 2216 2217 errorBody.Seek(0, io.SeekStart) 2218 if len(code) != 0 { 2219 errorCode = restjson.SanitizeErrorCode(code) 2220 } 2221 if len(message) != 0 { 2222 errorMessage = message 2223 } 2224 2225 switch { 2226 case strings.EqualFold("InvalidParametersException", errorCode): 2227 return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody) 2228 2229 case strings.EqualFold("ResourceInUseException", errorCode): 2230 return awsAwsjson11_deserializeErrorResourceInUseException(response, errorBody) 2231 2232 case strings.EqualFold("ResourceNotFoundException", errorCode): 2233 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 2234 2235 case strings.EqualFold("TagOptionNotMigratedException", errorCode): 2236 return awsAwsjson11_deserializeErrorTagOptionNotMigratedException(response, errorBody) 2237 2238 default: 2239 genericError := &smithy.GenericAPIError{ 2240 Code: errorCode, 2241 Message: errorMessage, 2242 } 2243 return genericError 2244 2245 } 2246} 2247 2248type awsAwsjson11_deserializeOpDeletePortfolioShare struct { 2249} 2250 2251func (*awsAwsjson11_deserializeOpDeletePortfolioShare) ID() string { 2252 return "OperationDeserializer" 2253} 2254 2255func (m *awsAwsjson11_deserializeOpDeletePortfolioShare) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2256 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2257) { 2258 out, metadata, err = next.HandleDeserialize(ctx, in) 2259 if err != nil { 2260 return out, metadata, err 2261 } 2262 2263 response, ok := out.RawResponse.(*smithyhttp.Response) 2264 if !ok { 2265 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2266 } 2267 2268 if response.StatusCode < 200 || response.StatusCode >= 300 { 2269 return out, metadata, awsAwsjson11_deserializeOpErrorDeletePortfolioShare(response, &metadata) 2270 } 2271 output := &DeletePortfolioShareOutput{} 2272 out.Result = output 2273 2274 var buff [1024]byte 2275 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2276 2277 body := io.TeeReader(response.Body, ringBuffer) 2278 decoder := json.NewDecoder(body) 2279 decoder.UseNumber() 2280 var shape interface{} 2281 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2282 var snapshot bytes.Buffer 2283 io.Copy(&snapshot, ringBuffer) 2284 err = &smithy.DeserializationError{ 2285 Err: fmt.Errorf("failed to decode response body, %w", err), 2286 Snapshot: snapshot.Bytes(), 2287 } 2288 return out, metadata, err 2289 } 2290 2291 err = awsAwsjson11_deserializeOpDocumentDeletePortfolioShareOutput(&output, shape) 2292 if err != nil { 2293 var snapshot bytes.Buffer 2294 io.Copy(&snapshot, ringBuffer) 2295 err = &smithy.DeserializationError{ 2296 Err: fmt.Errorf("failed to decode response body, %w", err), 2297 Snapshot: snapshot.Bytes(), 2298 } 2299 return out, metadata, err 2300 } 2301 2302 return out, metadata, err 2303} 2304 2305func awsAwsjson11_deserializeOpErrorDeletePortfolioShare(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2306 var errorBuffer bytes.Buffer 2307 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2308 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2309 } 2310 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2311 2312 errorCode := "UnknownError" 2313 errorMessage := errorCode 2314 2315 code := response.Header.Get("X-Amzn-ErrorType") 2316 if len(code) != 0 { 2317 errorCode = restjson.SanitizeErrorCode(code) 2318 } 2319 2320 var buff [1024]byte 2321 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2322 2323 body := io.TeeReader(errorBody, ringBuffer) 2324 decoder := json.NewDecoder(body) 2325 decoder.UseNumber() 2326 code, message, err := restjson.GetErrorInfo(decoder) 2327 if err != nil { 2328 var snapshot bytes.Buffer 2329 io.Copy(&snapshot, ringBuffer) 2330 err = &smithy.DeserializationError{ 2331 Err: fmt.Errorf("failed to decode response body, %w", err), 2332 Snapshot: snapshot.Bytes(), 2333 } 2334 return err 2335 } 2336 2337 errorBody.Seek(0, io.SeekStart) 2338 if len(code) != 0 { 2339 errorCode = restjson.SanitizeErrorCode(code) 2340 } 2341 if len(message) != 0 { 2342 errorMessage = message 2343 } 2344 2345 switch { 2346 case strings.EqualFold("InvalidParametersException", errorCode): 2347 return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody) 2348 2349 case strings.EqualFold("InvalidStateException", errorCode): 2350 return awsAwsjson11_deserializeErrorInvalidStateException(response, errorBody) 2351 2352 case strings.EqualFold("OperationNotSupportedException", errorCode): 2353 return awsAwsjson11_deserializeErrorOperationNotSupportedException(response, errorBody) 2354 2355 case strings.EqualFold("ResourceNotFoundException", errorCode): 2356 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 2357 2358 default: 2359 genericError := &smithy.GenericAPIError{ 2360 Code: errorCode, 2361 Message: errorMessage, 2362 } 2363 return genericError 2364 2365 } 2366} 2367 2368type awsAwsjson11_deserializeOpDeleteProduct struct { 2369} 2370 2371func (*awsAwsjson11_deserializeOpDeleteProduct) ID() string { 2372 return "OperationDeserializer" 2373} 2374 2375func (m *awsAwsjson11_deserializeOpDeleteProduct) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2376 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2377) { 2378 out, metadata, err = next.HandleDeserialize(ctx, in) 2379 if err != nil { 2380 return out, metadata, err 2381 } 2382 2383 response, ok := out.RawResponse.(*smithyhttp.Response) 2384 if !ok { 2385 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2386 } 2387 2388 if response.StatusCode < 200 || response.StatusCode >= 300 { 2389 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteProduct(response, &metadata) 2390 } 2391 output := &DeleteProductOutput{} 2392 out.Result = output 2393 2394 var buff [1024]byte 2395 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2396 2397 body := io.TeeReader(response.Body, ringBuffer) 2398 decoder := json.NewDecoder(body) 2399 decoder.UseNumber() 2400 var shape interface{} 2401 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2402 var snapshot bytes.Buffer 2403 io.Copy(&snapshot, ringBuffer) 2404 err = &smithy.DeserializationError{ 2405 Err: fmt.Errorf("failed to decode response body, %w", err), 2406 Snapshot: snapshot.Bytes(), 2407 } 2408 return out, metadata, err 2409 } 2410 2411 err = awsAwsjson11_deserializeOpDocumentDeleteProductOutput(&output, shape) 2412 if err != nil { 2413 var snapshot bytes.Buffer 2414 io.Copy(&snapshot, ringBuffer) 2415 err = &smithy.DeserializationError{ 2416 Err: fmt.Errorf("failed to decode response body, %w", err), 2417 Snapshot: snapshot.Bytes(), 2418 } 2419 return out, metadata, err 2420 } 2421 2422 return out, metadata, err 2423} 2424 2425func awsAwsjson11_deserializeOpErrorDeleteProduct(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2426 var errorBuffer bytes.Buffer 2427 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2428 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2429 } 2430 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2431 2432 errorCode := "UnknownError" 2433 errorMessage := errorCode 2434 2435 code := response.Header.Get("X-Amzn-ErrorType") 2436 if len(code) != 0 { 2437 errorCode = restjson.SanitizeErrorCode(code) 2438 } 2439 2440 var buff [1024]byte 2441 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2442 2443 body := io.TeeReader(errorBody, ringBuffer) 2444 decoder := json.NewDecoder(body) 2445 decoder.UseNumber() 2446 code, message, err := restjson.GetErrorInfo(decoder) 2447 if err != nil { 2448 var snapshot bytes.Buffer 2449 io.Copy(&snapshot, ringBuffer) 2450 err = &smithy.DeserializationError{ 2451 Err: fmt.Errorf("failed to decode response body, %w", err), 2452 Snapshot: snapshot.Bytes(), 2453 } 2454 return err 2455 } 2456 2457 errorBody.Seek(0, io.SeekStart) 2458 if len(code) != 0 { 2459 errorCode = restjson.SanitizeErrorCode(code) 2460 } 2461 if len(message) != 0 { 2462 errorMessage = message 2463 } 2464 2465 switch { 2466 case strings.EqualFold("InvalidParametersException", errorCode): 2467 return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody) 2468 2469 case strings.EqualFold("ResourceInUseException", errorCode): 2470 return awsAwsjson11_deserializeErrorResourceInUseException(response, errorBody) 2471 2472 case strings.EqualFold("ResourceNotFoundException", errorCode): 2473 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 2474 2475 case strings.EqualFold("TagOptionNotMigratedException", errorCode): 2476 return awsAwsjson11_deserializeErrorTagOptionNotMigratedException(response, errorBody) 2477 2478 default: 2479 genericError := &smithy.GenericAPIError{ 2480 Code: errorCode, 2481 Message: errorMessage, 2482 } 2483 return genericError 2484 2485 } 2486} 2487 2488type awsAwsjson11_deserializeOpDeleteProvisionedProductPlan struct { 2489} 2490 2491func (*awsAwsjson11_deserializeOpDeleteProvisionedProductPlan) ID() string { 2492 return "OperationDeserializer" 2493} 2494 2495func (m *awsAwsjson11_deserializeOpDeleteProvisionedProductPlan) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2496 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2497) { 2498 out, metadata, err = next.HandleDeserialize(ctx, in) 2499 if err != nil { 2500 return out, metadata, err 2501 } 2502 2503 response, ok := out.RawResponse.(*smithyhttp.Response) 2504 if !ok { 2505 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2506 } 2507 2508 if response.StatusCode < 200 || response.StatusCode >= 300 { 2509 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteProvisionedProductPlan(response, &metadata) 2510 } 2511 output := &DeleteProvisionedProductPlanOutput{} 2512 out.Result = output 2513 2514 var buff [1024]byte 2515 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2516 2517 body := io.TeeReader(response.Body, ringBuffer) 2518 decoder := json.NewDecoder(body) 2519 decoder.UseNumber() 2520 var shape interface{} 2521 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 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 out, metadata, err 2529 } 2530 2531 err = awsAwsjson11_deserializeOpDocumentDeleteProvisionedProductPlanOutput(&output, shape) 2532 if err != nil { 2533 var snapshot bytes.Buffer 2534 io.Copy(&snapshot, ringBuffer) 2535 err = &smithy.DeserializationError{ 2536 Err: fmt.Errorf("failed to decode response body, %w", err), 2537 Snapshot: snapshot.Bytes(), 2538 } 2539 return out, metadata, err 2540 } 2541 2542 return out, metadata, err 2543} 2544 2545func awsAwsjson11_deserializeOpErrorDeleteProvisionedProductPlan(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2546 var errorBuffer bytes.Buffer 2547 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2548 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2549 } 2550 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2551 2552 errorCode := "UnknownError" 2553 errorMessage := errorCode 2554 2555 code := response.Header.Get("X-Amzn-ErrorType") 2556 if len(code) != 0 { 2557 errorCode = restjson.SanitizeErrorCode(code) 2558 } 2559 2560 var buff [1024]byte 2561 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2562 2563 body := io.TeeReader(errorBody, ringBuffer) 2564 decoder := json.NewDecoder(body) 2565 decoder.UseNumber() 2566 code, message, err := restjson.GetErrorInfo(decoder) 2567 if err != nil { 2568 var snapshot bytes.Buffer 2569 io.Copy(&snapshot, ringBuffer) 2570 err = &smithy.DeserializationError{ 2571 Err: fmt.Errorf("failed to decode response body, %w", err), 2572 Snapshot: snapshot.Bytes(), 2573 } 2574 return err 2575 } 2576 2577 errorBody.Seek(0, io.SeekStart) 2578 if len(code) != 0 { 2579 errorCode = restjson.SanitizeErrorCode(code) 2580 } 2581 if len(message) != 0 { 2582 errorMessage = message 2583 } 2584 2585 switch { 2586 case strings.EqualFold("InvalidParametersException", errorCode): 2587 return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody) 2588 2589 case strings.EqualFold("ResourceNotFoundException", errorCode): 2590 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 2591 2592 default: 2593 genericError := &smithy.GenericAPIError{ 2594 Code: errorCode, 2595 Message: errorMessage, 2596 } 2597 return genericError 2598 2599 } 2600} 2601 2602type awsAwsjson11_deserializeOpDeleteProvisioningArtifact struct { 2603} 2604 2605func (*awsAwsjson11_deserializeOpDeleteProvisioningArtifact) ID() string { 2606 return "OperationDeserializer" 2607} 2608 2609func (m *awsAwsjson11_deserializeOpDeleteProvisioningArtifact) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2610 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2611) { 2612 out, metadata, err = next.HandleDeserialize(ctx, in) 2613 if err != nil { 2614 return out, metadata, err 2615 } 2616 2617 response, ok := out.RawResponse.(*smithyhttp.Response) 2618 if !ok { 2619 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2620 } 2621 2622 if response.StatusCode < 200 || response.StatusCode >= 300 { 2623 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteProvisioningArtifact(response, &metadata) 2624 } 2625 output := &DeleteProvisioningArtifactOutput{} 2626 out.Result = output 2627 2628 var buff [1024]byte 2629 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2630 2631 body := io.TeeReader(response.Body, ringBuffer) 2632 decoder := json.NewDecoder(body) 2633 decoder.UseNumber() 2634 var shape interface{} 2635 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2636 var snapshot bytes.Buffer 2637 io.Copy(&snapshot, ringBuffer) 2638 err = &smithy.DeserializationError{ 2639 Err: fmt.Errorf("failed to decode response body, %w", err), 2640 Snapshot: snapshot.Bytes(), 2641 } 2642 return out, metadata, err 2643 } 2644 2645 err = awsAwsjson11_deserializeOpDocumentDeleteProvisioningArtifactOutput(&output, shape) 2646 if err != nil { 2647 var snapshot bytes.Buffer 2648 io.Copy(&snapshot, ringBuffer) 2649 err = &smithy.DeserializationError{ 2650 Err: fmt.Errorf("failed to decode response body, %w", err), 2651 Snapshot: snapshot.Bytes(), 2652 } 2653 return out, metadata, err 2654 } 2655 2656 return out, metadata, err 2657} 2658 2659func awsAwsjson11_deserializeOpErrorDeleteProvisioningArtifact(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2660 var errorBuffer bytes.Buffer 2661 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2662 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2663 } 2664 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2665 2666 errorCode := "UnknownError" 2667 errorMessage := errorCode 2668 2669 code := response.Header.Get("X-Amzn-ErrorType") 2670 if len(code) != 0 { 2671 errorCode = restjson.SanitizeErrorCode(code) 2672 } 2673 2674 var buff [1024]byte 2675 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2676 2677 body := io.TeeReader(errorBody, ringBuffer) 2678 decoder := json.NewDecoder(body) 2679 decoder.UseNumber() 2680 code, message, err := restjson.GetErrorInfo(decoder) 2681 if err != nil { 2682 var snapshot bytes.Buffer 2683 io.Copy(&snapshot, ringBuffer) 2684 err = &smithy.DeserializationError{ 2685 Err: fmt.Errorf("failed to decode response body, %w", err), 2686 Snapshot: snapshot.Bytes(), 2687 } 2688 return err 2689 } 2690 2691 errorBody.Seek(0, io.SeekStart) 2692 if len(code) != 0 { 2693 errorCode = restjson.SanitizeErrorCode(code) 2694 } 2695 if len(message) != 0 { 2696 errorMessage = message 2697 } 2698 2699 switch { 2700 case strings.EqualFold("InvalidParametersException", errorCode): 2701 return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody) 2702 2703 case strings.EqualFold("ResourceInUseException", errorCode): 2704 return awsAwsjson11_deserializeErrorResourceInUseException(response, errorBody) 2705 2706 case strings.EqualFold("ResourceNotFoundException", errorCode): 2707 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 2708 2709 default: 2710 genericError := &smithy.GenericAPIError{ 2711 Code: errorCode, 2712 Message: errorMessage, 2713 } 2714 return genericError 2715 2716 } 2717} 2718 2719type awsAwsjson11_deserializeOpDeleteServiceAction struct { 2720} 2721 2722func (*awsAwsjson11_deserializeOpDeleteServiceAction) ID() string { 2723 return "OperationDeserializer" 2724} 2725 2726func (m *awsAwsjson11_deserializeOpDeleteServiceAction) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2727 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2728) { 2729 out, metadata, err = next.HandleDeserialize(ctx, in) 2730 if err != nil { 2731 return out, metadata, err 2732 } 2733 2734 response, ok := out.RawResponse.(*smithyhttp.Response) 2735 if !ok { 2736 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2737 } 2738 2739 if response.StatusCode < 200 || response.StatusCode >= 300 { 2740 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteServiceAction(response, &metadata) 2741 } 2742 output := &DeleteServiceActionOutput{} 2743 out.Result = output 2744 2745 var buff [1024]byte 2746 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2747 2748 body := io.TeeReader(response.Body, ringBuffer) 2749 decoder := json.NewDecoder(body) 2750 decoder.UseNumber() 2751 var shape interface{} 2752 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2753 var snapshot bytes.Buffer 2754 io.Copy(&snapshot, ringBuffer) 2755 err = &smithy.DeserializationError{ 2756 Err: fmt.Errorf("failed to decode response body, %w", err), 2757 Snapshot: snapshot.Bytes(), 2758 } 2759 return out, metadata, err 2760 } 2761 2762 err = awsAwsjson11_deserializeOpDocumentDeleteServiceActionOutput(&output, shape) 2763 if err != nil { 2764 var snapshot bytes.Buffer 2765 io.Copy(&snapshot, ringBuffer) 2766 err = &smithy.DeserializationError{ 2767 Err: fmt.Errorf("failed to decode response body, %w", err), 2768 Snapshot: snapshot.Bytes(), 2769 } 2770 return out, metadata, err 2771 } 2772 2773 return out, metadata, err 2774} 2775 2776func awsAwsjson11_deserializeOpErrorDeleteServiceAction(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2777 var errorBuffer bytes.Buffer 2778 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2779 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2780 } 2781 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2782 2783 errorCode := "UnknownError" 2784 errorMessage := errorCode 2785 2786 code := response.Header.Get("X-Amzn-ErrorType") 2787 if len(code) != 0 { 2788 errorCode = restjson.SanitizeErrorCode(code) 2789 } 2790 2791 var buff [1024]byte 2792 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2793 2794 body := io.TeeReader(errorBody, ringBuffer) 2795 decoder := json.NewDecoder(body) 2796 decoder.UseNumber() 2797 code, message, err := restjson.GetErrorInfo(decoder) 2798 if err != nil { 2799 var snapshot bytes.Buffer 2800 io.Copy(&snapshot, ringBuffer) 2801 err = &smithy.DeserializationError{ 2802 Err: fmt.Errorf("failed to decode response body, %w", err), 2803 Snapshot: snapshot.Bytes(), 2804 } 2805 return err 2806 } 2807 2808 errorBody.Seek(0, io.SeekStart) 2809 if len(code) != 0 { 2810 errorCode = restjson.SanitizeErrorCode(code) 2811 } 2812 if len(message) != 0 { 2813 errorMessage = message 2814 } 2815 2816 switch { 2817 case strings.EqualFold("ResourceInUseException", errorCode): 2818 return awsAwsjson11_deserializeErrorResourceInUseException(response, errorBody) 2819 2820 case strings.EqualFold("ResourceNotFoundException", errorCode): 2821 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 2822 2823 default: 2824 genericError := &smithy.GenericAPIError{ 2825 Code: errorCode, 2826 Message: errorMessage, 2827 } 2828 return genericError 2829 2830 } 2831} 2832 2833type awsAwsjson11_deserializeOpDeleteTagOption struct { 2834} 2835 2836func (*awsAwsjson11_deserializeOpDeleteTagOption) ID() string { 2837 return "OperationDeserializer" 2838} 2839 2840func (m *awsAwsjson11_deserializeOpDeleteTagOption) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2841 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2842) { 2843 out, metadata, err = next.HandleDeserialize(ctx, in) 2844 if err != nil { 2845 return out, metadata, err 2846 } 2847 2848 response, ok := out.RawResponse.(*smithyhttp.Response) 2849 if !ok { 2850 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2851 } 2852 2853 if response.StatusCode < 200 || response.StatusCode >= 300 { 2854 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteTagOption(response, &metadata) 2855 } 2856 output := &DeleteTagOptionOutput{} 2857 out.Result = output 2858 2859 var buff [1024]byte 2860 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2861 2862 body := io.TeeReader(response.Body, ringBuffer) 2863 decoder := json.NewDecoder(body) 2864 decoder.UseNumber() 2865 var shape interface{} 2866 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2867 var snapshot bytes.Buffer 2868 io.Copy(&snapshot, ringBuffer) 2869 err = &smithy.DeserializationError{ 2870 Err: fmt.Errorf("failed to decode response body, %w", err), 2871 Snapshot: snapshot.Bytes(), 2872 } 2873 return out, metadata, err 2874 } 2875 2876 err = awsAwsjson11_deserializeOpDocumentDeleteTagOptionOutput(&output, shape) 2877 if err != nil { 2878 var snapshot bytes.Buffer 2879 io.Copy(&snapshot, ringBuffer) 2880 err = &smithy.DeserializationError{ 2881 Err: fmt.Errorf("failed to decode response body, %w", err), 2882 Snapshot: snapshot.Bytes(), 2883 } 2884 return out, metadata, err 2885 } 2886 2887 return out, metadata, err 2888} 2889 2890func awsAwsjson11_deserializeOpErrorDeleteTagOption(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2891 var errorBuffer bytes.Buffer 2892 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2893 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2894 } 2895 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2896 2897 errorCode := "UnknownError" 2898 errorMessage := errorCode 2899 2900 code := response.Header.Get("X-Amzn-ErrorType") 2901 if len(code) != 0 { 2902 errorCode = restjson.SanitizeErrorCode(code) 2903 } 2904 2905 var buff [1024]byte 2906 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2907 2908 body := io.TeeReader(errorBody, ringBuffer) 2909 decoder := json.NewDecoder(body) 2910 decoder.UseNumber() 2911 code, message, err := restjson.GetErrorInfo(decoder) 2912 if err != nil { 2913 var snapshot bytes.Buffer 2914 io.Copy(&snapshot, ringBuffer) 2915 err = &smithy.DeserializationError{ 2916 Err: fmt.Errorf("failed to decode response body, %w", err), 2917 Snapshot: snapshot.Bytes(), 2918 } 2919 return err 2920 } 2921 2922 errorBody.Seek(0, io.SeekStart) 2923 if len(code) != 0 { 2924 errorCode = restjson.SanitizeErrorCode(code) 2925 } 2926 if len(message) != 0 { 2927 errorMessage = message 2928 } 2929 2930 switch { 2931 case strings.EqualFold("ResourceInUseException", errorCode): 2932 return awsAwsjson11_deserializeErrorResourceInUseException(response, errorBody) 2933 2934 case strings.EqualFold("ResourceNotFoundException", errorCode): 2935 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 2936 2937 case strings.EqualFold("TagOptionNotMigratedException", errorCode): 2938 return awsAwsjson11_deserializeErrorTagOptionNotMigratedException(response, errorBody) 2939 2940 default: 2941 genericError := &smithy.GenericAPIError{ 2942 Code: errorCode, 2943 Message: errorMessage, 2944 } 2945 return genericError 2946 2947 } 2948} 2949 2950type awsAwsjson11_deserializeOpDescribeConstraint struct { 2951} 2952 2953func (*awsAwsjson11_deserializeOpDescribeConstraint) ID() string { 2954 return "OperationDeserializer" 2955} 2956 2957func (m *awsAwsjson11_deserializeOpDescribeConstraint) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2958 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2959) { 2960 out, metadata, err = next.HandleDeserialize(ctx, in) 2961 if err != nil { 2962 return out, metadata, err 2963 } 2964 2965 response, ok := out.RawResponse.(*smithyhttp.Response) 2966 if !ok { 2967 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2968 } 2969 2970 if response.StatusCode < 200 || response.StatusCode >= 300 { 2971 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeConstraint(response, &metadata) 2972 } 2973 output := &DescribeConstraintOutput{} 2974 out.Result = output 2975 2976 var buff [1024]byte 2977 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2978 2979 body := io.TeeReader(response.Body, ringBuffer) 2980 decoder := json.NewDecoder(body) 2981 decoder.UseNumber() 2982 var shape interface{} 2983 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2984 var snapshot bytes.Buffer 2985 io.Copy(&snapshot, ringBuffer) 2986 err = &smithy.DeserializationError{ 2987 Err: fmt.Errorf("failed to decode response body, %w", err), 2988 Snapshot: snapshot.Bytes(), 2989 } 2990 return out, metadata, err 2991 } 2992 2993 err = awsAwsjson11_deserializeOpDocumentDescribeConstraintOutput(&output, shape) 2994 if err != nil { 2995 var snapshot bytes.Buffer 2996 io.Copy(&snapshot, ringBuffer) 2997 err = &smithy.DeserializationError{ 2998 Err: fmt.Errorf("failed to decode response body, %w", err), 2999 Snapshot: snapshot.Bytes(), 3000 } 3001 return out, metadata, err 3002 } 3003 3004 return out, metadata, err 3005} 3006 3007func awsAwsjson11_deserializeOpErrorDescribeConstraint(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3008 var errorBuffer bytes.Buffer 3009 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3010 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3011 } 3012 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3013 3014 errorCode := "UnknownError" 3015 errorMessage := errorCode 3016 3017 code := response.Header.Get("X-Amzn-ErrorType") 3018 if len(code) != 0 { 3019 errorCode = restjson.SanitizeErrorCode(code) 3020 } 3021 3022 var buff [1024]byte 3023 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3024 3025 body := io.TeeReader(errorBody, ringBuffer) 3026 decoder := json.NewDecoder(body) 3027 decoder.UseNumber() 3028 code, message, err := restjson.GetErrorInfo(decoder) 3029 if err != nil { 3030 var snapshot bytes.Buffer 3031 io.Copy(&snapshot, ringBuffer) 3032 err = &smithy.DeserializationError{ 3033 Err: fmt.Errorf("failed to decode response body, %w", err), 3034 Snapshot: snapshot.Bytes(), 3035 } 3036 return err 3037 } 3038 3039 errorBody.Seek(0, io.SeekStart) 3040 if len(code) != 0 { 3041 errorCode = restjson.SanitizeErrorCode(code) 3042 } 3043 if len(message) != 0 { 3044 errorMessage = message 3045 } 3046 3047 switch { 3048 case strings.EqualFold("ResourceNotFoundException", errorCode): 3049 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 3050 3051 default: 3052 genericError := &smithy.GenericAPIError{ 3053 Code: errorCode, 3054 Message: errorMessage, 3055 } 3056 return genericError 3057 3058 } 3059} 3060 3061type awsAwsjson11_deserializeOpDescribeCopyProductStatus struct { 3062} 3063 3064func (*awsAwsjson11_deserializeOpDescribeCopyProductStatus) ID() string { 3065 return "OperationDeserializer" 3066} 3067 3068func (m *awsAwsjson11_deserializeOpDescribeCopyProductStatus) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3069 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3070) { 3071 out, metadata, err = next.HandleDeserialize(ctx, in) 3072 if err != nil { 3073 return out, metadata, err 3074 } 3075 3076 response, ok := out.RawResponse.(*smithyhttp.Response) 3077 if !ok { 3078 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3079 } 3080 3081 if response.StatusCode < 200 || response.StatusCode >= 300 { 3082 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeCopyProductStatus(response, &metadata) 3083 } 3084 output := &DescribeCopyProductStatusOutput{} 3085 out.Result = output 3086 3087 var buff [1024]byte 3088 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3089 3090 body := io.TeeReader(response.Body, ringBuffer) 3091 decoder := json.NewDecoder(body) 3092 decoder.UseNumber() 3093 var shape interface{} 3094 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3095 var snapshot bytes.Buffer 3096 io.Copy(&snapshot, ringBuffer) 3097 err = &smithy.DeserializationError{ 3098 Err: fmt.Errorf("failed to decode response body, %w", err), 3099 Snapshot: snapshot.Bytes(), 3100 } 3101 return out, metadata, err 3102 } 3103 3104 err = awsAwsjson11_deserializeOpDocumentDescribeCopyProductStatusOutput(&output, shape) 3105 if err != nil { 3106 var snapshot bytes.Buffer 3107 io.Copy(&snapshot, ringBuffer) 3108 err = &smithy.DeserializationError{ 3109 Err: fmt.Errorf("failed to decode response body, %w", err), 3110 Snapshot: snapshot.Bytes(), 3111 } 3112 return out, metadata, err 3113 } 3114 3115 return out, metadata, err 3116} 3117 3118func awsAwsjson11_deserializeOpErrorDescribeCopyProductStatus(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3119 var errorBuffer bytes.Buffer 3120 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3121 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3122 } 3123 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3124 3125 errorCode := "UnknownError" 3126 errorMessage := errorCode 3127 3128 code := response.Header.Get("X-Amzn-ErrorType") 3129 if len(code) != 0 { 3130 errorCode = restjson.SanitizeErrorCode(code) 3131 } 3132 3133 var buff [1024]byte 3134 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3135 3136 body := io.TeeReader(errorBody, ringBuffer) 3137 decoder := json.NewDecoder(body) 3138 decoder.UseNumber() 3139 code, message, err := restjson.GetErrorInfo(decoder) 3140 if err != nil { 3141 var snapshot bytes.Buffer 3142 io.Copy(&snapshot, ringBuffer) 3143 err = &smithy.DeserializationError{ 3144 Err: fmt.Errorf("failed to decode response body, %w", err), 3145 Snapshot: snapshot.Bytes(), 3146 } 3147 return err 3148 } 3149 3150 errorBody.Seek(0, io.SeekStart) 3151 if len(code) != 0 { 3152 errorCode = restjson.SanitizeErrorCode(code) 3153 } 3154 if len(message) != 0 { 3155 errorMessage = message 3156 } 3157 3158 switch { 3159 case strings.EqualFold("ResourceNotFoundException", errorCode): 3160 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 3161 3162 default: 3163 genericError := &smithy.GenericAPIError{ 3164 Code: errorCode, 3165 Message: errorMessage, 3166 } 3167 return genericError 3168 3169 } 3170} 3171 3172type awsAwsjson11_deserializeOpDescribePortfolio struct { 3173} 3174 3175func (*awsAwsjson11_deserializeOpDescribePortfolio) ID() string { 3176 return "OperationDeserializer" 3177} 3178 3179func (m *awsAwsjson11_deserializeOpDescribePortfolio) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3180 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3181) { 3182 out, metadata, err = next.HandleDeserialize(ctx, in) 3183 if err != nil { 3184 return out, metadata, err 3185 } 3186 3187 response, ok := out.RawResponse.(*smithyhttp.Response) 3188 if !ok { 3189 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3190 } 3191 3192 if response.StatusCode < 200 || response.StatusCode >= 300 { 3193 return out, metadata, awsAwsjson11_deserializeOpErrorDescribePortfolio(response, &metadata) 3194 } 3195 output := &DescribePortfolioOutput{} 3196 out.Result = output 3197 3198 var buff [1024]byte 3199 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3200 3201 body := io.TeeReader(response.Body, ringBuffer) 3202 decoder := json.NewDecoder(body) 3203 decoder.UseNumber() 3204 var shape interface{} 3205 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3206 var snapshot bytes.Buffer 3207 io.Copy(&snapshot, ringBuffer) 3208 err = &smithy.DeserializationError{ 3209 Err: fmt.Errorf("failed to decode response body, %w", err), 3210 Snapshot: snapshot.Bytes(), 3211 } 3212 return out, metadata, err 3213 } 3214 3215 err = awsAwsjson11_deserializeOpDocumentDescribePortfolioOutput(&output, shape) 3216 if err != nil { 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 return out, metadata, err 3227} 3228 3229func awsAwsjson11_deserializeOpErrorDescribePortfolio(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3230 var errorBuffer bytes.Buffer 3231 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3232 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3233 } 3234 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3235 3236 errorCode := "UnknownError" 3237 errorMessage := errorCode 3238 3239 code := response.Header.Get("X-Amzn-ErrorType") 3240 if len(code) != 0 { 3241 errorCode = restjson.SanitizeErrorCode(code) 3242 } 3243 3244 var buff [1024]byte 3245 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3246 3247 body := io.TeeReader(errorBody, ringBuffer) 3248 decoder := json.NewDecoder(body) 3249 decoder.UseNumber() 3250 code, message, err := restjson.GetErrorInfo(decoder) 3251 if err != nil { 3252 var snapshot bytes.Buffer 3253 io.Copy(&snapshot, ringBuffer) 3254 err = &smithy.DeserializationError{ 3255 Err: fmt.Errorf("failed to decode response body, %w", err), 3256 Snapshot: snapshot.Bytes(), 3257 } 3258 return err 3259 } 3260 3261 errorBody.Seek(0, io.SeekStart) 3262 if len(code) != 0 { 3263 errorCode = restjson.SanitizeErrorCode(code) 3264 } 3265 if len(message) != 0 { 3266 errorMessage = message 3267 } 3268 3269 switch { 3270 case strings.EqualFold("ResourceNotFoundException", errorCode): 3271 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 3272 3273 default: 3274 genericError := &smithy.GenericAPIError{ 3275 Code: errorCode, 3276 Message: errorMessage, 3277 } 3278 return genericError 3279 3280 } 3281} 3282 3283type awsAwsjson11_deserializeOpDescribePortfolioShares struct { 3284} 3285 3286func (*awsAwsjson11_deserializeOpDescribePortfolioShares) ID() string { 3287 return "OperationDeserializer" 3288} 3289 3290func (m *awsAwsjson11_deserializeOpDescribePortfolioShares) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3291 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3292) { 3293 out, metadata, err = next.HandleDeserialize(ctx, in) 3294 if err != nil { 3295 return out, metadata, err 3296 } 3297 3298 response, ok := out.RawResponse.(*smithyhttp.Response) 3299 if !ok { 3300 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3301 } 3302 3303 if response.StatusCode < 200 || response.StatusCode >= 300 { 3304 return out, metadata, awsAwsjson11_deserializeOpErrorDescribePortfolioShares(response, &metadata) 3305 } 3306 output := &DescribePortfolioSharesOutput{} 3307 out.Result = output 3308 3309 var buff [1024]byte 3310 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3311 3312 body := io.TeeReader(response.Body, ringBuffer) 3313 decoder := json.NewDecoder(body) 3314 decoder.UseNumber() 3315 var shape interface{} 3316 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3317 var snapshot bytes.Buffer 3318 io.Copy(&snapshot, ringBuffer) 3319 err = &smithy.DeserializationError{ 3320 Err: fmt.Errorf("failed to decode response body, %w", err), 3321 Snapshot: snapshot.Bytes(), 3322 } 3323 return out, metadata, err 3324 } 3325 3326 err = awsAwsjson11_deserializeOpDocumentDescribePortfolioSharesOutput(&output, shape) 3327 if err != nil { 3328 var snapshot bytes.Buffer 3329 io.Copy(&snapshot, ringBuffer) 3330 err = &smithy.DeserializationError{ 3331 Err: fmt.Errorf("failed to decode response body, %w", err), 3332 Snapshot: snapshot.Bytes(), 3333 } 3334 return out, metadata, err 3335 } 3336 3337 return out, metadata, err 3338} 3339 3340func awsAwsjson11_deserializeOpErrorDescribePortfolioShares(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3341 var errorBuffer bytes.Buffer 3342 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3343 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3344 } 3345 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3346 3347 errorCode := "UnknownError" 3348 errorMessage := errorCode 3349 3350 code := response.Header.Get("X-Amzn-ErrorType") 3351 if len(code) != 0 { 3352 errorCode = restjson.SanitizeErrorCode(code) 3353 } 3354 3355 var buff [1024]byte 3356 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3357 3358 body := io.TeeReader(errorBody, ringBuffer) 3359 decoder := json.NewDecoder(body) 3360 decoder.UseNumber() 3361 code, message, err := restjson.GetErrorInfo(decoder) 3362 if err != nil { 3363 var snapshot bytes.Buffer 3364 io.Copy(&snapshot, ringBuffer) 3365 err = &smithy.DeserializationError{ 3366 Err: fmt.Errorf("failed to decode response body, %w", err), 3367 Snapshot: snapshot.Bytes(), 3368 } 3369 return err 3370 } 3371 3372 errorBody.Seek(0, io.SeekStart) 3373 if len(code) != 0 { 3374 errorCode = restjson.SanitizeErrorCode(code) 3375 } 3376 if len(message) != 0 { 3377 errorMessage = message 3378 } 3379 3380 switch { 3381 case strings.EqualFold("InvalidParametersException", errorCode): 3382 return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody) 3383 3384 case strings.EqualFold("ResourceNotFoundException", errorCode): 3385 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 3386 3387 default: 3388 genericError := &smithy.GenericAPIError{ 3389 Code: errorCode, 3390 Message: errorMessage, 3391 } 3392 return genericError 3393 3394 } 3395} 3396 3397type awsAwsjson11_deserializeOpDescribePortfolioShareStatus struct { 3398} 3399 3400func (*awsAwsjson11_deserializeOpDescribePortfolioShareStatus) ID() string { 3401 return "OperationDeserializer" 3402} 3403 3404func (m *awsAwsjson11_deserializeOpDescribePortfolioShareStatus) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3405 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3406) { 3407 out, metadata, err = next.HandleDeserialize(ctx, in) 3408 if err != nil { 3409 return out, metadata, err 3410 } 3411 3412 response, ok := out.RawResponse.(*smithyhttp.Response) 3413 if !ok { 3414 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3415 } 3416 3417 if response.StatusCode < 200 || response.StatusCode >= 300 { 3418 return out, metadata, awsAwsjson11_deserializeOpErrorDescribePortfolioShareStatus(response, &metadata) 3419 } 3420 output := &DescribePortfolioShareStatusOutput{} 3421 out.Result = output 3422 3423 var buff [1024]byte 3424 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3425 3426 body := io.TeeReader(response.Body, ringBuffer) 3427 decoder := json.NewDecoder(body) 3428 decoder.UseNumber() 3429 var shape interface{} 3430 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3431 var snapshot bytes.Buffer 3432 io.Copy(&snapshot, ringBuffer) 3433 err = &smithy.DeserializationError{ 3434 Err: fmt.Errorf("failed to decode response body, %w", err), 3435 Snapshot: snapshot.Bytes(), 3436 } 3437 return out, metadata, err 3438 } 3439 3440 err = awsAwsjson11_deserializeOpDocumentDescribePortfolioShareStatusOutput(&output, shape) 3441 if err != nil { 3442 var snapshot bytes.Buffer 3443 io.Copy(&snapshot, ringBuffer) 3444 err = &smithy.DeserializationError{ 3445 Err: fmt.Errorf("failed to decode response body, %w", err), 3446 Snapshot: snapshot.Bytes(), 3447 } 3448 return out, metadata, err 3449 } 3450 3451 return out, metadata, err 3452} 3453 3454func awsAwsjson11_deserializeOpErrorDescribePortfolioShareStatus(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3455 var errorBuffer bytes.Buffer 3456 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3457 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3458 } 3459 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3460 3461 errorCode := "UnknownError" 3462 errorMessage := errorCode 3463 3464 code := response.Header.Get("X-Amzn-ErrorType") 3465 if len(code) != 0 { 3466 errorCode = restjson.SanitizeErrorCode(code) 3467 } 3468 3469 var buff [1024]byte 3470 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3471 3472 body := io.TeeReader(errorBody, ringBuffer) 3473 decoder := json.NewDecoder(body) 3474 decoder.UseNumber() 3475 code, message, err := restjson.GetErrorInfo(decoder) 3476 if err != nil { 3477 var snapshot bytes.Buffer 3478 io.Copy(&snapshot, ringBuffer) 3479 err = &smithy.DeserializationError{ 3480 Err: fmt.Errorf("failed to decode response body, %w", err), 3481 Snapshot: snapshot.Bytes(), 3482 } 3483 return err 3484 } 3485 3486 errorBody.Seek(0, io.SeekStart) 3487 if len(code) != 0 { 3488 errorCode = restjson.SanitizeErrorCode(code) 3489 } 3490 if len(message) != 0 { 3491 errorMessage = message 3492 } 3493 3494 switch { 3495 case strings.EqualFold("InvalidParametersException", errorCode): 3496 return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody) 3497 3498 case strings.EqualFold("OperationNotSupportedException", errorCode): 3499 return awsAwsjson11_deserializeErrorOperationNotSupportedException(response, errorBody) 3500 3501 case strings.EqualFold("ResourceNotFoundException", errorCode): 3502 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 3503 3504 default: 3505 genericError := &smithy.GenericAPIError{ 3506 Code: errorCode, 3507 Message: errorMessage, 3508 } 3509 return genericError 3510 3511 } 3512} 3513 3514type awsAwsjson11_deserializeOpDescribeProduct struct { 3515} 3516 3517func (*awsAwsjson11_deserializeOpDescribeProduct) ID() string { 3518 return "OperationDeserializer" 3519} 3520 3521func (m *awsAwsjson11_deserializeOpDescribeProduct) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3522 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3523) { 3524 out, metadata, err = next.HandleDeserialize(ctx, in) 3525 if err != nil { 3526 return out, metadata, err 3527 } 3528 3529 response, ok := out.RawResponse.(*smithyhttp.Response) 3530 if !ok { 3531 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3532 } 3533 3534 if response.StatusCode < 200 || response.StatusCode >= 300 { 3535 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeProduct(response, &metadata) 3536 } 3537 output := &DescribeProductOutput{} 3538 out.Result = output 3539 3540 var buff [1024]byte 3541 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3542 3543 body := io.TeeReader(response.Body, ringBuffer) 3544 decoder := json.NewDecoder(body) 3545 decoder.UseNumber() 3546 var shape interface{} 3547 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3548 var snapshot bytes.Buffer 3549 io.Copy(&snapshot, ringBuffer) 3550 err = &smithy.DeserializationError{ 3551 Err: fmt.Errorf("failed to decode response body, %w", err), 3552 Snapshot: snapshot.Bytes(), 3553 } 3554 return out, metadata, err 3555 } 3556 3557 err = awsAwsjson11_deserializeOpDocumentDescribeProductOutput(&output, shape) 3558 if err != nil { 3559 var snapshot bytes.Buffer 3560 io.Copy(&snapshot, ringBuffer) 3561 err = &smithy.DeserializationError{ 3562 Err: fmt.Errorf("failed to decode response body, %w", err), 3563 Snapshot: snapshot.Bytes(), 3564 } 3565 return out, metadata, err 3566 } 3567 3568 return out, metadata, err 3569} 3570 3571func awsAwsjson11_deserializeOpErrorDescribeProduct(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3572 var errorBuffer bytes.Buffer 3573 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3574 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3575 } 3576 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3577 3578 errorCode := "UnknownError" 3579 errorMessage := errorCode 3580 3581 code := response.Header.Get("X-Amzn-ErrorType") 3582 if len(code) != 0 { 3583 errorCode = restjson.SanitizeErrorCode(code) 3584 } 3585 3586 var buff [1024]byte 3587 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3588 3589 body := io.TeeReader(errorBody, ringBuffer) 3590 decoder := json.NewDecoder(body) 3591 decoder.UseNumber() 3592 code, message, err := restjson.GetErrorInfo(decoder) 3593 if err != nil { 3594 var snapshot bytes.Buffer 3595 io.Copy(&snapshot, ringBuffer) 3596 err = &smithy.DeserializationError{ 3597 Err: fmt.Errorf("failed to decode response body, %w", err), 3598 Snapshot: snapshot.Bytes(), 3599 } 3600 return err 3601 } 3602 3603 errorBody.Seek(0, io.SeekStart) 3604 if len(code) != 0 { 3605 errorCode = restjson.SanitizeErrorCode(code) 3606 } 3607 if len(message) != 0 { 3608 errorMessage = message 3609 } 3610 3611 switch { 3612 case strings.EqualFold("InvalidParametersException", errorCode): 3613 return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody) 3614 3615 case strings.EqualFold("ResourceNotFoundException", errorCode): 3616 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 3617 3618 default: 3619 genericError := &smithy.GenericAPIError{ 3620 Code: errorCode, 3621 Message: errorMessage, 3622 } 3623 return genericError 3624 3625 } 3626} 3627 3628type awsAwsjson11_deserializeOpDescribeProductAsAdmin struct { 3629} 3630 3631func (*awsAwsjson11_deserializeOpDescribeProductAsAdmin) ID() string { 3632 return "OperationDeserializer" 3633} 3634 3635func (m *awsAwsjson11_deserializeOpDescribeProductAsAdmin) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3636 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3637) { 3638 out, metadata, err = next.HandleDeserialize(ctx, in) 3639 if err != nil { 3640 return out, metadata, err 3641 } 3642 3643 response, ok := out.RawResponse.(*smithyhttp.Response) 3644 if !ok { 3645 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3646 } 3647 3648 if response.StatusCode < 200 || response.StatusCode >= 300 { 3649 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeProductAsAdmin(response, &metadata) 3650 } 3651 output := &DescribeProductAsAdminOutput{} 3652 out.Result = output 3653 3654 var buff [1024]byte 3655 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3656 3657 body := io.TeeReader(response.Body, ringBuffer) 3658 decoder := json.NewDecoder(body) 3659 decoder.UseNumber() 3660 var shape interface{} 3661 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3662 var snapshot bytes.Buffer 3663 io.Copy(&snapshot, ringBuffer) 3664 err = &smithy.DeserializationError{ 3665 Err: fmt.Errorf("failed to decode response body, %w", err), 3666 Snapshot: snapshot.Bytes(), 3667 } 3668 return out, metadata, err 3669 } 3670 3671 err = awsAwsjson11_deserializeOpDocumentDescribeProductAsAdminOutput(&output, shape) 3672 if err != nil { 3673 var snapshot bytes.Buffer 3674 io.Copy(&snapshot, ringBuffer) 3675 err = &smithy.DeserializationError{ 3676 Err: fmt.Errorf("failed to decode response body, %w", err), 3677 Snapshot: snapshot.Bytes(), 3678 } 3679 return out, metadata, err 3680 } 3681 3682 return out, metadata, err 3683} 3684 3685func awsAwsjson11_deserializeOpErrorDescribeProductAsAdmin(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3686 var errorBuffer bytes.Buffer 3687 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3688 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3689 } 3690 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3691 3692 errorCode := "UnknownError" 3693 errorMessage := errorCode 3694 3695 code := response.Header.Get("X-Amzn-ErrorType") 3696 if len(code) != 0 { 3697 errorCode = restjson.SanitizeErrorCode(code) 3698 } 3699 3700 var buff [1024]byte 3701 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3702 3703 body := io.TeeReader(errorBody, ringBuffer) 3704 decoder := json.NewDecoder(body) 3705 decoder.UseNumber() 3706 code, message, err := restjson.GetErrorInfo(decoder) 3707 if err != nil { 3708 var snapshot bytes.Buffer 3709 io.Copy(&snapshot, ringBuffer) 3710 err = &smithy.DeserializationError{ 3711 Err: fmt.Errorf("failed to decode response body, %w", err), 3712 Snapshot: snapshot.Bytes(), 3713 } 3714 return err 3715 } 3716 3717 errorBody.Seek(0, io.SeekStart) 3718 if len(code) != 0 { 3719 errorCode = restjson.SanitizeErrorCode(code) 3720 } 3721 if len(message) != 0 { 3722 errorMessage = message 3723 } 3724 3725 switch { 3726 case strings.EqualFold("InvalidParametersException", errorCode): 3727 return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody) 3728 3729 case strings.EqualFold("ResourceNotFoundException", errorCode): 3730 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 3731 3732 default: 3733 genericError := &smithy.GenericAPIError{ 3734 Code: errorCode, 3735 Message: errorMessage, 3736 } 3737 return genericError 3738 3739 } 3740} 3741 3742type awsAwsjson11_deserializeOpDescribeProductView struct { 3743} 3744 3745func (*awsAwsjson11_deserializeOpDescribeProductView) ID() string { 3746 return "OperationDeserializer" 3747} 3748 3749func (m *awsAwsjson11_deserializeOpDescribeProductView) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3750 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3751) { 3752 out, metadata, err = next.HandleDeserialize(ctx, in) 3753 if err != nil { 3754 return out, metadata, err 3755 } 3756 3757 response, ok := out.RawResponse.(*smithyhttp.Response) 3758 if !ok { 3759 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3760 } 3761 3762 if response.StatusCode < 200 || response.StatusCode >= 300 { 3763 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeProductView(response, &metadata) 3764 } 3765 output := &DescribeProductViewOutput{} 3766 out.Result = output 3767 3768 var buff [1024]byte 3769 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3770 3771 body := io.TeeReader(response.Body, ringBuffer) 3772 decoder := json.NewDecoder(body) 3773 decoder.UseNumber() 3774 var shape interface{} 3775 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3776 var snapshot bytes.Buffer 3777 io.Copy(&snapshot, ringBuffer) 3778 err = &smithy.DeserializationError{ 3779 Err: fmt.Errorf("failed to decode response body, %w", err), 3780 Snapshot: snapshot.Bytes(), 3781 } 3782 return out, metadata, err 3783 } 3784 3785 err = awsAwsjson11_deserializeOpDocumentDescribeProductViewOutput(&output, shape) 3786 if err != nil { 3787 var snapshot bytes.Buffer 3788 io.Copy(&snapshot, ringBuffer) 3789 err = &smithy.DeserializationError{ 3790 Err: fmt.Errorf("failed to decode response body, %w", err), 3791 Snapshot: snapshot.Bytes(), 3792 } 3793 return out, metadata, err 3794 } 3795 3796 return out, metadata, err 3797} 3798 3799func awsAwsjson11_deserializeOpErrorDescribeProductView(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3800 var errorBuffer bytes.Buffer 3801 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3802 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3803 } 3804 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3805 3806 errorCode := "UnknownError" 3807 errorMessage := errorCode 3808 3809 code := response.Header.Get("X-Amzn-ErrorType") 3810 if len(code) != 0 { 3811 errorCode = restjson.SanitizeErrorCode(code) 3812 } 3813 3814 var buff [1024]byte 3815 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3816 3817 body := io.TeeReader(errorBody, ringBuffer) 3818 decoder := json.NewDecoder(body) 3819 decoder.UseNumber() 3820 code, message, err := restjson.GetErrorInfo(decoder) 3821 if err != nil { 3822 var snapshot bytes.Buffer 3823 io.Copy(&snapshot, ringBuffer) 3824 err = &smithy.DeserializationError{ 3825 Err: fmt.Errorf("failed to decode response body, %w", err), 3826 Snapshot: snapshot.Bytes(), 3827 } 3828 return err 3829 } 3830 3831 errorBody.Seek(0, io.SeekStart) 3832 if len(code) != 0 { 3833 errorCode = restjson.SanitizeErrorCode(code) 3834 } 3835 if len(message) != 0 { 3836 errorMessage = message 3837 } 3838 3839 switch { 3840 case strings.EqualFold("InvalidParametersException", errorCode): 3841 return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody) 3842 3843 case strings.EqualFold("ResourceNotFoundException", errorCode): 3844 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 3845 3846 default: 3847 genericError := &smithy.GenericAPIError{ 3848 Code: errorCode, 3849 Message: errorMessage, 3850 } 3851 return genericError 3852 3853 } 3854} 3855 3856type awsAwsjson11_deserializeOpDescribeProvisionedProduct struct { 3857} 3858 3859func (*awsAwsjson11_deserializeOpDescribeProvisionedProduct) ID() string { 3860 return "OperationDeserializer" 3861} 3862 3863func (m *awsAwsjson11_deserializeOpDescribeProvisionedProduct) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3864 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3865) { 3866 out, metadata, err = next.HandleDeserialize(ctx, in) 3867 if err != nil { 3868 return out, metadata, err 3869 } 3870 3871 response, ok := out.RawResponse.(*smithyhttp.Response) 3872 if !ok { 3873 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3874 } 3875 3876 if response.StatusCode < 200 || response.StatusCode >= 300 { 3877 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeProvisionedProduct(response, &metadata) 3878 } 3879 output := &DescribeProvisionedProductOutput{} 3880 out.Result = output 3881 3882 var buff [1024]byte 3883 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3884 3885 body := io.TeeReader(response.Body, ringBuffer) 3886 decoder := json.NewDecoder(body) 3887 decoder.UseNumber() 3888 var shape interface{} 3889 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3890 var snapshot bytes.Buffer 3891 io.Copy(&snapshot, ringBuffer) 3892 err = &smithy.DeserializationError{ 3893 Err: fmt.Errorf("failed to decode response body, %w", err), 3894 Snapshot: snapshot.Bytes(), 3895 } 3896 return out, metadata, err 3897 } 3898 3899 err = awsAwsjson11_deserializeOpDocumentDescribeProvisionedProductOutput(&output, shape) 3900 if err != nil { 3901 var snapshot bytes.Buffer 3902 io.Copy(&snapshot, ringBuffer) 3903 err = &smithy.DeserializationError{ 3904 Err: fmt.Errorf("failed to decode response body, %w", err), 3905 Snapshot: snapshot.Bytes(), 3906 } 3907 return out, metadata, err 3908 } 3909 3910 return out, metadata, err 3911} 3912 3913func awsAwsjson11_deserializeOpErrorDescribeProvisionedProduct(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3914 var errorBuffer bytes.Buffer 3915 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3916 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3917 } 3918 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3919 3920 errorCode := "UnknownError" 3921 errorMessage := errorCode 3922 3923 code := response.Header.Get("X-Amzn-ErrorType") 3924 if len(code) != 0 { 3925 errorCode = restjson.SanitizeErrorCode(code) 3926 } 3927 3928 var buff [1024]byte 3929 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3930 3931 body := io.TeeReader(errorBody, ringBuffer) 3932 decoder := json.NewDecoder(body) 3933 decoder.UseNumber() 3934 code, message, err := restjson.GetErrorInfo(decoder) 3935 if err != nil { 3936 var snapshot bytes.Buffer 3937 io.Copy(&snapshot, ringBuffer) 3938 err = &smithy.DeserializationError{ 3939 Err: fmt.Errorf("failed to decode response body, %w", err), 3940 Snapshot: snapshot.Bytes(), 3941 } 3942 return err 3943 } 3944 3945 errorBody.Seek(0, io.SeekStart) 3946 if len(code) != 0 { 3947 errorCode = restjson.SanitizeErrorCode(code) 3948 } 3949 if len(message) != 0 { 3950 errorMessage = message 3951 } 3952 3953 switch { 3954 case strings.EqualFold("InvalidParametersException", errorCode): 3955 return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody) 3956 3957 case strings.EqualFold("ResourceNotFoundException", errorCode): 3958 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 3959 3960 default: 3961 genericError := &smithy.GenericAPIError{ 3962 Code: errorCode, 3963 Message: errorMessage, 3964 } 3965 return genericError 3966 3967 } 3968} 3969 3970type awsAwsjson11_deserializeOpDescribeProvisionedProductPlan struct { 3971} 3972 3973func (*awsAwsjson11_deserializeOpDescribeProvisionedProductPlan) ID() string { 3974 return "OperationDeserializer" 3975} 3976 3977func (m *awsAwsjson11_deserializeOpDescribeProvisionedProductPlan) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3978 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3979) { 3980 out, metadata, err = next.HandleDeserialize(ctx, in) 3981 if err != nil { 3982 return out, metadata, err 3983 } 3984 3985 response, ok := out.RawResponse.(*smithyhttp.Response) 3986 if !ok { 3987 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3988 } 3989 3990 if response.StatusCode < 200 || response.StatusCode >= 300 { 3991 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeProvisionedProductPlan(response, &metadata) 3992 } 3993 output := &DescribeProvisionedProductPlanOutput{} 3994 out.Result = output 3995 3996 var buff [1024]byte 3997 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3998 3999 body := io.TeeReader(response.Body, ringBuffer) 4000 decoder := json.NewDecoder(body) 4001 decoder.UseNumber() 4002 var shape interface{} 4003 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 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 err = awsAwsjson11_deserializeOpDocumentDescribeProvisionedProductPlanOutput(&output, shape) 4014 if err != nil { 4015 var snapshot bytes.Buffer 4016 io.Copy(&snapshot, ringBuffer) 4017 err = &smithy.DeserializationError{ 4018 Err: fmt.Errorf("failed to decode response body, %w", err), 4019 Snapshot: snapshot.Bytes(), 4020 } 4021 return out, metadata, err 4022 } 4023 4024 return out, metadata, err 4025} 4026 4027func awsAwsjson11_deserializeOpErrorDescribeProvisionedProductPlan(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4028 var errorBuffer bytes.Buffer 4029 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4030 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4031 } 4032 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4033 4034 errorCode := "UnknownError" 4035 errorMessage := errorCode 4036 4037 code := response.Header.Get("X-Amzn-ErrorType") 4038 if len(code) != 0 { 4039 errorCode = restjson.SanitizeErrorCode(code) 4040 } 4041 4042 var buff [1024]byte 4043 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4044 4045 body := io.TeeReader(errorBody, ringBuffer) 4046 decoder := json.NewDecoder(body) 4047 decoder.UseNumber() 4048 code, message, err := restjson.GetErrorInfo(decoder) 4049 if err != nil { 4050 var snapshot bytes.Buffer 4051 io.Copy(&snapshot, ringBuffer) 4052 err = &smithy.DeserializationError{ 4053 Err: fmt.Errorf("failed to decode response body, %w", err), 4054 Snapshot: snapshot.Bytes(), 4055 } 4056 return err 4057 } 4058 4059 errorBody.Seek(0, io.SeekStart) 4060 if len(code) != 0 { 4061 errorCode = restjson.SanitizeErrorCode(code) 4062 } 4063 if len(message) != 0 { 4064 errorMessage = message 4065 } 4066 4067 switch { 4068 case strings.EqualFold("InvalidParametersException", errorCode): 4069 return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody) 4070 4071 case strings.EqualFold("ResourceNotFoundException", errorCode): 4072 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 4073 4074 default: 4075 genericError := &smithy.GenericAPIError{ 4076 Code: errorCode, 4077 Message: errorMessage, 4078 } 4079 return genericError 4080 4081 } 4082} 4083 4084type awsAwsjson11_deserializeOpDescribeProvisioningArtifact struct { 4085} 4086 4087func (*awsAwsjson11_deserializeOpDescribeProvisioningArtifact) ID() string { 4088 return "OperationDeserializer" 4089} 4090 4091func (m *awsAwsjson11_deserializeOpDescribeProvisioningArtifact) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4092 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4093) { 4094 out, metadata, err = next.HandleDeserialize(ctx, in) 4095 if err != nil { 4096 return out, metadata, err 4097 } 4098 4099 response, ok := out.RawResponse.(*smithyhttp.Response) 4100 if !ok { 4101 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4102 } 4103 4104 if response.StatusCode < 200 || response.StatusCode >= 300 { 4105 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeProvisioningArtifact(response, &metadata) 4106 } 4107 output := &DescribeProvisioningArtifactOutput{} 4108 out.Result = output 4109 4110 var buff [1024]byte 4111 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4112 4113 body := io.TeeReader(response.Body, ringBuffer) 4114 decoder := json.NewDecoder(body) 4115 decoder.UseNumber() 4116 var shape interface{} 4117 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4118 var snapshot bytes.Buffer 4119 io.Copy(&snapshot, ringBuffer) 4120 err = &smithy.DeserializationError{ 4121 Err: fmt.Errorf("failed to decode response body, %w", err), 4122 Snapshot: snapshot.Bytes(), 4123 } 4124 return out, metadata, err 4125 } 4126 4127 err = awsAwsjson11_deserializeOpDocumentDescribeProvisioningArtifactOutput(&output, shape) 4128 if err != nil { 4129 var snapshot bytes.Buffer 4130 io.Copy(&snapshot, ringBuffer) 4131 err = &smithy.DeserializationError{ 4132 Err: fmt.Errorf("failed to decode response body, %w", err), 4133 Snapshot: snapshot.Bytes(), 4134 } 4135 return out, metadata, err 4136 } 4137 4138 return out, metadata, err 4139} 4140 4141func awsAwsjson11_deserializeOpErrorDescribeProvisioningArtifact(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4142 var errorBuffer bytes.Buffer 4143 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4144 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4145 } 4146 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4147 4148 errorCode := "UnknownError" 4149 errorMessage := errorCode 4150 4151 code := response.Header.Get("X-Amzn-ErrorType") 4152 if len(code) != 0 { 4153 errorCode = restjson.SanitizeErrorCode(code) 4154 } 4155 4156 var buff [1024]byte 4157 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4158 4159 body := io.TeeReader(errorBody, ringBuffer) 4160 decoder := json.NewDecoder(body) 4161 decoder.UseNumber() 4162 code, message, err := restjson.GetErrorInfo(decoder) 4163 if err != nil { 4164 var snapshot bytes.Buffer 4165 io.Copy(&snapshot, ringBuffer) 4166 err = &smithy.DeserializationError{ 4167 Err: fmt.Errorf("failed to decode response body, %w", err), 4168 Snapshot: snapshot.Bytes(), 4169 } 4170 return err 4171 } 4172 4173 errorBody.Seek(0, io.SeekStart) 4174 if len(code) != 0 { 4175 errorCode = restjson.SanitizeErrorCode(code) 4176 } 4177 if len(message) != 0 { 4178 errorMessage = message 4179 } 4180 4181 switch { 4182 case strings.EqualFold("InvalidParametersException", errorCode): 4183 return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody) 4184 4185 case strings.EqualFold("ResourceNotFoundException", errorCode): 4186 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 4187 4188 default: 4189 genericError := &smithy.GenericAPIError{ 4190 Code: errorCode, 4191 Message: errorMessage, 4192 } 4193 return genericError 4194 4195 } 4196} 4197 4198type awsAwsjson11_deserializeOpDescribeProvisioningParameters struct { 4199} 4200 4201func (*awsAwsjson11_deserializeOpDescribeProvisioningParameters) ID() string { 4202 return "OperationDeserializer" 4203} 4204 4205func (m *awsAwsjson11_deserializeOpDescribeProvisioningParameters) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4206 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4207) { 4208 out, metadata, err = next.HandleDeserialize(ctx, in) 4209 if err != nil { 4210 return out, metadata, err 4211 } 4212 4213 response, ok := out.RawResponse.(*smithyhttp.Response) 4214 if !ok { 4215 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4216 } 4217 4218 if response.StatusCode < 200 || response.StatusCode >= 300 { 4219 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeProvisioningParameters(response, &metadata) 4220 } 4221 output := &DescribeProvisioningParametersOutput{} 4222 out.Result = output 4223 4224 var buff [1024]byte 4225 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4226 4227 body := io.TeeReader(response.Body, ringBuffer) 4228 decoder := json.NewDecoder(body) 4229 decoder.UseNumber() 4230 var shape interface{} 4231 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4232 var snapshot bytes.Buffer 4233 io.Copy(&snapshot, ringBuffer) 4234 err = &smithy.DeserializationError{ 4235 Err: fmt.Errorf("failed to decode response body, %w", err), 4236 Snapshot: snapshot.Bytes(), 4237 } 4238 return out, metadata, err 4239 } 4240 4241 err = awsAwsjson11_deserializeOpDocumentDescribeProvisioningParametersOutput(&output, shape) 4242 if err != nil { 4243 var snapshot bytes.Buffer 4244 io.Copy(&snapshot, ringBuffer) 4245 err = &smithy.DeserializationError{ 4246 Err: fmt.Errorf("failed to decode response body, %w", err), 4247 Snapshot: snapshot.Bytes(), 4248 } 4249 return out, metadata, err 4250 } 4251 4252 return out, metadata, err 4253} 4254 4255func awsAwsjson11_deserializeOpErrorDescribeProvisioningParameters(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4256 var errorBuffer bytes.Buffer 4257 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4258 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4259 } 4260 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4261 4262 errorCode := "UnknownError" 4263 errorMessage := errorCode 4264 4265 code := response.Header.Get("X-Amzn-ErrorType") 4266 if len(code) != 0 { 4267 errorCode = restjson.SanitizeErrorCode(code) 4268 } 4269 4270 var buff [1024]byte 4271 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4272 4273 body := io.TeeReader(errorBody, ringBuffer) 4274 decoder := json.NewDecoder(body) 4275 decoder.UseNumber() 4276 code, message, err := restjson.GetErrorInfo(decoder) 4277 if err != nil { 4278 var snapshot bytes.Buffer 4279 io.Copy(&snapshot, ringBuffer) 4280 err = &smithy.DeserializationError{ 4281 Err: fmt.Errorf("failed to decode response body, %w", err), 4282 Snapshot: snapshot.Bytes(), 4283 } 4284 return err 4285 } 4286 4287 errorBody.Seek(0, io.SeekStart) 4288 if len(code) != 0 { 4289 errorCode = restjson.SanitizeErrorCode(code) 4290 } 4291 if len(message) != 0 { 4292 errorMessage = message 4293 } 4294 4295 switch { 4296 case strings.EqualFold("InvalidParametersException", errorCode): 4297 return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody) 4298 4299 case strings.EqualFold("ResourceNotFoundException", errorCode): 4300 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 4301 4302 default: 4303 genericError := &smithy.GenericAPIError{ 4304 Code: errorCode, 4305 Message: errorMessage, 4306 } 4307 return genericError 4308 4309 } 4310} 4311 4312type awsAwsjson11_deserializeOpDescribeRecord struct { 4313} 4314 4315func (*awsAwsjson11_deserializeOpDescribeRecord) ID() string { 4316 return "OperationDeserializer" 4317} 4318 4319func (m *awsAwsjson11_deserializeOpDescribeRecord) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4320 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4321) { 4322 out, metadata, err = next.HandleDeserialize(ctx, in) 4323 if err != nil { 4324 return out, metadata, err 4325 } 4326 4327 response, ok := out.RawResponse.(*smithyhttp.Response) 4328 if !ok { 4329 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4330 } 4331 4332 if response.StatusCode < 200 || response.StatusCode >= 300 { 4333 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeRecord(response, &metadata) 4334 } 4335 output := &DescribeRecordOutput{} 4336 out.Result = output 4337 4338 var buff [1024]byte 4339 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4340 4341 body := io.TeeReader(response.Body, ringBuffer) 4342 decoder := json.NewDecoder(body) 4343 decoder.UseNumber() 4344 var shape interface{} 4345 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4346 var snapshot bytes.Buffer 4347 io.Copy(&snapshot, ringBuffer) 4348 err = &smithy.DeserializationError{ 4349 Err: fmt.Errorf("failed to decode response body, %w", err), 4350 Snapshot: snapshot.Bytes(), 4351 } 4352 return out, metadata, err 4353 } 4354 4355 err = awsAwsjson11_deserializeOpDocumentDescribeRecordOutput(&output, shape) 4356 if err != nil { 4357 var snapshot bytes.Buffer 4358 io.Copy(&snapshot, ringBuffer) 4359 err = &smithy.DeserializationError{ 4360 Err: fmt.Errorf("failed to decode response body, %w", err), 4361 Snapshot: snapshot.Bytes(), 4362 } 4363 return out, metadata, err 4364 } 4365 4366 return out, metadata, err 4367} 4368 4369func awsAwsjson11_deserializeOpErrorDescribeRecord(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4370 var errorBuffer bytes.Buffer 4371 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4372 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4373 } 4374 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4375 4376 errorCode := "UnknownError" 4377 errorMessage := errorCode 4378 4379 code := response.Header.Get("X-Amzn-ErrorType") 4380 if len(code) != 0 { 4381 errorCode = restjson.SanitizeErrorCode(code) 4382 } 4383 4384 var buff [1024]byte 4385 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4386 4387 body := io.TeeReader(errorBody, ringBuffer) 4388 decoder := json.NewDecoder(body) 4389 decoder.UseNumber() 4390 code, message, err := restjson.GetErrorInfo(decoder) 4391 if err != nil { 4392 var snapshot bytes.Buffer 4393 io.Copy(&snapshot, ringBuffer) 4394 err = &smithy.DeserializationError{ 4395 Err: fmt.Errorf("failed to decode response body, %w", err), 4396 Snapshot: snapshot.Bytes(), 4397 } 4398 return err 4399 } 4400 4401 errorBody.Seek(0, io.SeekStart) 4402 if len(code) != 0 { 4403 errorCode = restjson.SanitizeErrorCode(code) 4404 } 4405 if len(message) != 0 { 4406 errorMessage = message 4407 } 4408 4409 switch { 4410 case strings.EqualFold("ResourceNotFoundException", errorCode): 4411 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 4412 4413 default: 4414 genericError := &smithy.GenericAPIError{ 4415 Code: errorCode, 4416 Message: errorMessage, 4417 } 4418 return genericError 4419 4420 } 4421} 4422 4423type awsAwsjson11_deserializeOpDescribeServiceAction struct { 4424} 4425 4426func (*awsAwsjson11_deserializeOpDescribeServiceAction) ID() string { 4427 return "OperationDeserializer" 4428} 4429 4430func (m *awsAwsjson11_deserializeOpDescribeServiceAction) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4431 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4432) { 4433 out, metadata, err = next.HandleDeserialize(ctx, in) 4434 if err != nil { 4435 return out, metadata, err 4436 } 4437 4438 response, ok := out.RawResponse.(*smithyhttp.Response) 4439 if !ok { 4440 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4441 } 4442 4443 if response.StatusCode < 200 || response.StatusCode >= 300 { 4444 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeServiceAction(response, &metadata) 4445 } 4446 output := &DescribeServiceActionOutput{} 4447 out.Result = output 4448 4449 var buff [1024]byte 4450 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4451 4452 body := io.TeeReader(response.Body, ringBuffer) 4453 decoder := json.NewDecoder(body) 4454 decoder.UseNumber() 4455 var shape interface{} 4456 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4457 var snapshot bytes.Buffer 4458 io.Copy(&snapshot, ringBuffer) 4459 err = &smithy.DeserializationError{ 4460 Err: fmt.Errorf("failed to decode response body, %w", err), 4461 Snapshot: snapshot.Bytes(), 4462 } 4463 return out, metadata, err 4464 } 4465 4466 err = awsAwsjson11_deserializeOpDocumentDescribeServiceActionOutput(&output, shape) 4467 if err != nil { 4468 var snapshot bytes.Buffer 4469 io.Copy(&snapshot, ringBuffer) 4470 err = &smithy.DeserializationError{ 4471 Err: fmt.Errorf("failed to decode response body, %w", err), 4472 Snapshot: snapshot.Bytes(), 4473 } 4474 return out, metadata, err 4475 } 4476 4477 return out, metadata, err 4478} 4479 4480func awsAwsjson11_deserializeOpErrorDescribeServiceAction(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4481 var errorBuffer bytes.Buffer 4482 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4483 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4484 } 4485 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4486 4487 errorCode := "UnknownError" 4488 errorMessage := errorCode 4489 4490 code := response.Header.Get("X-Amzn-ErrorType") 4491 if len(code) != 0 { 4492 errorCode = restjson.SanitizeErrorCode(code) 4493 } 4494 4495 var buff [1024]byte 4496 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4497 4498 body := io.TeeReader(errorBody, ringBuffer) 4499 decoder := json.NewDecoder(body) 4500 decoder.UseNumber() 4501 code, message, err := restjson.GetErrorInfo(decoder) 4502 if err != nil { 4503 var snapshot bytes.Buffer 4504 io.Copy(&snapshot, ringBuffer) 4505 err = &smithy.DeserializationError{ 4506 Err: fmt.Errorf("failed to decode response body, %w", err), 4507 Snapshot: snapshot.Bytes(), 4508 } 4509 return err 4510 } 4511 4512 errorBody.Seek(0, io.SeekStart) 4513 if len(code) != 0 { 4514 errorCode = restjson.SanitizeErrorCode(code) 4515 } 4516 if len(message) != 0 { 4517 errorMessage = message 4518 } 4519 4520 switch { 4521 case strings.EqualFold("ResourceNotFoundException", errorCode): 4522 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 4523 4524 default: 4525 genericError := &smithy.GenericAPIError{ 4526 Code: errorCode, 4527 Message: errorMessage, 4528 } 4529 return genericError 4530 4531 } 4532} 4533 4534type awsAwsjson11_deserializeOpDescribeServiceActionExecutionParameters struct { 4535} 4536 4537func (*awsAwsjson11_deserializeOpDescribeServiceActionExecutionParameters) ID() string { 4538 return "OperationDeserializer" 4539} 4540 4541func (m *awsAwsjson11_deserializeOpDescribeServiceActionExecutionParameters) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4542 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4543) { 4544 out, metadata, err = next.HandleDeserialize(ctx, in) 4545 if err != nil { 4546 return out, metadata, err 4547 } 4548 4549 response, ok := out.RawResponse.(*smithyhttp.Response) 4550 if !ok { 4551 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4552 } 4553 4554 if response.StatusCode < 200 || response.StatusCode >= 300 { 4555 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeServiceActionExecutionParameters(response, &metadata) 4556 } 4557 output := &DescribeServiceActionExecutionParametersOutput{} 4558 out.Result = output 4559 4560 var buff [1024]byte 4561 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4562 4563 body := io.TeeReader(response.Body, ringBuffer) 4564 decoder := json.NewDecoder(body) 4565 decoder.UseNumber() 4566 var shape interface{} 4567 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4568 var snapshot bytes.Buffer 4569 io.Copy(&snapshot, ringBuffer) 4570 err = &smithy.DeserializationError{ 4571 Err: fmt.Errorf("failed to decode response body, %w", err), 4572 Snapshot: snapshot.Bytes(), 4573 } 4574 return out, metadata, err 4575 } 4576 4577 err = awsAwsjson11_deserializeOpDocumentDescribeServiceActionExecutionParametersOutput(&output, shape) 4578 if err != nil { 4579 var snapshot bytes.Buffer 4580 io.Copy(&snapshot, ringBuffer) 4581 err = &smithy.DeserializationError{ 4582 Err: fmt.Errorf("failed to decode response body, %w", err), 4583 Snapshot: snapshot.Bytes(), 4584 } 4585 return out, metadata, err 4586 } 4587 4588 return out, metadata, err 4589} 4590 4591func awsAwsjson11_deserializeOpErrorDescribeServiceActionExecutionParameters(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4592 var errorBuffer bytes.Buffer 4593 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4594 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4595 } 4596 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4597 4598 errorCode := "UnknownError" 4599 errorMessage := errorCode 4600 4601 code := response.Header.Get("X-Amzn-ErrorType") 4602 if len(code) != 0 { 4603 errorCode = restjson.SanitizeErrorCode(code) 4604 } 4605 4606 var buff [1024]byte 4607 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4608 4609 body := io.TeeReader(errorBody, ringBuffer) 4610 decoder := json.NewDecoder(body) 4611 decoder.UseNumber() 4612 code, message, err := restjson.GetErrorInfo(decoder) 4613 if err != nil { 4614 var snapshot bytes.Buffer 4615 io.Copy(&snapshot, ringBuffer) 4616 err = &smithy.DeserializationError{ 4617 Err: fmt.Errorf("failed to decode response body, %w", err), 4618 Snapshot: snapshot.Bytes(), 4619 } 4620 return err 4621 } 4622 4623 errorBody.Seek(0, io.SeekStart) 4624 if len(code) != 0 { 4625 errorCode = restjson.SanitizeErrorCode(code) 4626 } 4627 if len(message) != 0 { 4628 errorMessage = message 4629 } 4630 4631 switch { 4632 case strings.EqualFold("InvalidParametersException", errorCode): 4633 return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody) 4634 4635 case strings.EqualFold("ResourceNotFoundException", errorCode): 4636 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 4637 4638 default: 4639 genericError := &smithy.GenericAPIError{ 4640 Code: errorCode, 4641 Message: errorMessage, 4642 } 4643 return genericError 4644 4645 } 4646} 4647 4648type awsAwsjson11_deserializeOpDescribeTagOption struct { 4649} 4650 4651func (*awsAwsjson11_deserializeOpDescribeTagOption) ID() string { 4652 return "OperationDeserializer" 4653} 4654 4655func (m *awsAwsjson11_deserializeOpDescribeTagOption) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4656 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4657) { 4658 out, metadata, err = next.HandleDeserialize(ctx, in) 4659 if err != nil { 4660 return out, metadata, err 4661 } 4662 4663 response, ok := out.RawResponse.(*smithyhttp.Response) 4664 if !ok { 4665 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4666 } 4667 4668 if response.StatusCode < 200 || response.StatusCode >= 300 { 4669 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeTagOption(response, &metadata) 4670 } 4671 output := &DescribeTagOptionOutput{} 4672 out.Result = output 4673 4674 var buff [1024]byte 4675 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4676 4677 body := io.TeeReader(response.Body, ringBuffer) 4678 decoder := json.NewDecoder(body) 4679 decoder.UseNumber() 4680 var shape interface{} 4681 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4682 var snapshot bytes.Buffer 4683 io.Copy(&snapshot, ringBuffer) 4684 err = &smithy.DeserializationError{ 4685 Err: fmt.Errorf("failed to decode response body, %w", err), 4686 Snapshot: snapshot.Bytes(), 4687 } 4688 return out, metadata, err 4689 } 4690 4691 err = awsAwsjson11_deserializeOpDocumentDescribeTagOptionOutput(&output, shape) 4692 if err != nil { 4693 var snapshot bytes.Buffer 4694 io.Copy(&snapshot, ringBuffer) 4695 err = &smithy.DeserializationError{ 4696 Err: fmt.Errorf("failed to decode response body, %w", err), 4697 Snapshot: snapshot.Bytes(), 4698 } 4699 return out, metadata, err 4700 } 4701 4702 return out, metadata, err 4703} 4704 4705func awsAwsjson11_deserializeOpErrorDescribeTagOption(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4706 var errorBuffer bytes.Buffer 4707 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4708 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4709 } 4710 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4711 4712 errorCode := "UnknownError" 4713 errorMessage := errorCode 4714 4715 code := response.Header.Get("X-Amzn-ErrorType") 4716 if len(code) != 0 { 4717 errorCode = restjson.SanitizeErrorCode(code) 4718 } 4719 4720 var buff [1024]byte 4721 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4722 4723 body := io.TeeReader(errorBody, ringBuffer) 4724 decoder := json.NewDecoder(body) 4725 decoder.UseNumber() 4726 code, message, err := restjson.GetErrorInfo(decoder) 4727 if err != nil { 4728 var snapshot bytes.Buffer 4729 io.Copy(&snapshot, ringBuffer) 4730 err = &smithy.DeserializationError{ 4731 Err: fmt.Errorf("failed to decode response body, %w", err), 4732 Snapshot: snapshot.Bytes(), 4733 } 4734 return err 4735 } 4736 4737 errorBody.Seek(0, io.SeekStart) 4738 if len(code) != 0 { 4739 errorCode = restjson.SanitizeErrorCode(code) 4740 } 4741 if len(message) != 0 { 4742 errorMessage = message 4743 } 4744 4745 switch { 4746 case strings.EqualFold("ResourceNotFoundException", errorCode): 4747 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 4748 4749 case strings.EqualFold("TagOptionNotMigratedException", errorCode): 4750 return awsAwsjson11_deserializeErrorTagOptionNotMigratedException(response, errorBody) 4751 4752 default: 4753 genericError := &smithy.GenericAPIError{ 4754 Code: errorCode, 4755 Message: errorMessage, 4756 } 4757 return genericError 4758 4759 } 4760} 4761 4762type awsAwsjson11_deserializeOpDisableAWSOrganizationsAccess struct { 4763} 4764 4765func (*awsAwsjson11_deserializeOpDisableAWSOrganizationsAccess) ID() string { 4766 return "OperationDeserializer" 4767} 4768 4769func (m *awsAwsjson11_deserializeOpDisableAWSOrganizationsAccess) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4770 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4771) { 4772 out, metadata, err = next.HandleDeserialize(ctx, in) 4773 if err != nil { 4774 return out, metadata, err 4775 } 4776 4777 response, ok := out.RawResponse.(*smithyhttp.Response) 4778 if !ok { 4779 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4780 } 4781 4782 if response.StatusCode < 200 || response.StatusCode >= 300 { 4783 return out, metadata, awsAwsjson11_deserializeOpErrorDisableAWSOrganizationsAccess(response, &metadata) 4784 } 4785 output := &DisableAWSOrganizationsAccessOutput{} 4786 out.Result = output 4787 4788 var buff [1024]byte 4789 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4790 4791 body := io.TeeReader(response.Body, ringBuffer) 4792 decoder := json.NewDecoder(body) 4793 decoder.UseNumber() 4794 var shape interface{} 4795 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4796 var snapshot bytes.Buffer 4797 io.Copy(&snapshot, ringBuffer) 4798 err = &smithy.DeserializationError{ 4799 Err: fmt.Errorf("failed to decode response body, %w", err), 4800 Snapshot: snapshot.Bytes(), 4801 } 4802 return out, metadata, err 4803 } 4804 4805 err = awsAwsjson11_deserializeOpDocumentDisableAWSOrganizationsAccessOutput(&output, shape) 4806 if err != nil { 4807 var snapshot bytes.Buffer 4808 io.Copy(&snapshot, ringBuffer) 4809 err = &smithy.DeserializationError{ 4810 Err: fmt.Errorf("failed to decode response body, %w", err), 4811 Snapshot: snapshot.Bytes(), 4812 } 4813 return out, metadata, err 4814 } 4815 4816 return out, metadata, err 4817} 4818 4819func awsAwsjson11_deserializeOpErrorDisableAWSOrganizationsAccess(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4820 var errorBuffer bytes.Buffer 4821 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4822 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4823 } 4824 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4825 4826 errorCode := "UnknownError" 4827 errorMessage := errorCode 4828 4829 code := response.Header.Get("X-Amzn-ErrorType") 4830 if len(code) != 0 { 4831 errorCode = restjson.SanitizeErrorCode(code) 4832 } 4833 4834 var buff [1024]byte 4835 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4836 4837 body := io.TeeReader(errorBody, ringBuffer) 4838 decoder := json.NewDecoder(body) 4839 decoder.UseNumber() 4840 code, message, err := restjson.GetErrorInfo(decoder) 4841 if err != nil { 4842 var snapshot bytes.Buffer 4843 io.Copy(&snapshot, ringBuffer) 4844 err = &smithy.DeserializationError{ 4845 Err: fmt.Errorf("failed to decode response body, %w", err), 4846 Snapshot: snapshot.Bytes(), 4847 } 4848 return err 4849 } 4850 4851 errorBody.Seek(0, io.SeekStart) 4852 if len(code) != 0 { 4853 errorCode = restjson.SanitizeErrorCode(code) 4854 } 4855 if len(message) != 0 { 4856 errorMessage = message 4857 } 4858 4859 switch { 4860 case strings.EqualFold("InvalidStateException", errorCode): 4861 return awsAwsjson11_deserializeErrorInvalidStateException(response, errorBody) 4862 4863 case strings.EqualFold("OperationNotSupportedException", errorCode): 4864 return awsAwsjson11_deserializeErrorOperationNotSupportedException(response, errorBody) 4865 4866 case strings.EqualFold("ResourceNotFoundException", errorCode): 4867 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 4868 4869 default: 4870 genericError := &smithy.GenericAPIError{ 4871 Code: errorCode, 4872 Message: errorMessage, 4873 } 4874 return genericError 4875 4876 } 4877} 4878 4879type awsAwsjson11_deserializeOpDisassociateBudgetFromResource struct { 4880} 4881 4882func (*awsAwsjson11_deserializeOpDisassociateBudgetFromResource) ID() string { 4883 return "OperationDeserializer" 4884} 4885 4886func (m *awsAwsjson11_deserializeOpDisassociateBudgetFromResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4887 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4888) { 4889 out, metadata, err = next.HandleDeserialize(ctx, in) 4890 if err != nil { 4891 return out, metadata, err 4892 } 4893 4894 response, ok := out.RawResponse.(*smithyhttp.Response) 4895 if !ok { 4896 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4897 } 4898 4899 if response.StatusCode < 200 || response.StatusCode >= 300 { 4900 return out, metadata, awsAwsjson11_deserializeOpErrorDisassociateBudgetFromResource(response, &metadata) 4901 } 4902 output := &DisassociateBudgetFromResourceOutput{} 4903 out.Result = output 4904 4905 var buff [1024]byte 4906 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4907 4908 body := io.TeeReader(response.Body, ringBuffer) 4909 decoder := json.NewDecoder(body) 4910 decoder.UseNumber() 4911 var shape interface{} 4912 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4913 var snapshot bytes.Buffer 4914 io.Copy(&snapshot, ringBuffer) 4915 err = &smithy.DeserializationError{ 4916 Err: fmt.Errorf("failed to decode response body, %w", err), 4917 Snapshot: snapshot.Bytes(), 4918 } 4919 return out, metadata, err 4920 } 4921 4922 err = awsAwsjson11_deserializeOpDocumentDisassociateBudgetFromResourceOutput(&output, shape) 4923 if err != nil { 4924 var snapshot bytes.Buffer 4925 io.Copy(&snapshot, ringBuffer) 4926 err = &smithy.DeserializationError{ 4927 Err: fmt.Errorf("failed to decode response body, %w", err), 4928 Snapshot: snapshot.Bytes(), 4929 } 4930 return out, metadata, err 4931 } 4932 4933 return out, metadata, err 4934} 4935 4936func awsAwsjson11_deserializeOpErrorDisassociateBudgetFromResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4937 var errorBuffer bytes.Buffer 4938 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4939 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4940 } 4941 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4942 4943 errorCode := "UnknownError" 4944 errorMessage := errorCode 4945 4946 code := response.Header.Get("X-Amzn-ErrorType") 4947 if len(code) != 0 { 4948 errorCode = restjson.SanitizeErrorCode(code) 4949 } 4950 4951 var buff [1024]byte 4952 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4953 4954 body := io.TeeReader(errorBody, ringBuffer) 4955 decoder := json.NewDecoder(body) 4956 decoder.UseNumber() 4957 code, message, err := restjson.GetErrorInfo(decoder) 4958 if err != nil { 4959 var snapshot bytes.Buffer 4960 io.Copy(&snapshot, ringBuffer) 4961 err = &smithy.DeserializationError{ 4962 Err: fmt.Errorf("failed to decode response body, %w", err), 4963 Snapshot: snapshot.Bytes(), 4964 } 4965 return err 4966 } 4967 4968 errorBody.Seek(0, io.SeekStart) 4969 if len(code) != 0 { 4970 errorCode = restjson.SanitizeErrorCode(code) 4971 } 4972 if len(message) != 0 { 4973 errorMessage = message 4974 } 4975 4976 switch { 4977 case strings.EqualFold("ResourceNotFoundException", errorCode): 4978 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 4979 4980 default: 4981 genericError := &smithy.GenericAPIError{ 4982 Code: errorCode, 4983 Message: errorMessage, 4984 } 4985 return genericError 4986 4987 } 4988} 4989 4990type awsAwsjson11_deserializeOpDisassociatePrincipalFromPortfolio struct { 4991} 4992 4993func (*awsAwsjson11_deserializeOpDisassociatePrincipalFromPortfolio) ID() string { 4994 return "OperationDeserializer" 4995} 4996 4997func (m *awsAwsjson11_deserializeOpDisassociatePrincipalFromPortfolio) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4998 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4999) { 5000 out, metadata, err = next.HandleDeserialize(ctx, in) 5001 if err != nil { 5002 return out, metadata, err 5003 } 5004 5005 response, ok := out.RawResponse.(*smithyhttp.Response) 5006 if !ok { 5007 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5008 } 5009 5010 if response.StatusCode < 200 || response.StatusCode >= 300 { 5011 return out, metadata, awsAwsjson11_deserializeOpErrorDisassociatePrincipalFromPortfolio(response, &metadata) 5012 } 5013 output := &DisassociatePrincipalFromPortfolioOutput{} 5014 out.Result = output 5015 5016 var buff [1024]byte 5017 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5018 5019 body := io.TeeReader(response.Body, ringBuffer) 5020 decoder := json.NewDecoder(body) 5021 decoder.UseNumber() 5022 var shape interface{} 5023 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5024 var snapshot bytes.Buffer 5025 io.Copy(&snapshot, ringBuffer) 5026 err = &smithy.DeserializationError{ 5027 Err: fmt.Errorf("failed to decode response body, %w", err), 5028 Snapshot: snapshot.Bytes(), 5029 } 5030 return out, metadata, err 5031 } 5032 5033 err = awsAwsjson11_deserializeOpDocumentDisassociatePrincipalFromPortfolioOutput(&output, shape) 5034 if err != nil { 5035 var snapshot bytes.Buffer 5036 io.Copy(&snapshot, ringBuffer) 5037 err = &smithy.DeserializationError{ 5038 Err: fmt.Errorf("failed to decode response body, %w", err), 5039 Snapshot: snapshot.Bytes(), 5040 } 5041 return out, metadata, err 5042 } 5043 5044 return out, metadata, err 5045} 5046 5047func awsAwsjson11_deserializeOpErrorDisassociatePrincipalFromPortfolio(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5048 var errorBuffer bytes.Buffer 5049 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5050 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5051 } 5052 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5053 5054 errorCode := "UnknownError" 5055 errorMessage := errorCode 5056 5057 code := response.Header.Get("X-Amzn-ErrorType") 5058 if len(code) != 0 { 5059 errorCode = restjson.SanitizeErrorCode(code) 5060 } 5061 5062 var buff [1024]byte 5063 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5064 5065 body := io.TeeReader(errorBody, ringBuffer) 5066 decoder := json.NewDecoder(body) 5067 decoder.UseNumber() 5068 code, message, err := restjson.GetErrorInfo(decoder) 5069 if err != nil { 5070 var snapshot bytes.Buffer 5071 io.Copy(&snapshot, ringBuffer) 5072 err = &smithy.DeserializationError{ 5073 Err: fmt.Errorf("failed to decode response body, %w", err), 5074 Snapshot: snapshot.Bytes(), 5075 } 5076 return err 5077 } 5078 5079 errorBody.Seek(0, io.SeekStart) 5080 if len(code) != 0 { 5081 errorCode = restjson.SanitizeErrorCode(code) 5082 } 5083 if len(message) != 0 { 5084 errorMessage = message 5085 } 5086 5087 switch { 5088 case strings.EqualFold("InvalidParametersException", errorCode): 5089 return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody) 5090 5091 case strings.EqualFold("ResourceNotFoundException", errorCode): 5092 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 5093 5094 default: 5095 genericError := &smithy.GenericAPIError{ 5096 Code: errorCode, 5097 Message: errorMessage, 5098 } 5099 return genericError 5100 5101 } 5102} 5103 5104type awsAwsjson11_deserializeOpDisassociateProductFromPortfolio struct { 5105} 5106 5107func (*awsAwsjson11_deserializeOpDisassociateProductFromPortfolio) ID() string { 5108 return "OperationDeserializer" 5109} 5110 5111func (m *awsAwsjson11_deserializeOpDisassociateProductFromPortfolio) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5112 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5113) { 5114 out, metadata, err = next.HandleDeserialize(ctx, in) 5115 if err != nil { 5116 return out, metadata, err 5117 } 5118 5119 response, ok := out.RawResponse.(*smithyhttp.Response) 5120 if !ok { 5121 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5122 } 5123 5124 if response.StatusCode < 200 || response.StatusCode >= 300 { 5125 return out, metadata, awsAwsjson11_deserializeOpErrorDisassociateProductFromPortfolio(response, &metadata) 5126 } 5127 output := &DisassociateProductFromPortfolioOutput{} 5128 out.Result = output 5129 5130 var buff [1024]byte 5131 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5132 5133 body := io.TeeReader(response.Body, ringBuffer) 5134 decoder := json.NewDecoder(body) 5135 decoder.UseNumber() 5136 var shape interface{} 5137 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5138 var snapshot bytes.Buffer 5139 io.Copy(&snapshot, ringBuffer) 5140 err = &smithy.DeserializationError{ 5141 Err: fmt.Errorf("failed to decode response body, %w", err), 5142 Snapshot: snapshot.Bytes(), 5143 } 5144 return out, metadata, err 5145 } 5146 5147 err = awsAwsjson11_deserializeOpDocumentDisassociateProductFromPortfolioOutput(&output, shape) 5148 if err != nil { 5149 var snapshot bytes.Buffer 5150 io.Copy(&snapshot, ringBuffer) 5151 err = &smithy.DeserializationError{ 5152 Err: fmt.Errorf("failed to decode response body, %w", err), 5153 Snapshot: snapshot.Bytes(), 5154 } 5155 return out, metadata, err 5156 } 5157 5158 return out, metadata, err 5159} 5160 5161func awsAwsjson11_deserializeOpErrorDisassociateProductFromPortfolio(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5162 var errorBuffer bytes.Buffer 5163 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5164 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5165 } 5166 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5167 5168 errorCode := "UnknownError" 5169 errorMessage := errorCode 5170 5171 code := response.Header.Get("X-Amzn-ErrorType") 5172 if len(code) != 0 { 5173 errorCode = restjson.SanitizeErrorCode(code) 5174 } 5175 5176 var buff [1024]byte 5177 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5178 5179 body := io.TeeReader(errorBody, ringBuffer) 5180 decoder := json.NewDecoder(body) 5181 decoder.UseNumber() 5182 code, message, err := restjson.GetErrorInfo(decoder) 5183 if err != nil { 5184 var snapshot bytes.Buffer 5185 io.Copy(&snapshot, ringBuffer) 5186 err = &smithy.DeserializationError{ 5187 Err: fmt.Errorf("failed to decode response body, %w", err), 5188 Snapshot: snapshot.Bytes(), 5189 } 5190 return err 5191 } 5192 5193 errorBody.Seek(0, io.SeekStart) 5194 if len(code) != 0 { 5195 errorCode = restjson.SanitizeErrorCode(code) 5196 } 5197 if len(message) != 0 { 5198 errorMessage = message 5199 } 5200 5201 switch { 5202 case strings.EqualFold("InvalidParametersException", errorCode): 5203 return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody) 5204 5205 case strings.EqualFold("ResourceInUseException", errorCode): 5206 return awsAwsjson11_deserializeErrorResourceInUseException(response, errorBody) 5207 5208 case strings.EqualFold("ResourceNotFoundException", errorCode): 5209 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 5210 5211 default: 5212 genericError := &smithy.GenericAPIError{ 5213 Code: errorCode, 5214 Message: errorMessage, 5215 } 5216 return genericError 5217 5218 } 5219} 5220 5221type awsAwsjson11_deserializeOpDisassociateServiceActionFromProvisioningArtifact struct { 5222} 5223 5224func (*awsAwsjson11_deserializeOpDisassociateServiceActionFromProvisioningArtifact) ID() string { 5225 return "OperationDeserializer" 5226} 5227 5228func (m *awsAwsjson11_deserializeOpDisassociateServiceActionFromProvisioningArtifact) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5229 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5230) { 5231 out, metadata, err = next.HandleDeserialize(ctx, in) 5232 if err != nil { 5233 return out, metadata, err 5234 } 5235 5236 response, ok := out.RawResponse.(*smithyhttp.Response) 5237 if !ok { 5238 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5239 } 5240 5241 if response.StatusCode < 200 || response.StatusCode >= 300 { 5242 return out, metadata, awsAwsjson11_deserializeOpErrorDisassociateServiceActionFromProvisioningArtifact(response, &metadata) 5243 } 5244 output := &DisassociateServiceActionFromProvisioningArtifactOutput{} 5245 out.Result = output 5246 5247 var buff [1024]byte 5248 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5249 5250 body := io.TeeReader(response.Body, ringBuffer) 5251 decoder := json.NewDecoder(body) 5252 decoder.UseNumber() 5253 var shape interface{} 5254 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5255 var snapshot bytes.Buffer 5256 io.Copy(&snapshot, ringBuffer) 5257 err = &smithy.DeserializationError{ 5258 Err: fmt.Errorf("failed to decode response body, %w", err), 5259 Snapshot: snapshot.Bytes(), 5260 } 5261 return out, metadata, err 5262 } 5263 5264 err = awsAwsjson11_deserializeOpDocumentDisassociateServiceActionFromProvisioningArtifactOutput(&output, shape) 5265 if err != nil { 5266 var snapshot bytes.Buffer 5267 io.Copy(&snapshot, ringBuffer) 5268 err = &smithy.DeserializationError{ 5269 Err: fmt.Errorf("failed to decode response body, %w", err), 5270 Snapshot: snapshot.Bytes(), 5271 } 5272 return out, metadata, err 5273 } 5274 5275 return out, metadata, err 5276} 5277 5278func awsAwsjson11_deserializeOpErrorDisassociateServiceActionFromProvisioningArtifact(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5279 var errorBuffer bytes.Buffer 5280 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5281 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5282 } 5283 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5284 5285 errorCode := "UnknownError" 5286 errorMessage := errorCode 5287 5288 code := response.Header.Get("X-Amzn-ErrorType") 5289 if len(code) != 0 { 5290 errorCode = restjson.SanitizeErrorCode(code) 5291 } 5292 5293 var buff [1024]byte 5294 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5295 5296 body := io.TeeReader(errorBody, ringBuffer) 5297 decoder := json.NewDecoder(body) 5298 decoder.UseNumber() 5299 code, message, err := restjson.GetErrorInfo(decoder) 5300 if err != nil { 5301 var snapshot bytes.Buffer 5302 io.Copy(&snapshot, ringBuffer) 5303 err = &smithy.DeserializationError{ 5304 Err: fmt.Errorf("failed to decode response body, %w", err), 5305 Snapshot: snapshot.Bytes(), 5306 } 5307 return err 5308 } 5309 5310 errorBody.Seek(0, io.SeekStart) 5311 if len(code) != 0 { 5312 errorCode = restjson.SanitizeErrorCode(code) 5313 } 5314 if len(message) != 0 { 5315 errorMessage = message 5316 } 5317 5318 switch { 5319 case strings.EqualFold("ResourceNotFoundException", errorCode): 5320 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 5321 5322 default: 5323 genericError := &smithy.GenericAPIError{ 5324 Code: errorCode, 5325 Message: errorMessage, 5326 } 5327 return genericError 5328 5329 } 5330} 5331 5332type awsAwsjson11_deserializeOpDisassociateTagOptionFromResource struct { 5333} 5334 5335func (*awsAwsjson11_deserializeOpDisassociateTagOptionFromResource) ID() string { 5336 return "OperationDeserializer" 5337} 5338 5339func (m *awsAwsjson11_deserializeOpDisassociateTagOptionFromResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5340 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5341) { 5342 out, metadata, err = next.HandleDeserialize(ctx, in) 5343 if err != nil { 5344 return out, metadata, err 5345 } 5346 5347 response, ok := out.RawResponse.(*smithyhttp.Response) 5348 if !ok { 5349 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5350 } 5351 5352 if response.StatusCode < 200 || response.StatusCode >= 300 { 5353 return out, metadata, awsAwsjson11_deserializeOpErrorDisassociateTagOptionFromResource(response, &metadata) 5354 } 5355 output := &DisassociateTagOptionFromResourceOutput{} 5356 out.Result = output 5357 5358 var buff [1024]byte 5359 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5360 5361 body := io.TeeReader(response.Body, ringBuffer) 5362 decoder := json.NewDecoder(body) 5363 decoder.UseNumber() 5364 var shape interface{} 5365 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5366 var snapshot bytes.Buffer 5367 io.Copy(&snapshot, ringBuffer) 5368 err = &smithy.DeserializationError{ 5369 Err: fmt.Errorf("failed to decode response body, %w", err), 5370 Snapshot: snapshot.Bytes(), 5371 } 5372 return out, metadata, err 5373 } 5374 5375 err = awsAwsjson11_deserializeOpDocumentDisassociateTagOptionFromResourceOutput(&output, shape) 5376 if err != nil { 5377 var snapshot bytes.Buffer 5378 io.Copy(&snapshot, ringBuffer) 5379 err = &smithy.DeserializationError{ 5380 Err: fmt.Errorf("failed to decode response body, %w", err), 5381 Snapshot: snapshot.Bytes(), 5382 } 5383 return out, metadata, err 5384 } 5385 5386 return out, metadata, err 5387} 5388 5389func awsAwsjson11_deserializeOpErrorDisassociateTagOptionFromResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5390 var errorBuffer bytes.Buffer 5391 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5392 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5393 } 5394 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5395 5396 errorCode := "UnknownError" 5397 errorMessage := errorCode 5398 5399 code := response.Header.Get("X-Amzn-ErrorType") 5400 if len(code) != 0 { 5401 errorCode = restjson.SanitizeErrorCode(code) 5402 } 5403 5404 var buff [1024]byte 5405 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5406 5407 body := io.TeeReader(errorBody, ringBuffer) 5408 decoder := json.NewDecoder(body) 5409 decoder.UseNumber() 5410 code, message, err := restjson.GetErrorInfo(decoder) 5411 if err != nil { 5412 var snapshot bytes.Buffer 5413 io.Copy(&snapshot, ringBuffer) 5414 err = &smithy.DeserializationError{ 5415 Err: fmt.Errorf("failed to decode response body, %w", err), 5416 Snapshot: snapshot.Bytes(), 5417 } 5418 return err 5419 } 5420 5421 errorBody.Seek(0, io.SeekStart) 5422 if len(code) != 0 { 5423 errorCode = restjson.SanitizeErrorCode(code) 5424 } 5425 if len(message) != 0 { 5426 errorMessage = message 5427 } 5428 5429 switch { 5430 case strings.EqualFold("ResourceNotFoundException", errorCode): 5431 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 5432 5433 case strings.EqualFold("TagOptionNotMigratedException", errorCode): 5434 return awsAwsjson11_deserializeErrorTagOptionNotMigratedException(response, errorBody) 5435 5436 default: 5437 genericError := &smithy.GenericAPIError{ 5438 Code: errorCode, 5439 Message: errorMessage, 5440 } 5441 return genericError 5442 5443 } 5444} 5445 5446type awsAwsjson11_deserializeOpEnableAWSOrganizationsAccess struct { 5447} 5448 5449func (*awsAwsjson11_deserializeOpEnableAWSOrganizationsAccess) ID() string { 5450 return "OperationDeserializer" 5451} 5452 5453func (m *awsAwsjson11_deserializeOpEnableAWSOrganizationsAccess) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5454 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5455) { 5456 out, metadata, err = next.HandleDeserialize(ctx, in) 5457 if err != nil { 5458 return out, metadata, err 5459 } 5460 5461 response, ok := out.RawResponse.(*smithyhttp.Response) 5462 if !ok { 5463 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5464 } 5465 5466 if response.StatusCode < 200 || response.StatusCode >= 300 { 5467 return out, metadata, awsAwsjson11_deserializeOpErrorEnableAWSOrganizationsAccess(response, &metadata) 5468 } 5469 output := &EnableAWSOrganizationsAccessOutput{} 5470 out.Result = output 5471 5472 var buff [1024]byte 5473 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5474 5475 body := io.TeeReader(response.Body, ringBuffer) 5476 decoder := json.NewDecoder(body) 5477 decoder.UseNumber() 5478 var shape interface{} 5479 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5480 var snapshot bytes.Buffer 5481 io.Copy(&snapshot, ringBuffer) 5482 err = &smithy.DeserializationError{ 5483 Err: fmt.Errorf("failed to decode response body, %w", err), 5484 Snapshot: snapshot.Bytes(), 5485 } 5486 return out, metadata, err 5487 } 5488 5489 err = awsAwsjson11_deserializeOpDocumentEnableAWSOrganizationsAccessOutput(&output, shape) 5490 if err != nil { 5491 var snapshot bytes.Buffer 5492 io.Copy(&snapshot, ringBuffer) 5493 err = &smithy.DeserializationError{ 5494 Err: fmt.Errorf("failed to decode response body, %w", err), 5495 Snapshot: snapshot.Bytes(), 5496 } 5497 return out, metadata, err 5498 } 5499 5500 return out, metadata, err 5501} 5502 5503func awsAwsjson11_deserializeOpErrorEnableAWSOrganizationsAccess(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5504 var errorBuffer bytes.Buffer 5505 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5506 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5507 } 5508 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5509 5510 errorCode := "UnknownError" 5511 errorMessage := errorCode 5512 5513 code := response.Header.Get("X-Amzn-ErrorType") 5514 if len(code) != 0 { 5515 errorCode = restjson.SanitizeErrorCode(code) 5516 } 5517 5518 var buff [1024]byte 5519 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5520 5521 body := io.TeeReader(errorBody, ringBuffer) 5522 decoder := json.NewDecoder(body) 5523 decoder.UseNumber() 5524 code, message, err := restjson.GetErrorInfo(decoder) 5525 if err != nil { 5526 var snapshot bytes.Buffer 5527 io.Copy(&snapshot, ringBuffer) 5528 err = &smithy.DeserializationError{ 5529 Err: fmt.Errorf("failed to decode response body, %w", err), 5530 Snapshot: snapshot.Bytes(), 5531 } 5532 return err 5533 } 5534 5535 errorBody.Seek(0, io.SeekStart) 5536 if len(code) != 0 { 5537 errorCode = restjson.SanitizeErrorCode(code) 5538 } 5539 if len(message) != 0 { 5540 errorMessage = message 5541 } 5542 5543 switch { 5544 case strings.EqualFold("InvalidStateException", errorCode): 5545 return awsAwsjson11_deserializeErrorInvalidStateException(response, errorBody) 5546 5547 case strings.EqualFold("OperationNotSupportedException", errorCode): 5548 return awsAwsjson11_deserializeErrorOperationNotSupportedException(response, errorBody) 5549 5550 case strings.EqualFold("ResourceNotFoundException", errorCode): 5551 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 5552 5553 default: 5554 genericError := &smithy.GenericAPIError{ 5555 Code: errorCode, 5556 Message: errorMessage, 5557 } 5558 return genericError 5559 5560 } 5561} 5562 5563type awsAwsjson11_deserializeOpExecuteProvisionedProductPlan struct { 5564} 5565 5566func (*awsAwsjson11_deserializeOpExecuteProvisionedProductPlan) ID() string { 5567 return "OperationDeserializer" 5568} 5569 5570func (m *awsAwsjson11_deserializeOpExecuteProvisionedProductPlan) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5571 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5572) { 5573 out, metadata, err = next.HandleDeserialize(ctx, in) 5574 if err != nil { 5575 return out, metadata, err 5576 } 5577 5578 response, ok := out.RawResponse.(*smithyhttp.Response) 5579 if !ok { 5580 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5581 } 5582 5583 if response.StatusCode < 200 || response.StatusCode >= 300 { 5584 return out, metadata, awsAwsjson11_deserializeOpErrorExecuteProvisionedProductPlan(response, &metadata) 5585 } 5586 output := &ExecuteProvisionedProductPlanOutput{} 5587 out.Result = output 5588 5589 var buff [1024]byte 5590 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5591 5592 body := io.TeeReader(response.Body, ringBuffer) 5593 decoder := json.NewDecoder(body) 5594 decoder.UseNumber() 5595 var shape interface{} 5596 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5597 var snapshot bytes.Buffer 5598 io.Copy(&snapshot, ringBuffer) 5599 err = &smithy.DeserializationError{ 5600 Err: fmt.Errorf("failed to decode response body, %w", err), 5601 Snapshot: snapshot.Bytes(), 5602 } 5603 return out, metadata, err 5604 } 5605 5606 err = awsAwsjson11_deserializeOpDocumentExecuteProvisionedProductPlanOutput(&output, shape) 5607 if err != nil { 5608 var snapshot bytes.Buffer 5609 io.Copy(&snapshot, ringBuffer) 5610 err = &smithy.DeserializationError{ 5611 Err: fmt.Errorf("failed to decode response body, %w", err), 5612 Snapshot: snapshot.Bytes(), 5613 } 5614 return out, metadata, err 5615 } 5616 5617 return out, metadata, err 5618} 5619 5620func awsAwsjson11_deserializeOpErrorExecuteProvisionedProductPlan(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5621 var errorBuffer bytes.Buffer 5622 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5623 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5624 } 5625 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5626 5627 errorCode := "UnknownError" 5628 errorMessage := errorCode 5629 5630 code := response.Header.Get("X-Amzn-ErrorType") 5631 if len(code) != 0 { 5632 errorCode = restjson.SanitizeErrorCode(code) 5633 } 5634 5635 var buff [1024]byte 5636 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5637 5638 body := io.TeeReader(errorBody, ringBuffer) 5639 decoder := json.NewDecoder(body) 5640 decoder.UseNumber() 5641 code, message, err := restjson.GetErrorInfo(decoder) 5642 if err != nil { 5643 var snapshot bytes.Buffer 5644 io.Copy(&snapshot, ringBuffer) 5645 err = &smithy.DeserializationError{ 5646 Err: fmt.Errorf("failed to decode response body, %w", err), 5647 Snapshot: snapshot.Bytes(), 5648 } 5649 return err 5650 } 5651 5652 errorBody.Seek(0, io.SeekStart) 5653 if len(code) != 0 { 5654 errorCode = restjson.SanitizeErrorCode(code) 5655 } 5656 if len(message) != 0 { 5657 errorMessage = message 5658 } 5659 5660 switch { 5661 case strings.EqualFold("InvalidParametersException", errorCode): 5662 return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody) 5663 5664 case strings.EqualFold("InvalidStateException", errorCode): 5665 return awsAwsjson11_deserializeErrorInvalidStateException(response, errorBody) 5666 5667 case strings.EqualFold("ResourceNotFoundException", errorCode): 5668 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 5669 5670 default: 5671 genericError := &smithy.GenericAPIError{ 5672 Code: errorCode, 5673 Message: errorMessage, 5674 } 5675 return genericError 5676 5677 } 5678} 5679 5680type awsAwsjson11_deserializeOpExecuteProvisionedProductServiceAction struct { 5681} 5682 5683func (*awsAwsjson11_deserializeOpExecuteProvisionedProductServiceAction) ID() string { 5684 return "OperationDeserializer" 5685} 5686 5687func (m *awsAwsjson11_deserializeOpExecuteProvisionedProductServiceAction) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5688 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5689) { 5690 out, metadata, err = next.HandleDeserialize(ctx, in) 5691 if err != nil { 5692 return out, metadata, err 5693 } 5694 5695 response, ok := out.RawResponse.(*smithyhttp.Response) 5696 if !ok { 5697 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5698 } 5699 5700 if response.StatusCode < 200 || response.StatusCode >= 300 { 5701 return out, metadata, awsAwsjson11_deserializeOpErrorExecuteProvisionedProductServiceAction(response, &metadata) 5702 } 5703 output := &ExecuteProvisionedProductServiceActionOutput{} 5704 out.Result = output 5705 5706 var buff [1024]byte 5707 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5708 5709 body := io.TeeReader(response.Body, ringBuffer) 5710 decoder := json.NewDecoder(body) 5711 decoder.UseNumber() 5712 var shape interface{} 5713 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5714 var snapshot bytes.Buffer 5715 io.Copy(&snapshot, ringBuffer) 5716 err = &smithy.DeserializationError{ 5717 Err: fmt.Errorf("failed to decode response body, %w", err), 5718 Snapshot: snapshot.Bytes(), 5719 } 5720 return out, metadata, err 5721 } 5722 5723 err = awsAwsjson11_deserializeOpDocumentExecuteProvisionedProductServiceActionOutput(&output, shape) 5724 if err != nil { 5725 var snapshot bytes.Buffer 5726 io.Copy(&snapshot, ringBuffer) 5727 err = &smithy.DeserializationError{ 5728 Err: fmt.Errorf("failed to decode response body, %w", err), 5729 Snapshot: snapshot.Bytes(), 5730 } 5731 return out, metadata, err 5732 } 5733 5734 return out, metadata, err 5735} 5736 5737func awsAwsjson11_deserializeOpErrorExecuteProvisionedProductServiceAction(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5738 var errorBuffer bytes.Buffer 5739 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5740 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5741 } 5742 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5743 5744 errorCode := "UnknownError" 5745 errorMessage := errorCode 5746 5747 code := response.Header.Get("X-Amzn-ErrorType") 5748 if len(code) != 0 { 5749 errorCode = restjson.SanitizeErrorCode(code) 5750 } 5751 5752 var buff [1024]byte 5753 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5754 5755 body := io.TeeReader(errorBody, ringBuffer) 5756 decoder := json.NewDecoder(body) 5757 decoder.UseNumber() 5758 code, message, err := restjson.GetErrorInfo(decoder) 5759 if err != nil { 5760 var snapshot bytes.Buffer 5761 io.Copy(&snapshot, ringBuffer) 5762 err = &smithy.DeserializationError{ 5763 Err: fmt.Errorf("failed to decode response body, %w", err), 5764 Snapshot: snapshot.Bytes(), 5765 } 5766 return err 5767 } 5768 5769 errorBody.Seek(0, io.SeekStart) 5770 if len(code) != 0 { 5771 errorCode = restjson.SanitizeErrorCode(code) 5772 } 5773 if len(message) != 0 { 5774 errorMessage = message 5775 } 5776 5777 switch { 5778 case strings.EqualFold("InvalidParametersException", errorCode): 5779 return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody) 5780 5781 case strings.EqualFold("InvalidStateException", errorCode): 5782 return awsAwsjson11_deserializeErrorInvalidStateException(response, errorBody) 5783 5784 case strings.EqualFold("ResourceNotFoundException", errorCode): 5785 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 5786 5787 default: 5788 genericError := &smithy.GenericAPIError{ 5789 Code: errorCode, 5790 Message: errorMessage, 5791 } 5792 return genericError 5793 5794 } 5795} 5796 5797type awsAwsjson11_deserializeOpGetAWSOrganizationsAccessStatus struct { 5798} 5799 5800func (*awsAwsjson11_deserializeOpGetAWSOrganizationsAccessStatus) ID() string { 5801 return "OperationDeserializer" 5802} 5803 5804func (m *awsAwsjson11_deserializeOpGetAWSOrganizationsAccessStatus) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5805 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5806) { 5807 out, metadata, err = next.HandleDeserialize(ctx, in) 5808 if err != nil { 5809 return out, metadata, err 5810 } 5811 5812 response, ok := out.RawResponse.(*smithyhttp.Response) 5813 if !ok { 5814 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5815 } 5816 5817 if response.StatusCode < 200 || response.StatusCode >= 300 { 5818 return out, metadata, awsAwsjson11_deserializeOpErrorGetAWSOrganizationsAccessStatus(response, &metadata) 5819 } 5820 output := &GetAWSOrganizationsAccessStatusOutput{} 5821 out.Result = output 5822 5823 var buff [1024]byte 5824 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5825 5826 body := io.TeeReader(response.Body, ringBuffer) 5827 decoder := json.NewDecoder(body) 5828 decoder.UseNumber() 5829 var shape interface{} 5830 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5831 var snapshot bytes.Buffer 5832 io.Copy(&snapshot, ringBuffer) 5833 err = &smithy.DeserializationError{ 5834 Err: fmt.Errorf("failed to decode response body, %w", err), 5835 Snapshot: snapshot.Bytes(), 5836 } 5837 return out, metadata, err 5838 } 5839 5840 err = awsAwsjson11_deserializeOpDocumentGetAWSOrganizationsAccessStatusOutput(&output, shape) 5841 if err != nil { 5842 var snapshot bytes.Buffer 5843 io.Copy(&snapshot, ringBuffer) 5844 err = &smithy.DeserializationError{ 5845 Err: fmt.Errorf("failed to decode response body, %w", err), 5846 Snapshot: snapshot.Bytes(), 5847 } 5848 return out, metadata, err 5849 } 5850 5851 return out, metadata, err 5852} 5853 5854func awsAwsjson11_deserializeOpErrorGetAWSOrganizationsAccessStatus(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5855 var errorBuffer bytes.Buffer 5856 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5857 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5858 } 5859 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5860 5861 errorCode := "UnknownError" 5862 errorMessage := errorCode 5863 5864 code := response.Header.Get("X-Amzn-ErrorType") 5865 if len(code) != 0 { 5866 errorCode = restjson.SanitizeErrorCode(code) 5867 } 5868 5869 var buff [1024]byte 5870 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5871 5872 body := io.TeeReader(errorBody, ringBuffer) 5873 decoder := json.NewDecoder(body) 5874 decoder.UseNumber() 5875 code, message, err := restjson.GetErrorInfo(decoder) 5876 if err != nil { 5877 var snapshot bytes.Buffer 5878 io.Copy(&snapshot, ringBuffer) 5879 err = &smithy.DeserializationError{ 5880 Err: fmt.Errorf("failed to decode response body, %w", err), 5881 Snapshot: snapshot.Bytes(), 5882 } 5883 return err 5884 } 5885 5886 errorBody.Seek(0, io.SeekStart) 5887 if len(code) != 0 { 5888 errorCode = restjson.SanitizeErrorCode(code) 5889 } 5890 if len(message) != 0 { 5891 errorMessage = message 5892 } 5893 5894 switch { 5895 case strings.EqualFold("OperationNotSupportedException", errorCode): 5896 return awsAwsjson11_deserializeErrorOperationNotSupportedException(response, errorBody) 5897 5898 case strings.EqualFold("ResourceNotFoundException", errorCode): 5899 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 5900 5901 default: 5902 genericError := &smithy.GenericAPIError{ 5903 Code: errorCode, 5904 Message: errorMessage, 5905 } 5906 return genericError 5907 5908 } 5909} 5910 5911type awsAwsjson11_deserializeOpGetProvisionedProductOutputs struct { 5912} 5913 5914func (*awsAwsjson11_deserializeOpGetProvisionedProductOutputs) ID() string { 5915 return "OperationDeserializer" 5916} 5917 5918func (m *awsAwsjson11_deserializeOpGetProvisionedProductOutputs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5919 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5920) { 5921 out, metadata, err = next.HandleDeserialize(ctx, in) 5922 if err != nil { 5923 return out, metadata, err 5924 } 5925 5926 response, ok := out.RawResponse.(*smithyhttp.Response) 5927 if !ok { 5928 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5929 } 5930 5931 if response.StatusCode < 200 || response.StatusCode >= 300 { 5932 return out, metadata, awsAwsjson11_deserializeOpErrorGetProvisionedProductOutputs(response, &metadata) 5933 } 5934 output := &GetProvisionedProductOutputsOutput{} 5935 out.Result = output 5936 5937 var buff [1024]byte 5938 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5939 5940 body := io.TeeReader(response.Body, ringBuffer) 5941 decoder := json.NewDecoder(body) 5942 decoder.UseNumber() 5943 var shape interface{} 5944 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5945 var snapshot bytes.Buffer 5946 io.Copy(&snapshot, ringBuffer) 5947 err = &smithy.DeserializationError{ 5948 Err: fmt.Errorf("failed to decode response body, %w", err), 5949 Snapshot: snapshot.Bytes(), 5950 } 5951 return out, metadata, err 5952 } 5953 5954 err = awsAwsjson11_deserializeOpDocumentGetProvisionedProductOutputsOutput(&output, shape) 5955 if err != nil { 5956 var snapshot bytes.Buffer 5957 io.Copy(&snapshot, ringBuffer) 5958 err = &smithy.DeserializationError{ 5959 Err: fmt.Errorf("failed to decode response body, %w", err), 5960 Snapshot: snapshot.Bytes(), 5961 } 5962 return out, metadata, err 5963 } 5964 5965 return out, metadata, err 5966} 5967 5968func awsAwsjson11_deserializeOpErrorGetProvisionedProductOutputs(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5969 var errorBuffer bytes.Buffer 5970 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5971 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5972 } 5973 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5974 5975 errorCode := "UnknownError" 5976 errorMessage := errorCode 5977 5978 code := response.Header.Get("X-Amzn-ErrorType") 5979 if len(code) != 0 { 5980 errorCode = restjson.SanitizeErrorCode(code) 5981 } 5982 5983 var buff [1024]byte 5984 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5985 5986 body := io.TeeReader(errorBody, ringBuffer) 5987 decoder := json.NewDecoder(body) 5988 decoder.UseNumber() 5989 code, message, err := restjson.GetErrorInfo(decoder) 5990 if err != nil { 5991 var snapshot bytes.Buffer 5992 io.Copy(&snapshot, ringBuffer) 5993 err = &smithy.DeserializationError{ 5994 Err: fmt.Errorf("failed to decode response body, %w", err), 5995 Snapshot: snapshot.Bytes(), 5996 } 5997 return err 5998 } 5999 6000 errorBody.Seek(0, io.SeekStart) 6001 if len(code) != 0 { 6002 errorCode = restjson.SanitizeErrorCode(code) 6003 } 6004 if len(message) != 0 { 6005 errorMessage = message 6006 } 6007 6008 switch { 6009 case strings.EqualFold("InvalidParametersException", errorCode): 6010 return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody) 6011 6012 case strings.EqualFold("ResourceNotFoundException", errorCode): 6013 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 6014 6015 default: 6016 genericError := &smithy.GenericAPIError{ 6017 Code: errorCode, 6018 Message: errorMessage, 6019 } 6020 return genericError 6021 6022 } 6023} 6024 6025type awsAwsjson11_deserializeOpImportAsProvisionedProduct struct { 6026} 6027 6028func (*awsAwsjson11_deserializeOpImportAsProvisionedProduct) ID() string { 6029 return "OperationDeserializer" 6030} 6031 6032func (m *awsAwsjson11_deserializeOpImportAsProvisionedProduct) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6033 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6034) { 6035 out, metadata, err = next.HandleDeserialize(ctx, in) 6036 if err != nil { 6037 return out, metadata, err 6038 } 6039 6040 response, ok := out.RawResponse.(*smithyhttp.Response) 6041 if !ok { 6042 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6043 } 6044 6045 if response.StatusCode < 200 || response.StatusCode >= 300 { 6046 return out, metadata, awsAwsjson11_deserializeOpErrorImportAsProvisionedProduct(response, &metadata) 6047 } 6048 output := &ImportAsProvisionedProductOutput{} 6049 out.Result = output 6050 6051 var buff [1024]byte 6052 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6053 6054 body := io.TeeReader(response.Body, ringBuffer) 6055 decoder := json.NewDecoder(body) 6056 decoder.UseNumber() 6057 var shape interface{} 6058 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6059 var snapshot bytes.Buffer 6060 io.Copy(&snapshot, ringBuffer) 6061 err = &smithy.DeserializationError{ 6062 Err: fmt.Errorf("failed to decode response body, %w", err), 6063 Snapshot: snapshot.Bytes(), 6064 } 6065 return out, metadata, err 6066 } 6067 6068 err = awsAwsjson11_deserializeOpDocumentImportAsProvisionedProductOutput(&output, shape) 6069 if err != nil { 6070 var snapshot bytes.Buffer 6071 io.Copy(&snapshot, ringBuffer) 6072 err = &smithy.DeserializationError{ 6073 Err: fmt.Errorf("failed to decode response body, %w", err), 6074 Snapshot: snapshot.Bytes(), 6075 } 6076 return out, metadata, err 6077 } 6078 6079 return out, metadata, err 6080} 6081 6082func awsAwsjson11_deserializeOpErrorImportAsProvisionedProduct(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6083 var errorBuffer bytes.Buffer 6084 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6085 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6086 } 6087 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6088 6089 errorCode := "UnknownError" 6090 errorMessage := errorCode 6091 6092 code := response.Header.Get("X-Amzn-ErrorType") 6093 if len(code) != 0 { 6094 errorCode = restjson.SanitizeErrorCode(code) 6095 } 6096 6097 var buff [1024]byte 6098 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6099 6100 body := io.TeeReader(errorBody, ringBuffer) 6101 decoder := json.NewDecoder(body) 6102 decoder.UseNumber() 6103 code, message, err := restjson.GetErrorInfo(decoder) 6104 if err != nil { 6105 var snapshot bytes.Buffer 6106 io.Copy(&snapshot, ringBuffer) 6107 err = &smithy.DeserializationError{ 6108 Err: fmt.Errorf("failed to decode response body, %w", err), 6109 Snapshot: snapshot.Bytes(), 6110 } 6111 return err 6112 } 6113 6114 errorBody.Seek(0, io.SeekStart) 6115 if len(code) != 0 { 6116 errorCode = restjson.SanitizeErrorCode(code) 6117 } 6118 if len(message) != 0 { 6119 errorMessage = message 6120 } 6121 6122 switch { 6123 case strings.EqualFold("DuplicateResourceException", errorCode): 6124 return awsAwsjson11_deserializeErrorDuplicateResourceException(response, errorBody) 6125 6126 case strings.EqualFold("InvalidParametersException", errorCode): 6127 return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody) 6128 6129 case strings.EqualFold("InvalidStateException", errorCode): 6130 return awsAwsjson11_deserializeErrorInvalidStateException(response, errorBody) 6131 6132 case strings.EqualFold("ResourceNotFoundException", errorCode): 6133 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 6134 6135 default: 6136 genericError := &smithy.GenericAPIError{ 6137 Code: errorCode, 6138 Message: errorMessage, 6139 } 6140 return genericError 6141 6142 } 6143} 6144 6145type awsAwsjson11_deserializeOpListAcceptedPortfolioShares struct { 6146} 6147 6148func (*awsAwsjson11_deserializeOpListAcceptedPortfolioShares) ID() string { 6149 return "OperationDeserializer" 6150} 6151 6152func (m *awsAwsjson11_deserializeOpListAcceptedPortfolioShares) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6153 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6154) { 6155 out, metadata, err = next.HandleDeserialize(ctx, in) 6156 if err != nil { 6157 return out, metadata, err 6158 } 6159 6160 response, ok := out.RawResponse.(*smithyhttp.Response) 6161 if !ok { 6162 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6163 } 6164 6165 if response.StatusCode < 200 || response.StatusCode >= 300 { 6166 return out, metadata, awsAwsjson11_deserializeOpErrorListAcceptedPortfolioShares(response, &metadata) 6167 } 6168 output := &ListAcceptedPortfolioSharesOutput{} 6169 out.Result = output 6170 6171 var buff [1024]byte 6172 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6173 6174 body := io.TeeReader(response.Body, ringBuffer) 6175 decoder := json.NewDecoder(body) 6176 decoder.UseNumber() 6177 var shape interface{} 6178 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6179 var snapshot bytes.Buffer 6180 io.Copy(&snapshot, ringBuffer) 6181 err = &smithy.DeserializationError{ 6182 Err: fmt.Errorf("failed to decode response body, %w", err), 6183 Snapshot: snapshot.Bytes(), 6184 } 6185 return out, metadata, err 6186 } 6187 6188 err = awsAwsjson11_deserializeOpDocumentListAcceptedPortfolioSharesOutput(&output, shape) 6189 if err != nil { 6190 var snapshot bytes.Buffer 6191 io.Copy(&snapshot, ringBuffer) 6192 err = &smithy.DeserializationError{ 6193 Err: fmt.Errorf("failed to decode response body, %w", err), 6194 Snapshot: snapshot.Bytes(), 6195 } 6196 return out, metadata, err 6197 } 6198 6199 return out, metadata, err 6200} 6201 6202func awsAwsjson11_deserializeOpErrorListAcceptedPortfolioShares(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6203 var errorBuffer bytes.Buffer 6204 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6205 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6206 } 6207 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6208 6209 errorCode := "UnknownError" 6210 errorMessage := errorCode 6211 6212 code := response.Header.Get("X-Amzn-ErrorType") 6213 if len(code) != 0 { 6214 errorCode = restjson.SanitizeErrorCode(code) 6215 } 6216 6217 var buff [1024]byte 6218 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6219 6220 body := io.TeeReader(errorBody, ringBuffer) 6221 decoder := json.NewDecoder(body) 6222 decoder.UseNumber() 6223 code, message, err := restjson.GetErrorInfo(decoder) 6224 if err != nil { 6225 var snapshot bytes.Buffer 6226 io.Copy(&snapshot, ringBuffer) 6227 err = &smithy.DeserializationError{ 6228 Err: fmt.Errorf("failed to decode response body, %w", err), 6229 Snapshot: snapshot.Bytes(), 6230 } 6231 return err 6232 } 6233 6234 errorBody.Seek(0, io.SeekStart) 6235 if len(code) != 0 { 6236 errorCode = restjson.SanitizeErrorCode(code) 6237 } 6238 if len(message) != 0 { 6239 errorMessage = message 6240 } 6241 6242 switch { 6243 case strings.EqualFold("InvalidParametersException", errorCode): 6244 return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody) 6245 6246 case strings.EqualFold("OperationNotSupportedException", errorCode): 6247 return awsAwsjson11_deserializeErrorOperationNotSupportedException(response, errorBody) 6248 6249 default: 6250 genericError := &smithy.GenericAPIError{ 6251 Code: errorCode, 6252 Message: errorMessage, 6253 } 6254 return genericError 6255 6256 } 6257} 6258 6259type awsAwsjson11_deserializeOpListBudgetsForResource struct { 6260} 6261 6262func (*awsAwsjson11_deserializeOpListBudgetsForResource) ID() string { 6263 return "OperationDeserializer" 6264} 6265 6266func (m *awsAwsjson11_deserializeOpListBudgetsForResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6267 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6268) { 6269 out, metadata, err = next.HandleDeserialize(ctx, in) 6270 if err != nil { 6271 return out, metadata, err 6272 } 6273 6274 response, ok := out.RawResponse.(*smithyhttp.Response) 6275 if !ok { 6276 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6277 } 6278 6279 if response.StatusCode < 200 || response.StatusCode >= 300 { 6280 return out, metadata, awsAwsjson11_deserializeOpErrorListBudgetsForResource(response, &metadata) 6281 } 6282 output := &ListBudgetsForResourceOutput{} 6283 out.Result = output 6284 6285 var buff [1024]byte 6286 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6287 6288 body := io.TeeReader(response.Body, ringBuffer) 6289 decoder := json.NewDecoder(body) 6290 decoder.UseNumber() 6291 var shape interface{} 6292 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6293 var snapshot bytes.Buffer 6294 io.Copy(&snapshot, ringBuffer) 6295 err = &smithy.DeserializationError{ 6296 Err: fmt.Errorf("failed to decode response body, %w", err), 6297 Snapshot: snapshot.Bytes(), 6298 } 6299 return out, metadata, err 6300 } 6301 6302 err = awsAwsjson11_deserializeOpDocumentListBudgetsForResourceOutput(&output, shape) 6303 if err != nil { 6304 var snapshot bytes.Buffer 6305 io.Copy(&snapshot, ringBuffer) 6306 err = &smithy.DeserializationError{ 6307 Err: fmt.Errorf("failed to decode response body, %w", err), 6308 Snapshot: snapshot.Bytes(), 6309 } 6310 return out, metadata, err 6311 } 6312 6313 return out, metadata, err 6314} 6315 6316func awsAwsjson11_deserializeOpErrorListBudgetsForResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6317 var errorBuffer bytes.Buffer 6318 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6319 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6320 } 6321 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6322 6323 errorCode := "UnknownError" 6324 errorMessage := errorCode 6325 6326 code := response.Header.Get("X-Amzn-ErrorType") 6327 if len(code) != 0 { 6328 errorCode = restjson.SanitizeErrorCode(code) 6329 } 6330 6331 var buff [1024]byte 6332 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6333 6334 body := io.TeeReader(errorBody, ringBuffer) 6335 decoder := json.NewDecoder(body) 6336 decoder.UseNumber() 6337 code, message, err := restjson.GetErrorInfo(decoder) 6338 if err != nil { 6339 var snapshot bytes.Buffer 6340 io.Copy(&snapshot, ringBuffer) 6341 err = &smithy.DeserializationError{ 6342 Err: fmt.Errorf("failed to decode response body, %w", err), 6343 Snapshot: snapshot.Bytes(), 6344 } 6345 return err 6346 } 6347 6348 errorBody.Seek(0, io.SeekStart) 6349 if len(code) != 0 { 6350 errorCode = restjson.SanitizeErrorCode(code) 6351 } 6352 if len(message) != 0 { 6353 errorMessage = message 6354 } 6355 6356 switch { 6357 case strings.EqualFold("InvalidParametersException", errorCode): 6358 return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody) 6359 6360 case strings.EqualFold("ResourceNotFoundException", errorCode): 6361 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 6362 6363 default: 6364 genericError := &smithy.GenericAPIError{ 6365 Code: errorCode, 6366 Message: errorMessage, 6367 } 6368 return genericError 6369 6370 } 6371} 6372 6373type awsAwsjson11_deserializeOpListConstraintsForPortfolio struct { 6374} 6375 6376func (*awsAwsjson11_deserializeOpListConstraintsForPortfolio) ID() string { 6377 return "OperationDeserializer" 6378} 6379 6380func (m *awsAwsjson11_deserializeOpListConstraintsForPortfolio) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6381 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6382) { 6383 out, metadata, err = next.HandleDeserialize(ctx, in) 6384 if err != nil { 6385 return out, metadata, err 6386 } 6387 6388 response, ok := out.RawResponse.(*smithyhttp.Response) 6389 if !ok { 6390 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6391 } 6392 6393 if response.StatusCode < 200 || response.StatusCode >= 300 { 6394 return out, metadata, awsAwsjson11_deserializeOpErrorListConstraintsForPortfolio(response, &metadata) 6395 } 6396 output := &ListConstraintsForPortfolioOutput{} 6397 out.Result = output 6398 6399 var buff [1024]byte 6400 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6401 6402 body := io.TeeReader(response.Body, ringBuffer) 6403 decoder := json.NewDecoder(body) 6404 decoder.UseNumber() 6405 var shape interface{} 6406 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6407 var snapshot bytes.Buffer 6408 io.Copy(&snapshot, ringBuffer) 6409 err = &smithy.DeserializationError{ 6410 Err: fmt.Errorf("failed to decode response body, %w", err), 6411 Snapshot: snapshot.Bytes(), 6412 } 6413 return out, metadata, err 6414 } 6415 6416 err = awsAwsjson11_deserializeOpDocumentListConstraintsForPortfolioOutput(&output, shape) 6417 if err != nil { 6418 var snapshot bytes.Buffer 6419 io.Copy(&snapshot, ringBuffer) 6420 err = &smithy.DeserializationError{ 6421 Err: fmt.Errorf("failed to decode response body, %w", err), 6422 Snapshot: snapshot.Bytes(), 6423 } 6424 return out, metadata, err 6425 } 6426 6427 return out, metadata, err 6428} 6429 6430func awsAwsjson11_deserializeOpErrorListConstraintsForPortfolio(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6431 var errorBuffer bytes.Buffer 6432 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6433 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6434 } 6435 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6436 6437 errorCode := "UnknownError" 6438 errorMessage := errorCode 6439 6440 code := response.Header.Get("X-Amzn-ErrorType") 6441 if len(code) != 0 { 6442 errorCode = restjson.SanitizeErrorCode(code) 6443 } 6444 6445 var buff [1024]byte 6446 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6447 6448 body := io.TeeReader(errorBody, ringBuffer) 6449 decoder := json.NewDecoder(body) 6450 decoder.UseNumber() 6451 code, message, err := restjson.GetErrorInfo(decoder) 6452 if err != nil { 6453 var snapshot bytes.Buffer 6454 io.Copy(&snapshot, ringBuffer) 6455 err = &smithy.DeserializationError{ 6456 Err: fmt.Errorf("failed to decode response body, %w", err), 6457 Snapshot: snapshot.Bytes(), 6458 } 6459 return err 6460 } 6461 6462 errorBody.Seek(0, io.SeekStart) 6463 if len(code) != 0 { 6464 errorCode = restjson.SanitizeErrorCode(code) 6465 } 6466 if len(message) != 0 { 6467 errorMessage = message 6468 } 6469 6470 switch { 6471 case strings.EqualFold("InvalidParametersException", errorCode): 6472 return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody) 6473 6474 case strings.EqualFold("ResourceNotFoundException", errorCode): 6475 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 6476 6477 default: 6478 genericError := &smithy.GenericAPIError{ 6479 Code: errorCode, 6480 Message: errorMessage, 6481 } 6482 return genericError 6483 6484 } 6485} 6486 6487type awsAwsjson11_deserializeOpListLaunchPaths struct { 6488} 6489 6490func (*awsAwsjson11_deserializeOpListLaunchPaths) ID() string { 6491 return "OperationDeserializer" 6492} 6493 6494func (m *awsAwsjson11_deserializeOpListLaunchPaths) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6495 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6496) { 6497 out, metadata, err = next.HandleDeserialize(ctx, in) 6498 if err != nil { 6499 return out, metadata, err 6500 } 6501 6502 response, ok := out.RawResponse.(*smithyhttp.Response) 6503 if !ok { 6504 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6505 } 6506 6507 if response.StatusCode < 200 || response.StatusCode >= 300 { 6508 return out, metadata, awsAwsjson11_deserializeOpErrorListLaunchPaths(response, &metadata) 6509 } 6510 output := &ListLaunchPathsOutput{} 6511 out.Result = output 6512 6513 var buff [1024]byte 6514 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6515 6516 body := io.TeeReader(response.Body, ringBuffer) 6517 decoder := json.NewDecoder(body) 6518 decoder.UseNumber() 6519 var shape interface{} 6520 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6521 var snapshot bytes.Buffer 6522 io.Copy(&snapshot, ringBuffer) 6523 err = &smithy.DeserializationError{ 6524 Err: fmt.Errorf("failed to decode response body, %w", err), 6525 Snapshot: snapshot.Bytes(), 6526 } 6527 return out, metadata, err 6528 } 6529 6530 err = awsAwsjson11_deserializeOpDocumentListLaunchPathsOutput(&output, shape) 6531 if err != nil { 6532 var snapshot bytes.Buffer 6533 io.Copy(&snapshot, ringBuffer) 6534 err = &smithy.DeserializationError{ 6535 Err: fmt.Errorf("failed to decode response body, %w", err), 6536 Snapshot: snapshot.Bytes(), 6537 } 6538 return out, metadata, err 6539 } 6540 6541 return out, metadata, err 6542} 6543 6544func awsAwsjson11_deserializeOpErrorListLaunchPaths(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6545 var errorBuffer bytes.Buffer 6546 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6547 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6548 } 6549 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6550 6551 errorCode := "UnknownError" 6552 errorMessage := errorCode 6553 6554 code := response.Header.Get("X-Amzn-ErrorType") 6555 if len(code) != 0 { 6556 errorCode = restjson.SanitizeErrorCode(code) 6557 } 6558 6559 var buff [1024]byte 6560 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6561 6562 body := io.TeeReader(errorBody, ringBuffer) 6563 decoder := json.NewDecoder(body) 6564 decoder.UseNumber() 6565 code, message, err := restjson.GetErrorInfo(decoder) 6566 if err != nil { 6567 var snapshot bytes.Buffer 6568 io.Copy(&snapshot, ringBuffer) 6569 err = &smithy.DeserializationError{ 6570 Err: fmt.Errorf("failed to decode response body, %w", err), 6571 Snapshot: snapshot.Bytes(), 6572 } 6573 return err 6574 } 6575 6576 errorBody.Seek(0, io.SeekStart) 6577 if len(code) != 0 { 6578 errorCode = restjson.SanitizeErrorCode(code) 6579 } 6580 if len(message) != 0 { 6581 errorMessage = message 6582 } 6583 6584 switch { 6585 case strings.EqualFold("InvalidParametersException", errorCode): 6586 return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody) 6587 6588 case strings.EqualFold("ResourceNotFoundException", errorCode): 6589 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 6590 6591 default: 6592 genericError := &smithy.GenericAPIError{ 6593 Code: errorCode, 6594 Message: errorMessage, 6595 } 6596 return genericError 6597 6598 } 6599} 6600 6601type awsAwsjson11_deserializeOpListOrganizationPortfolioAccess struct { 6602} 6603 6604func (*awsAwsjson11_deserializeOpListOrganizationPortfolioAccess) ID() string { 6605 return "OperationDeserializer" 6606} 6607 6608func (m *awsAwsjson11_deserializeOpListOrganizationPortfolioAccess) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6609 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6610) { 6611 out, metadata, err = next.HandleDeserialize(ctx, in) 6612 if err != nil { 6613 return out, metadata, err 6614 } 6615 6616 response, ok := out.RawResponse.(*smithyhttp.Response) 6617 if !ok { 6618 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6619 } 6620 6621 if response.StatusCode < 200 || response.StatusCode >= 300 { 6622 return out, metadata, awsAwsjson11_deserializeOpErrorListOrganizationPortfolioAccess(response, &metadata) 6623 } 6624 output := &ListOrganizationPortfolioAccessOutput{} 6625 out.Result = output 6626 6627 var buff [1024]byte 6628 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6629 6630 body := io.TeeReader(response.Body, ringBuffer) 6631 decoder := json.NewDecoder(body) 6632 decoder.UseNumber() 6633 var shape interface{} 6634 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6635 var snapshot bytes.Buffer 6636 io.Copy(&snapshot, ringBuffer) 6637 err = &smithy.DeserializationError{ 6638 Err: fmt.Errorf("failed to decode response body, %w", err), 6639 Snapshot: snapshot.Bytes(), 6640 } 6641 return out, metadata, err 6642 } 6643 6644 err = awsAwsjson11_deserializeOpDocumentListOrganizationPortfolioAccessOutput(&output, shape) 6645 if err != nil { 6646 var snapshot bytes.Buffer 6647 io.Copy(&snapshot, ringBuffer) 6648 err = &smithy.DeserializationError{ 6649 Err: fmt.Errorf("failed to decode response body, %w", err), 6650 Snapshot: snapshot.Bytes(), 6651 } 6652 return out, metadata, err 6653 } 6654 6655 return out, metadata, err 6656} 6657 6658func awsAwsjson11_deserializeOpErrorListOrganizationPortfolioAccess(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6659 var errorBuffer bytes.Buffer 6660 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6661 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6662 } 6663 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6664 6665 errorCode := "UnknownError" 6666 errorMessage := errorCode 6667 6668 code := response.Header.Get("X-Amzn-ErrorType") 6669 if len(code) != 0 { 6670 errorCode = restjson.SanitizeErrorCode(code) 6671 } 6672 6673 var buff [1024]byte 6674 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6675 6676 body := io.TeeReader(errorBody, ringBuffer) 6677 decoder := json.NewDecoder(body) 6678 decoder.UseNumber() 6679 code, message, err := restjson.GetErrorInfo(decoder) 6680 if err != nil { 6681 var snapshot bytes.Buffer 6682 io.Copy(&snapshot, ringBuffer) 6683 err = &smithy.DeserializationError{ 6684 Err: fmt.Errorf("failed to decode response body, %w", err), 6685 Snapshot: snapshot.Bytes(), 6686 } 6687 return err 6688 } 6689 6690 errorBody.Seek(0, io.SeekStart) 6691 if len(code) != 0 { 6692 errorCode = restjson.SanitizeErrorCode(code) 6693 } 6694 if len(message) != 0 { 6695 errorMessage = message 6696 } 6697 6698 switch { 6699 case strings.EqualFold("InvalidParametersException", errorCode): 6700 return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody) 6701 6702 case strings.EqualFold("OperationNotSupportedException", errorCode): 6703 return awsAwsjson11_deserializeErrorOperationNotSupportedException(response, errorBody) 6704 6705 case strings.EqualFold("ResourceNotFoundException", errorCode): 6706 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 6707 6708 default: 6709 genericError := &smithy.GenericAPIError{ 6710 Code: errorCode, 6711 Message: errorMessage, 6712 } 6713 return genericError 6714 6715 } 6716} 6717 6718type awsAwsjson11_deserializeOpListPortfolioAccess struct { 6719} 6720 6721func (*awsAwsjson11_deserializeOpListPortfolioAccess) ID() string { 6722 return "OperationDeserializer" 6723} 6724 6725func (m *awsAwsjson11_deserializeOpListPortfolioAccess) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6726 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6727) { 6728 out, metadata, err = next.HandleDeserialize(ctx, in) 6729 if err != nil { 6730 return out, metadata, err 6731 } 6732 6733 response, ok := out.RawResponse.(*smithyhttp.Response) 6734 if !ok { 6735 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6736 } 6737 6738 if response.StatusCode < 200 || response.StatusCode >= 300 { 6739 return out, metadata, awsAwsjson11_deserializeOpErrorListPortfolioAccess(response, &metadata) 6740 } 6741 output := &ListPortfolioAccessOutput{} 6742 out.Result = output 6743 6744 var buff [1024]byte 6745 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6746 6747 body := io.TeeReader(response.Body, ringBuffer) 6748 decoder := json.NewDecoder(body) 6749 decoder.UseNumber() 6750 var shape interface{} 6751 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 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 out, metadata, err 6759 } 6760 6761 err = awsAwsjson11_deserializeOpDocumentListPortfolioAccessOutput(&output, shape) 6762 if err != nil { 6763 var snapshot bytes.Buffer 6764 io.Copy(&snapshot, ringBuffer) 6765 err = &smithy.DeserializationError{ 6766 Err: fmt.Errorf("failed to decode response body, %w", err), 6767 Snapshot: snapshot.Bytes(), 6768 } 6769 return out, metadata, err 6770 } 6771 6772 return out, metadata, err 6773} 6774 6775func awsAwsjson11_deserializeOpErrorListPortfolioAccess(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6776 var errorBuffer bytes.Buffer 6777 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6778 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6779 } 6780 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6781 6782 errorCode := "UnknownError" 6783 errorMessage := errorCode 6784 6785 code := response.Header.Get("X-Amzn-ErrorType") 6786 if len(code) != 0 { 6787 errorCode = restjson.SanitizeErrorCode(code) 6788 } 6789 6790 var buff [1024]byte 6791 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6792 6793 body := io.TeeReader(errorBody, ringBuffer) 6794 decoder := json.NewDecoder(body) 6795 decoder.UseNumber() 6796 code, message, err := restjson.GetErrorInfo(decoder) 6797 if err != nil { 6798 var snapshot bytes.Buffer 6799 io.Copy(&snapshot, ringBuffer) 6800 err = &smithy.DeserializationError{ 6801 Err: fmt.Errorf("failed to decode response body, %w", err), 6802 Snapshot: snapshot.Bytes(), 6803 } 6804 return err 6805 } 6806 6807 errorBody.Seek(0, io.SeekStart) 6808 if len(code) != 0 { 6809 errorCode = restjson.SanitizeErrorCode(code) 6810 } 6811 if len(message) != 0 { 6812 errorMessage = message 6813 } 6814 6815 switch { 6816 case strings.EqualFold("InvalidParametersException", errorCode): 6817 return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody) 6818 6819 case strings.EqualFold("ResourceNotFoundException", errorCode): 6820 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 6821 6822 default: 6823 genericError := &smithy.GenericAPIError{ 6824 Code: errorCode, 6825 Message: errorMessage, 6826 } 6827 return genericError 6828 6829 } 6830} 6831 6832type awsAwsjson11_deserializeOpListPortfolios struct { 6833} 6834 6835func (*awsAwsjson11_deserializeOpListPortfolios) ID() string { 6836 return "OperationDeserializer" 6837} 6838 6839func (m *awsAwsjson11_deserializeOpListPortfolios) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6840 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6841) { 6842 out, metadata, err = next.HandleDeserialize(ctx, in) 6843 if err != nil { 6844 return out, metadata, err 6845 } 6846 6847 response, ok := out.RawResponse.(*smithyhttp.Response) 6848 if !ok { 6849 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6850 } 6851 6852 if response.StatusCode < 200 || response.StatusCode >= 300 { 6853 return out, metadata, awsAwsjson11_deserializeOpErrorListPortfolios(response, &metadata) 6854 } 6855 output := &ListPortfoliosOutput{} 6856 out.Result = output 6857 6858 var buff [1024]byte 6859 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6860 6861 body := io.TeeReader(response.Body, ringBuffer) 6862 decoder := json.NewDecoder(body) 6863 decoder.UseNumber() 6864 var shape interface{} 6865 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6866 var snapshot bytes.Buffer 6867 io.Copy(&snapshot, ringBuffer) 6868 err = &smithy.DeserializationError{ 6869 Err: fmt.Errorf("failed to decode response body, %w", err), 6870 Snapshot: snapshot.Bytes(), 6871 } 6872 return out, metadata, err 6873 } 6874 6875 err = awsAwsjson11_deserializeOpDocumentListPortfoliosOutput(&output, shape) 6876 if err != nil { 6877 var snapshot bytes.Buffer 6878 io.Copy(&snapshot, ringBuffer) 6879 err = &smithy.DeserializationError{ 6880 Err: fmt.Errorf("failed to decode response body, %w", err), 6881 Snapshot: snapshot.Bytes(), 6882 } 6883 return out, metadata, err 6884 } 6885 6886 return out, metadata, err 6887} 6888 6889func awsAwsjson11_deserializeOpErrorListPortfolios(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6890 var errorBuffer bytes.Buffer 6891 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6892 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6893 } 6894 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6895 6896 errorCode := "UnknownError" 6897 errorMessage := errorCode 6898 6899 code := response.Header.Get("X-Amzn-ErrorType") 6900 if len(code) != 0 { 6901 errorCode = restjson.SanitizeErrorCode(code) 6902 } 6903 6904 var buff [1024]byte 6905 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6906 6907 body := io.TeeReader(errorBody, ringBuffer) 6908 decoder := json.NewDecoder(body) 6909 decoder.UseNumber() 6910 code, message, err := restjson.GetErrorInfo(decoder) 6911 if err != nil { 6912 var snapshot bytes.Buffer 6913 io.Copy(&snapshot, ringBuffer) 6914 err = &smithy.DeserializationError{ 6915 Err: fmt.Errorf("failed to decode response body, %w", err), 6916 Snapshot: snapshot.Bytes(), 6917 } 6918 return err 6919 } 6920 6921 errorBody.Seek(0, io.SeekStart) 6922 if len(code) != 0 { 6923 errorCode = restjson.SanitizeErrorCode(code) 6924 } 6925 if len(message) != 0 { 6926 errorMessage = message 6927 } 6928 6929 switch { 6930 case strings.EqualFold("InvalidParametersException", errorCode): 6931 return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody) 6932 6933 default: 6934 genericError := &smithy.GenericAPIError{ 6935 Code: errorCode, 6936 Message: errorMessage, 6937 } 6938 return genericError 6939 6940 } 6941} 6942 6943type awsAwsjson11_deserializeOpListPortfoliosForProduct struct { 6944} 6945 6946func (*awsAwsjson11_deserializeOpListPortfoliosForProduct) ID() string { 6947 return "OperationDeserializer" 6948} 6949 6950func (m *awsAwsjson11_deserializeOpListPortfoliosForProduct) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6951 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6952) { 6953 out, metadata, err = next.HandleDeserialize(ctx, in) 6954 if err != nil { 6955 return out, metadata, err 6956 } 6957 6958 response, ok := out.RawResponse.(*smithyhttp.Response) 6959 if !ok { 6960 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6961 } 6962 6963 if response.StatusCode < 200 || response.StatusCode >= 300 { 6964 return out, metadata, awsAwsjson11_deserializeOpErrorListPortfoliosForProduct(response, &metadata) 6965 } 6966 output := &ListPortfoliosForProductOutput{} 6967 out.Result = output 6968 6969 var buff [1024]byte 6970 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6971 6972 body := io.TeeReader(response.Body, ringBuffer) 6973 decoder := json.NewDecoder(body) 6974 decoder.UseNumber() 6975 var shape interface{} 6976 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6977 var snapshot bytes.Buffer 6978 io.Copy(&snapshot, ringBuffer) 6979 err = &smithy.DeserializationError{ 6980 Err: fmt.Errorf("failed to decode response body, %w", err), 6981 Snapshot: snapshot.Bytes(), 6982 } 6983 return out, metadata, err 6984 } 6985 6986 err = awsAwsjson11_deserializeOpDocumentListPortfoliosForProductOutput(&output, shape) 6987 if err != nil { 6988 var snapshot bytes.Buffer 6989 io.Copy(&snapshot, ringBuffer) 6990 err = &smithy.DeserializationError{ 6991 Err: fmt.Errorf("failed to decode response body, %w", err), 6992 Snapshot: snapshot.Bytes(), 6993 } 6994 return out, metadata, err 6995 } 6996 6997 return out, metadata, err 6998} 6999 7000func awsAwsjson11_deserializeOpErrorListPortfoliosForProduct(response *smithyhttp.Response, metadata *middleware.Metadata) error { 7001 var errorBuffer bytes.Buffer 7002 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 7003 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 7004 } 7005 errorBody := bytes.NewReader(errorBuffer.Bytes()) 7006 7007 errorCode := "UnknownError" 7008 errorMessage := errorCode 7009 7010 code := response.Header.Get("X-Amzn-ErrorType") 7011 if len(code) != 0 { 7012 errorCode = restjson.SanitizeErrorCode(code) 7013 } 7014 7015 var buff [1024]byte 7016 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7017 7018 body := io.TeeReader(errorBody, ringBuffer) 7019 decoder := json.NewDecoder(body) 7020 decoder.UseNumber() 7021 code, message, err := restjson.GetErrorInfo(decoder) 7022 if err != nil { 7023 var snapshot bytes.Buffer 7024 io.Copy(&snapshot, ringBuffer) 7025 err = &smithy.DeserializationError{ 7026 Err: fmt.Errorf("failed to decode response body, %w", err), 7027 Snapshot: snapshot.Bytes(), 7028 } 7029 return err 7030 } 7031 7032 errorBody.Seek(0, io.SeekStart) 7033 if len(code) != 0 { 7034 errorCode = restjson.SanitizeErrorCode(code) 7035 } 7036 if len(message) != 0 { 7037 errorMessage = message 7038 } 7039 7040 switch { 7041 case strings.EqualFold("InvalidParametersException", errorCode): 7042 return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody) 7043 7044 case strings.EqualFold("ResourceNotFoundException", errorCode): 7045 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 7046 7047 default: 7048 genericError := &smithy.GenericAPIError{ 7049 Code: errorCode, 7050 Message: errorMessage, 7051 } 7052 return genericError 7053 7054 } 7055} 7056 7057type awsAwsjson11_deserializeOpListPrincipalsForPortfolio struct { 7058} 7059 7060func (*awsAwsjson11_deserializeOpListPrincipalsForPortfolio) ID() string { 7061 return "OperationDeserializer" 7062} 7063 7064func (m *awsAwsjson11_deserializeOpListPrincipalsForPortfolio) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 7065 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 7066) { 7067 out, metadata, err = next.HandleDeserialize(ctx, in) 7068 if err != nil { 7069 return out, metadata, err 7070 } 7071 7072 response, ok := out.RawResponse.(*smithyhttp.Response) 7073 if !ok { 7074 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 7075 } 7076 7077 if response.StatusCode < 200 || response.StatusCode >= 300 { 7078 return out, metadata, awsAwsjson11_deserializeOpErrorListPrincipalsForPortfolio(response, &metadata) 7079 } 7080 output := &ListPrincipalsForPortfolioOutput{} 7081 out.Result = output 7082 7083 var buff [1024]byte 7084 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7085 7086 body := io.TeeReader(response.Body, ringBuffer) 7087 decoder := json.NewDecoder(body) 7088 decoder.UseNumber() 7089 var shape interface{} 7090 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7091 var snapshot bytes.Buffer 7092 io.Copy(&snapshot, ringBuffer) 7093 err = &smithy.DeserializationError{ 7094 Err: fmt.Errorf("failed to decode response body, %w", err), 7095 Snapshot: snapshot.Bytes(), 7096 } 7097 return out, metadata, err 7098 } 7099 7100 err = awsAwsjson11_deserializeOpDocumentListPrincipalsForPortfolioOutput(&output, shape) 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 out, metadata, err 7109 } 7110 7111 return out, metadata, err 7112} 7113 7114func awsAwsjson11_deserializeOpErrorListPrincipalsForPortfolio(response *smithyhttp.Response, metadata *middleware.Metadata) error { 7115 var errorBuffer bytes.Buffer 7116 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 7117 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 7118 } 7119 errorBody := bytes.NewReader(errorBuffer.Bytes()) 7120 7121 errorCode := "UnknownError" 7122 errorMessage := errorCode 7123 7124 code := response.Header.Get("X-Amzn-ErrorType") 7125 if len(code) != 0 { 7126 errorCode = restjson.SanitizeErrorCode(code) 7127 } 7128 7129 var buff [1024]byte 7130 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7131 7132 body := io.TeeReader(errorBody, ringBuffer) 7133 decoder := json.NewDecoder(body) 7134 decoder.UseNumber() 7135 code, message, err := restjson.GetErrorInfo(decoder) 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 if len(code) != 0 { 7148 errorCode = restjson.SanitizeErrorCode(code) 7149 } 7150 if len(message) != 0 { 7151 errorMessage = message 7152 } 7153 7154 switch { 7155 case strings.EqualFold("InvalidParametersException", errorCode): 7156 return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody) 7157 7158 case strings.EqualFold("ResourceNotFoundException", errorCode): 7159 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 7160 7161 default: 7162 genericError := &smithy.GenericAPIError{ 7163 Code: errorCode, 7164 Message: errorMessage, 7165 } 7166 return genericError 7167 7168 } 7169} 7170 7171type awsAwsjson11_deserializeOpListProvisionedProductPlans struct { 7172} 7173 7174func (*awsAwsjson11_deserializeOpListProvisionedProductPlans) ID() string { 7175 return "OperationDeserializer" 7176} 7177 7178func (m *awsAwsjson11_deserializeOpListProvisionedProductPlans) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 7179 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 7180) { 7181 out, metadata, err = next.HandleDeserialize(ctx, in) 7182 if err != nil { 7183 return out, metadata, err 7184 } 7185 7186 response, ok := out.RawResponse.(*smithyhttp.Response) 7187 if !ok { 7188 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 7189 } 7190 7191 if response.StatusCode < 200 || response.StatusCode >= 300 { 7192 return out, metadata, awsAwsjson11_deserializeOpErrorListProvisionedProductPlans(response, &metadata) 7193 } 7194 output := &ListProvisionedProductPlansOutput{} 7195 out.Result = output 7196 7197 var buff [1024]byte 7198 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7199 7200 body := io.TeeReader(response.Body, ringBuffer) 7201 decoder := json.NewDecoder(body) 7202 decoder.UseNumber() 7203 var shape interface{} 7204 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7205 var snapshot bytes.Buffer 7206 io.Copy(&snapshot, ringBuffer) 7207 err = &smithy.DeserializationError{ 7208 Err: fmt.Errorf("failed to decode response body, %w", err), 7209 Snapshot: snapshot.Bytes(), 7210 } 7211 return out, metadata, err 7212 } 7213 7214 err = awsAwsjson11_deserializeOpDocumentListProvisionedProductPlansOutput(&output, shape) 7215 if err != nil { 7216 var snapshot bytes.Buffer 7217 io.Copy(&snapshot, ringBuffer) 7218 err = &smithy.DeserializationError{ 7219 Err: fmt.Errorf("failed to decode response body, %w", err), 7220 Snapshot: snapshot.Bytes(), 7221 } 7222 return out, metadata, err 7223 } 7224 7225 return out, metadata, err 7226} 7227 7228func awsAwsjson11_deserializeOpErrorListProvisionedProductPlans(response *smithyhttp.Response, metadata *middleware.Metadata) error { 7229 var errorBuffer bytes.Buffer 7230 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 7231 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 7232 } 7233 errorBody := bytes.NewReader(errorBuffer.Bytes()) 7234 7235 errorCode := "UnknownError" 7236 errorMessage := errorCode 7237 7238 code := response.Header.Get("X-Amzn-ErrorType") 7239 if len(code) != 0 { 7240 errorCode = restjson.SanitizeErrorCode(code) 7241 } 7242 7243 var buff [1024]byte 7244 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7245 7246 body := io.TeeReader(errorBody, ringBuffer) 7247 decoder := json.NewDecoder(body) 7248 decoder.UseNumber() 7249 code, message, err := restjson.GetErrorInfo(decoder) 7250 if err != nil { 7251 var snapshot bytes.Buffer 7252 io.Copy(&snapshot, ringBuffer) 7253 err = &smithy.DeserializationError{ 7254 Err: fmt.Errorf("failed to decode response body, %w", err), 7255 Snapshot: snapshot.Bytes(), 7256 } 7257 return err 7258 } 7259 7260 errorBody.Seek(0, io.SeekStart) 7261 if len(code) != 0 { 7262 errorCode = restjson.SanitizeErrorCode(code) 7263 } 7264 if len(message) != 0 { 7265 errorMessage = message 7266 } 7267 7268 switch { 7269 case strings.EqualFold("InvalidParametersException", errorCode): 7270 return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody) 7271 7272 case strings.EqualFold("ResourceNotFoundException", errorCode): 7273 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 7274 7275 default: 7276 genericError := &smithy.GenericAPIError{ 7277 Code: errorCode, 7278 Message: errorMessage, 7279 } 7280 return genericError 7281 7282 } 7283} 7284 7285type awsAwsjson11_deserializeOpListProvisioningArtifacts struct { 7286} 7287 7288func (*awsAwsjson11_deserializeOpListProvisioningArtifacts) ID() string { 7289 return "OperationDeserializer" 7290} 7291 7292func (m *awsAwsjson11_deserializeOpListProvisioningArtifacts) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 7293 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 7294) { 7295 out, metadata, err = next.HandleDeserialize(ctx, in) 7296 if err != nil { 7297 return out, metadata, err 7298 } 7299 7300 response, ok := out.RawResponse.(*smithyhttp.Response) 7301 if !ok { 7302 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 7303 } 7304 7305 if response.StatusCode < 200 || response.StatusCode >= 300 { 7306 return out, metadata, awsAwsjson11_deserializeOpErrorListProvisioningArtifacts(response, &metadata) 7307 } 7308 output := &ListProvisioningArtifactsOutput{} 7309 out.Result = output 7310 7311 var buff [1024]byte 7312 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7313 7314 body := io.TeeReader(response.Body, ringBuffer) 7315 decoder := json.NewDecoder(body) 7316 decoder.UseNumber() 7317 var shape interface{} 7318 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7319 var snapshot bytes.Buffer 7320 io.Copy(&snapshot, ringBuffer) 7321 err = &smithy.DeserializationError{ 7322 Err: fmt.Errorf("failed to decode response body, %w", err), 7323 Snapshot: snapshot.Bytes(), 7324 } 7325 return out, metadata, err 7326 } 7327 7328 err = awsAwsjson11_deserializeOpDocumentListProvisioningArtifactsOutput(&output, shape) 7329 if err != nil { 7330 var snapshot bytes.Buffer 7331 io.Copy(&snapshot, ringBuffer) 7332 err = &smithy.DeserializationError{ 7333 Err: fmt.Errorf("failed to decode response body, %w", err), 7334 Snapshot: snapshot.Bytes(), 7335 } 7336 return out, metadata, err 7337 } 7338 7339 return out, metadata, err 7340} 7341 7342func awsAwsjson11_deserializeOpErrorListProvisioningArtifacts(response *smithyhttp.Response, metadata *middleware.Metadata) error { 7343 var errorBuffer bytes.Buffer 7344 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 7345 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 7346 } 7347 errorBody := bytes.NewReader(errorBuffer.Bytes()) 7348 7349 errorCode := "UnknownError" 7350 errorMessage := errorCode 7351 7352 code := response.Header.Get("X-Amzn-ErrorType") 7353 if len(code) != 0 { 7354 errorCode = restjson.SanitizeErrorCode(code) 7355 } 7356 7357 var buff [1024]byte 7358 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7359 7360 body := io.TeeReader(errorBody, ringBuffer) 7361 decoder := json.NewDecoder(body) 7362 decoder.UseNumber() 7363 code, message, err := restjson.GetErrorInfo(decoder) 7364 if err != nil { 7365 var snapshot bytes.Buffer 7366 io.Copy(&snapshot, ringBuffer) 7367 err = &smithy.DeserializationError{ 7368 Err: fmt.Errorf("failed to decode response body, %w", err), 7369 Snapshot: snapshot.Bytes(), 7370 } 7371 return err 7372 } 7373 7374 errorBody.Seek(0, io.SeekStart) 7375 if len(code) != 0 { 7376 errorCode = restjson.SanitizeErrorCode(code) 7377 } 7378 if len(message) != 0 { 7379 errorMessage = message 7380 } 7381 7382 switch { 7383 case strings.EqualFold("InvalidParametersException", errorCode): 7384 return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody) 7385 7386 case strings.EqualFold("ResourceNotFoundException", errorCode): 7387 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 7388 7389 default: 7390 genericError := &smithy.GenericAPIError{ 7391 Code: errorCode, 7392 Message: errorMessage, 7393 } 7394 return genericError 7395 7396 } 7397} 7398 7399type awsAwsjson11_deserializeOpListProvisioningArtifactsForServiceAction struct { 7400} 7401 7402func (*awsAwsjson11_deserializeOpListProvisioningArtifactsForServiceAction) ID() string { 7403 return "OperationDeserializer" 7404} 7405 7406func (m *awsAwsjson11_deserializeOpListProvisioningArtifactsForServiceAction) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 7407 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 7408) { 7409 out, metadata, err = next.HandleDeserialize(ctx, in) 7410 if err != nil { 7411 return out, metadata, err 7412 } 7413 7414 response, ok := out.RawResponse.(*smithyhttp.Response) 7415 if !ok { 7416 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 7417 } 7418 7419 if response.StatusCode < 200 || response.StatusCode >= 300 { 7420 return out, metadata, awsAwsjson11_deserializeOpErrorListProvisioningArtifactsForServiceAction(response, &metadata) 7421 } 7422 output := &ListProvisioningArtifactsForServiceActionOutput{} 7423 out.Result = output 7424 7425 var buff [1024]byte 7426 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7427 7428 body := io.TeeReader(response.Body, ringBuffer) 7429 decoder := json.NewDecoder(body) 7430 decoder.UseNumber() 7431 var shape interface{} 7432 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7433 var snapshot bytes.Buffer 7434 io.Copy(&snapshot, ringBuffer) 7435 err = &smithy.DeserializationError{ 7436 Err: fmt.Errorf("failed to decode response body, %w", err), 7437 Snapshot: snapshot.Bytes(), 7438 } 7439 return out, metadata, err 7440 } 7441 7442 err = awsAwsjson11_deserializeOpDocumentListProvisioningArtifactsForServiceActionOutput(&output, shape) 7443 if err != nil { 7444 var snapshot bytes.Buffer 7445 io.Copy(&snapshot, ringBuffer) 7446 err = &smithy.DeserializationError{ 7447 Err: fmt.Errorf("failed to decode response body, %w", err), 7448 Snapshot: snapshot.Bytes(), 7449 } 7450 return out, metadata, err 7451 } 7452 7453 return out, metadata, err 7454} 7455 7456func awsAwsjson11_deserializeOpErrorListProvisioningArtifactsForServiceAction(response *smithyhttp.Response, metadata *middleware.Metadata) error { 7457 var errorBuffer bytes.Buffer 7458 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 7459 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 7460 } 7461 errorBody := bytes.NewReader(errorBuffer.Bytes()) 7462 7463 errorCode := "UnknownError" 7464 errorMessage := errorCode 7465 7466 code := response.Header.Get("X-Amzn-ErrorType") 7467 if len(code) != 0 { 7468 errorCode = restjson.SanitizeErrorCode(code) 7469 } 7470 7471 var buff [1024]byte 7472 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7473 7474 body := io.TeeReader(errorBody, ringBuffer) 7475 decoder := json.NewDecoder(body) 7476 decoder.UseNumber() 7477 code, message, err := restjson.GetErrorInfo(decoder) 7478 if err != nil { 7479 var snapshot bytes.Buffer 7480 io.Copy(&snapshot, ringBuffer) 7481 err = &smithy.DeserializationError{ 7482 Err: fmt.Errorf("failed to decode response body, %w", err), 7483 Snapshot: snapshot.Bytes(), 7484 } 7485 return err 7486 } 7487 7488 errorBody.Seek(0, io.SeekStart) 7489 if len(code) != 0 { 7490 errorCode = restjson.SanitizeErrorCode(code) 7491 } 7492 if len(message) != 0 { 7493 errorMessage = message 7494 } 7495 7496 switch { 7497 case strings.EqualFold("InvalidParametersException", errorCode): 7498 return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody) 7499 7500 case strings.EqualFold("ResourceNotFoundException", errorCode): 7501 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 7502 7503 default: 7504 genericError := &smithy.GenericAPIError{ 7505 Code: errorCode, 7506 Message: errorMessage, 7507 } 7508 return genericError 7509 7510 } 7511} 7512 7513type awsAwsjson11_deserializeOpListRecordHistory struct { 7514} 7515 7516func (*awsAwsjson11_deserializeOpListRecordHistory) ID() string { 7517 return "OperationDeserializer" 7518} 7519 7520func (m *awsAwsjson11_deserializeOpListRecordHistory) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 7521 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 7522) { 7523 out, metadata, err = next.HandleDeserialize(ctx, in) 7524 if err != nil { 7525 return out, metadata, err 7526 } 7527 7528 response, ok := out.RawResponse.(*smithyhttp.Response) 7529 if !ok { 7530 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 7531 } 7532 7533 if response.StatusCode < 200 || response.StatusCode >= 300 { 7534 return out, metadata, awsAwsjson11_deserializeOpErrorListRecordHistory(response, &metadata) 7535 } 7536 output := &ListRecordHistoryOutput{} 7537 out.Result = output 7538 7539 var buff [1024]byte 7540 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7541 7542 body := io.TeeReader(response.Body, ringBuffer) 7543 decoder := json.NewDecoder(body) 7544 decoder.UseNumber() 7545 var shape interface{} 7546 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7547 var snapshot bytes.Buffer 7548 io.Copy(&snapshot, ringBuffer) 7549 err = &smithy.DeserializationError{ 7550 Err: fmt.Errorf("failed to decode response body, %w", err), 7551 Snapshot: snapshot.Bytes(), 7552 } 7553 return out, metadata, err 7554 } 7555 7556 err = awsAwsjson11_deserializeOpDocumentListRecordHistoryOutput(&output, shape) 7557 if err != nil { 7558 var snapshot bytes.Buffer 7559 io.Copy(&snapshot, ringBuffer) 7560 err = &smithy.DeserializationError{ 7561 Err: fmt.Errorf("failed to decode response body, %w", err), 7562 Snapshot: snapshot.Bytes(), 7563 } 7564 return out, metadata, err 7565 } 7566 7567 return out, metadata, err 7568} 7569 7570func awsAwsjson11_deserializeOpErrorListRecordHistory(response *smithyhttp.Response, metadata *middleware.Metadata) error { 7571 var errorBuffer bytes.Buffer 7572 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 7573 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 7574 } 7575 errorBody := bytes.NewReader(errorBuffer.Bytes()) 7576 7577 errorCode := "UnknownError" 7578 errorMessage := errorCode 7579 7580 code := response.Header.Get("X-Amzn-ErrorType") 7581 if len(code) != 0 { 7582 errorCode = restjson.SanitizeErrorCode(code) 7583 } 7584 7585 var buff [1024]byte 7586 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7587 7588 body := io.TeeReader(errorBody, ringBuffer) 7589 decoder := json.NewDecoder(body) 7590 decoder.UseNumber() 7591 code, message, err := restjson.GetErrorInfo(decoder) 7592 if err != nil { 7593 var snapshot bytes.Buffer 7594 io.Copy(&snapshot, ringBuffer) 7595 err = &smithy.DeserializationError{ 7596 Err: fmt.Errorf("failed to decode response body, %w", err), 7597 Snapshot: snapshot.Bytes(), 7598 } 7599 return err 7600 } 7601 7602 errorBody.Seek(0, io.SeekStart) 7603 if len(code) != 0 { 7604 errorCode = restjson.SanitizeErrorCode(code) 7605 } 7606 if len(message) != 0 { 7607 errorMessage = message 7608 } 7609 7610 switch { 7611 case strings.EqualFold("InvalidParametersException", errorCode): 7612 return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody) 7613 7614 default: 7615 genericError := &smithy.GenericAPIError{ 7616 Code: errorCode, 7617 Message: errorMessage, 7618 } 7619 return genericError 7620 7621 } 7622} 7623 7624type awsAwsjson11_deserializeOpListResourcesForTagOption struct { 7625} 7626 7627func (*awsAwsjson11_deserializeOpListResourcesForTagOption) ID() string { 7628 return "OperationDeserializer" 7629} 7630 7631func (m *awsAwsjson11_deserializeOpListResourcesForTagOption) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 7632 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 7633) { 7634 out, metadata, err = next.HandleDeserialize(ctx, in) 7635 if err != nil { 7636 return out, metadata, err 7637 } 7638 7639 response, ok := out.RawResponse.(*smithyhttp.Response) 7640 if !ok { 7641 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 7642 } 7643 7644 if response.StatusCode < 200 || response.StatusCode >= 300 { 7645 return out, metadata, awsAwsjson11_deserializeOpErrorListResourcesForTagOption(response, &metadata) 7646 } 7647 output := &ListResourcesForTagOptionOutput{} 7648 out.Result = output 7649 7650 var buff [1024]byte 7651 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7652 7653 body := io.TeeReader(response.Body, ringBuffer) 7654 decoder := json.NewDecoder(body) 7655 decoder.UseNumber() 7656 var shape interface{} 7657 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7658 var snapshot bytes.Buffer 7659 io.Copy(&snapshot, ringBuffer) 7660 err = &smithy.DeserializationError{ 7661 Err: fmt.Errorf("failed to decode response body, %w", err), 7662 Snapshot: snapshot.Bytes(), 7663 } 7664 return out, metadata, err 7665 } 7666 7667 err = awsAwsjson11_deserializeOpDocumentListResourcesForTagOptionOutput(&output, shape) 7668 if err != nil { 7669 var snapshot bytes.Buffer 7670 io.Copy(&snapshot, ringBuffer) 7671 err = &smithy.DeserializationError{ 7672 Err: fmt.Errorf("failed to decode response body, %w", err), 7673 Snapshot: snapshot.Bytes(), 7674 } 7675 return out, metadata, err 7676 } 7677 7678 return out, metadata, err 7679} 7680 7681func awsAwsjson11_deserializeOpErrorListResourcesForTagOption(response *smithyhttp.Response, metadata *middleware.Metadata) error { 7682 var errorBuffer bytes.Buffer 7683 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 7684 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 7685 } 7686 errorBody := bytes.NewReader(errorBuffer.Bytes()) 7687 7688 errorCode := "UnknownError" 7689 errorMessage := errorCode 7690 7691 code := response.Header.Get("X-Amzn-ErrorType") 7692 if len(code) != 0 { 7693 errorCode = restjson.SanitizeErrorCode(code) 7694 } 7695 7696 var buff [1024]byte 7697 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7698 7699 body := io.TeeReader(errorBody, ringBuffer) 7700 decoder := json.NewDecoder(body) 7701 decoder.UseNumber() 7702 code, message, err := restjson.GetErrorInfo(decoder) 7703 if err != nil { 7704 var snapshot bytes.Buffer 7705 io.Copy(&snapshot, ringBuffer) 7706 err = &smithy.DeserializationError{ 7707 Err: fmt.Errorf("failed to decode response body, %w", err), 7708 Snapshot: snapshot.Bytes(), 7709 } 7710 return err 7711 } 7712 7713 errorBody.Seek(0, io.SeekStart) 7714 if len(code) != 0 { 7715 errorCode = restjson.SanitizeErrorCode(code) 7716 } 7717 if len(message) != 0 { 7718 errorMessage = message 7719 } 7720 7721 switch { 7722 case strings.EqualFold("InvalidParametersException", errorCode): 7723 return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody) 7724 7725 case strings.EqualFold("ResourceNotFoundException", errorCode): 7726 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 7727 7728 case strings.EqualFold("TagOptionNotMigratedException", errorCode): 7729 return awsAwsjson11_deserializeErrorTagOptionNotMigratedException(response, errorBody) 7730 7731 default: 7732 genericError := &smithy.GenericAPIError{ 7733 Code: errorCode, 7734 Message: errorMessage, 7735 } 7736 return genericError 7737 7738 } 7739} 7740 7741type awsAwsjson11_deserializeOpListServiceActions struct { 7742} 7743 7744func (*awsAwsjson11_deserializeOpListServiceActions) ID() string { 7745 return "OperationDeserializer" 7746} 7747 7748func (m *awsAwsjson11_deserializeOpListServiceActions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 7749 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 7750) { 7751 out, metadata, err = next.HandleDeserialize(ctx, in) 7752 if err != nil { 7753 return out, metadata, err 7754 } 7755 7756 response, ok := out.RawResponse.(*smithyhttp.Response) 7757 if !ok { 7758 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 7759 } 7760 7761 if response.StatusCode < 200 || response.StatusCode >= 300 { 7762 return out, metadata, awsAwsjson11_deserializeOpErrorListServiceActions(response, &metadata) 7763 } 7764 output := &ListServiceActionsOutput{} 7765 out.Result = output 7766 7767 var buff [1024]byte 7768 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7769 7770 body := io.TeeReader(response.Body, ringBuffer) 7771 decoder := json.NewDecoder(body) 7772 decoder.UseNumber() 7773 var shape interface{} 7774 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7775 var snapshot bytes.Buffer 7776 io.Copy(&snapshot, ringBuffer) 7777 err = &smithy.DeserializationError{ 7778 Err: fmt.Errorf("failed to decode response body, %w", err), 7779 Snapshot: snapshot.Bytes(), 7780 } 7781 return out, metadata, err 7782 } 7783 7784 err = awsAwsjson11_deserializeOpDocumentListServiceActionsOutput(&output, shape) 7785 if err != nil { 7786 var snapshot bytes.Buffer 7787 io.Copy(&snapshot, ringBuffer) 7788 err = &smithy.DeserializationError{ 7789 Err: fmt.Errorf("failed to decode response body, %w", err), 7790 Snapshot: snapshot.Bytes(), 7791 } 7792 return out, metadata, err 7793 } 7794 7795 return out, metadata, err 7796} 7797 7798func awsAwsjson11_deserializeOpErrorListServiceActions(response *smithyhttp.Response, metadata *middleware.Metadata) error { 7799 var errorBuffer bytes.Buffer 7800 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 7801 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 7802 } 7803 errorBody := bytes.NewReader(errorBuffer.Bytes()) 7804 7805 errorCode := "UnknownError" 7806 errorMessage := errorCode 7807 7808 code := response.Header.Get("X-Amzn-ErrorType") 7809 if len(code) != 0 { 7810 errorCode = restjson.SanitizeErrorCode(code) 7811 } 7812 7813 var buff [1024]byte 7814 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7815 7816 body := io.TeeReader(errorBody, ringBuffer) 7817 decoder := json.NewDecoder(body) 7818 decoder.UseNumber() 7819 code, message, err := restjson.GetErrorInfo(decoder) 7820 if err != nil { 7821 var snapshot bytes.Buffer 7822 io.Copy(&snapshot, ringBuffer) 7823 err = &smithy.DeserializationError{ 7824 Err: fmt.Errorf("failed to decode response body, %w", err), 7825 Snapshot: snapshot.Bytes(), 7826 } 7827 return err 7828 } 7829 7830 errorBody.Seek(0, io.SeekStart) 7831 if len(code) != 0 { 7832 errorCode = restjson.SanitizeErrorCode(code) 7833 } 7834 if len(message) != 0 { 7835 errorMessage = message 7836 } 7837 7838 switch { 7839 case strings.EqualFold("InvalidParametersException", errorCode): 7840 return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody) 7841 7842 default: 7843 genericError := &smithy.GenericAPIError{ 7844 Code: errorCode, 7845 Message: errorMessage, 7846 } 7847 return genericError 7848 7849 } 7850} 7851 7852type awsAwsjson11_deserializeOpListServiceActionsForProvisioningArtifact struct { 7853} 7854 7855func (*awsAwsjson11_deserializeOpListServiceActionsForProvisioningArtifact) ID() string { 7856 return "OperationDeserializer" 7857} 7858 7859func (m *awsAwsjson11_deserializeOpListServiceActionsForProvisioningArtifact) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 7860 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 7861) { 7862 out, metadata, err = next.HandleDeserialize(ctx, in) 7863 if err != nil { 7864 return out, metadata, err 7865 } 7866 7867 response, ok := out.RawResponse.(*smithyhttp.Response) 7868 if !ok { 7869 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 7870 } 7871 7872 if response.StatusCode < 200 || response.StatusCode >= 300 { 7873 return out, metadata, awsAwsjson11_deserializeOpErrorListServiceActionsForProvisioningArtifact(response, &metadata) 7874 } 7875 output := &ListServiceActionsForProvisioningArtifactOutput{} 7876 out.Result = output 7877 7878 var buff [1024]byte 7879 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7880 7881 body := io.TeeReader(response.Body, ringBuffer) 7882 decoder := json.NewDecoder(body) 7883 decoder.UseNumber() 7884 var shape interface{} 7885 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7886 var snapshot bytes.Buffer 7887 io.Copy(&snapshot, ringBuffer) 7888 err = &smithy.DeserializationError{ 7889 Err: fmt.Errorf("failed to decode response body, %w", err), 7890 Snapshot: snapshot.Bytes(), 7891 } 7892 return out, metadata, err 7893 } 7894 7895 err = awsAwsjson11_deserializeOpDocumentListServiceActionsForProvisioningArtifactOutput(&output, shape) 7896 if err != nil { 7897 var snapshot bytes.Buffer 7898 io.Copy(&snapshot, ringBuffer) 7899 err = &smithy.DeserializationError{ 7900 Err: fmt.Errorf("failed to decode response body, %w", err), 7901 Snapshot: snapshot.Bytes(), 7902 } 7903 return out, metadata, err 7904 } 7905 7906 return out, metadata, err 7907} 7908 7909func awsAwsjson11_deserializeOpErrorListServiceActionsForProvisioningArtifact(response *smithyhttp.Response, metadata *middleware.Metadata) error { 7910 var errorBuffer bytes.Buffer 7911 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 7912 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 7913 } 7914 errorBody := bytes.NewReader(errorBuffer.Bytes()) 7915 7916 errorCode := "UnknownError" 7917 errorMessage := errorCode 7918 7919 code := response.Header.Get("X-Amzn-ErrorType") 7920 if len(code) != 0 { 7921 errorCode = restjson.SanitizeErrorCode(code) 7922 } 7923 7924 var buff [1024]byte 7925 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7926 7927 body := io.TeeReader(errorBody, ringBuffer) 7928 decoder := json.NewDecoder(body) 7929 decoder.UseNumber() 7930 code, message, err := restjson.GetErrorInfo(decoder) 7931 if err != nil { 7932 var snapshot bytes.Buffer 7933 io.Copy(&snapshot, ringBuffer) 7934 err = &smithy.DeserializationError{ 7935 Err: fmt.Errorf("failed to decode response body, %w", err), 7936 Snapshot: snapshot.Bytes(), 7937 } 7938 return err 7939 } 7940 7941 errorBody.Seek(0, io.SeekStart) 7942 if len(code) != 0 { 7943 errorCode = restjson.SanitizeErrorCode(code) 7944 } 7945 if len(message) != 0 { 7946 errorMessage = message 7947 } 7948 7949 switch { 7950 case strings.EqualFold("InvalidParametersException", errorCode): 7951 return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody) 7952 7953 case strings.EqualFold("ResourceNotFoundException", errorCode): 7954 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 7955 7956 default: 7957 genericError := &smithy.GenericAPIError{ 7958 Code: errorCode, 7959 Message: errorMessage, 7960 } 7961 return genericError 7962 7963 } 7964} 7965 7966type awsAwsjson11_deserializeOpListStackInstancesForProvisionedProduct struct { 7967} 7968 7969func (*awsAwsjson11_deserializeOpListStackInstancesForProvisionedProduct) ID() string { 7970 return "OperationDeserializer" 7971} 7972 7973func (m *awsAwsjson11_deserializeOpListStackInstancesForProvisionedProduct) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 7974 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 7975) { 7976 out, metadata, err = next.HandleDeserialize(ctx, in) 7977 if err != nil { 7978 return out, metadata, err 7979 } 7980 7981 response, ok := out.RawResponse.(*smithyhttp.Response) 7982 if !ok { 7983 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 7984 } 7985 7986 if response.StatusCode < 200 || response.StatusCode >= 300 { 7987 return out, metadata, awsAwsjson11_deserializeOpErrorListStackInstancesForProvisionedProduct(response, &metadata) 7988 } 7989 output := &ListStackInstancesForProvisionedProductOutput{} 7990 out.Result = output 7991 7992 var buff [1024]byte 7993 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7994 7995 body := io.TeeReader(response.Body, ringBuffer) 7996 decoder := json.NewDecoder(body) 7997 decoder.UseNumber() 7998 var shape interface{} 7999 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 8000 var snapshot bytes.Buffer 8001 io.Copy(&snapshot, ringBuffer) 8002 err = &smithy.DeserializationError{ 8003 Err: fmt.Errorf("failed to decode response body, %w", err), 8004 Snapshot: snapshot.Bytes(), 8005 } 8006 return out, metadata, err 8007 } 8008 8009 err = awsAwsjson11_deserializeOpDocumentListStackInstancesForProvisionedProductOutput(&output, shape) 8010 if err != nil { 8011 var snapshot bytes.Buffer 8012 io.Copy(&snapshot, ringBuffer) 8013 err = &smithy.DeserializationError{ 8014 Err: fmt.Errorf("failed to decode response body, %w", err), 8015 Snapshot: snapshot.Bytes(), 8016 } 8017 return out, metadata, err 8018 } 8019 8020 return out, metadata, err 8021} 8022 8023func awsAwsjson11_deserializeOpErrorListStackInstancesForProvisionedProduct(response *smithyhttp.Response, metadata *middleware.Metadata) error { 8024 var errorBuffer bytes.Buffer 8025 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 8026 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 8027 } 8028 errorBody := bytes.NewReader(errorBuffer.Bytes()) 8029 8030 errorCode := "UnknownError" 8031 errorMessage := errorCode 8032 8033 code := response.Header.Get("X-Amzn-ErrorType") 8034 if len(code) != 0 { 8035 errorCode = restjson.SanitizeErrorCode(code) 8036 } 8037 8038 var buff [1024]byte 8039 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8040 8041 body := io.TeeReader(errorBody, ringBuffer) 8042 decoder := json.NewDecoder(body) 8043 decoder.UseNumber() 8044 code, message, err := restjson.GetErrorInfo(decoder) 8045 if err != nil { 8046 var snapshot bytes.Buffer 8047 io.Copy(&snapshot, ringBuffer) 8048 err = &smithy.DeserializationError{ 8049 Err: fmt.Errorf("failed to decode response body, %w", err), 8050 Snapshot: snapshot.Bytes(), 8051 } 8052 return err 8053 } 8054 8055 errorBody.Seek(0, io.SeekStart) 8056 if len(code) != 0 { 8057 errorCode = restjson.SanitizeErrorCode(code) 8058 } 8059 if len(message) != 0 { 8060 errorMessage = message 8061 } 8062 8063 switch { 8064 case strings.EqualFold("InvalidParametersException", errorCode): 8065 return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody) 8066 8067 case strings.EqualFold("ResourceNotFoundException", errorCode): 8068 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 8069 8070 default: 8071 genericError := &smithy.GenericAPIError{ 8072 Code: errorCode, 8073 Message: errorMessage, 8074 } 8075 return genericError 8076 8077 } 8078} 8079 8080type awsAwsjson11_deserializeOpListTagOptions struct { 8081} 8082 8083func (*awsAwsjson11_deserializeOpListTagOptions) ID() string { 8084 return "OperationDeserializer" 8085} 8086 8087func (m *awsAwsjson11_deserializeOpListTagOptions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 8088 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 8089) { 8090 out, metadata, err = next.HandleDeserialize(ctx, in) 8091 if err != nil { 8092 return out, metadata, err 8093 } 8094 8095 response, ok := out.RawResponse.(*smithyhttp.Response) 8096 if !ok { 8097 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 8098 } 8099 8100 if response.StatusCode < 200 || response.StatusCode >= 300 { 8101 return out, metadata, awsAwsjson11_deserializeOpErrorListTagOptions(response, &metadata) 8102 } 8103 output := &ListTagOptionsOutput{} 8104 out.Result = output 8105 8106 var buff [1024]byte 8107 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8108 8109 body := io.TeeReader(response.Body, ringBuffer) 8110 decoder := json.NewDecoder(body) 8111 decoder.UseNumber() 8112 var shape interface{} 8113 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 8114 var snapshot bytes.Buffer 8115 io.Copy(&snapshot, ringBuffer) 8116 err = &smithy.DeserializationError{ 8117 Err: fmt.Errorf("failed to decode response body, %w", err), 8118 Snapshot: snapshot.Bytes(), 8119 } 8120 return out, metadata, err 8121 } 8122 8123 err = awsAwsjson11_deserializeOpDocumentListTagOptionsOutput(&output, shape) 8124 if err != nil { 8125 var snapshot bytes.Buffer 8126 io.Copy(&snapshot, ringBuffer) 8127 err = &smithy.DeserializationError{ 8128 Err: fmt.Errorf("failed to decode response body, %w", err), 8129 Snapshot: snapshot.Bytes(), 8130 } 8131 return out, metadata, err 8132 } 8133 8134 return out, metadata, err 8135} 8136 8137func awsAwsjson11_deserializeOpErrorListTagOptions(response *smithyhttp.Response, metadata *middleware.Metadata) error { 8138 var errorBuffer bytes.Buffer 8139 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 8140 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 8141 } 8142 errorBody := bytes.NewReader(errorBuffer.Bytes()) 8143 8144 errorCode := "UnknownError" 8145 errorMessage := errorCode 8146 8147 code := response.Header.Get("X-Amzn-ErrorType") 8148 if len(code) != 0 { 8149 errorCode = restjson.SanitizeErrorCode(code) 8150 } 8151 8152 var buff [1024]byte 8153 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8154 8155 body := io.TeeReader(errorBody, ringBuffer) 8156 decoder := json.NewDecoder(body) 8157 decoder.UseNumber() 8158 code, message, err := restjson.GetErrorInfo(decoder) 8159 if err != nil { 8160 var snapshot bytes.Buffer 8161 io.Copy(&snapshot, ringBuffer) 8162 err = &smithy.DeserializationError{ 8163 Err: fmt.Errorf("failed to decode response body, %w", err), 8164 Snapshot: snapshot.Bytes(), 8165 } 8166 return err 8167 } 8168 8169 errorBody.Seek(0, io.SeekStart) 8170 if len(code) != 0 { 8171 errorCode = restjson.SanitizeErrorCode(code) 8172 } 8173 if len(message) != 0 { 8174 errorMessage = message 8175 } 8176 8177 switch { 8178 case strings.EqualFold("InvalidParametersException", errorCode): 8179 return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody) 8180 8181 case strings.EqualFold("TagOptionNotMigratedException", errorCode): 8182 return awsAwsjson11_deserializeErrorTagOptionNotMigratedException(response, errorBody) 8183 8184 default: 8185 genericError := &smithy.GenericAPIError{ 8186 Code: errorCode, 8187 Message: errorMessage, 8188 } 8189 return genericError 8190 8191 } 8192} 8193 8194type awsAwsjson11_deserializeOpProvisionProduct struct { 8195} 8196 8197func (*awsAwsjson11_deserializeOpProvisionProduct) ID() string { 8198 return "OperationDeserializer" 8199} 8200 8201func (m *awsAwsjson11_deserializeOpProvisionProduct) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 8202 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 8203) { 8204 out, metadata, err = next.HandleDeserialize(ctx, in) 8205 if err != nil { 8206 return out, metadata, err 8207 } 8208 8209 response, ok := out.RawResponse.(*smithyhttp.Response) 8210 if !ok { 8211 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 8212 } 8213 8214 if response.StatusCode < 200 || response.StatusCode >= 300 { 8215 return out, metadata, awsAwsjson11_deserializeOpErrorProvisionProduct(response, &metadata) 8216 } 8217 output := &ProvisionProductOutput{} 8218 out.Result = output 8219 8220 var buff [1024]byte 8221 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8222 8223 body := io.TeeReader(response.Body, ringBuffer) 8224 decoder := json.NewDecoder(body) 8225 decoder.UseNumber() 8226 var shape interface{} 8227 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 8228 var snapshot bytes.Buffer 8229 io.Copy(&snapshot, ringBuffer) 8230 err = &smithy.DeserializationError{ 8231 Err: fmt.Errorf("failed to decode response body, %w", err), 8232 Snapshot: snapshot.Bytes(), 8233 } 8234 return out, metadata, err 8235 } 8236 8237 err = awsAwsjson11_deserializeOpDocumentProvisionProductOutput(&output, shape) 8238 if err != nil { 8239 var snapshot bytes.Buffer 8240 io.Copy(&snapshot, ringBuffer) 8241 err = &smithy.DeserializationError{ 8242 Err: fmt.Errorf("failed to decode response body, %w", err), 8243 Snapshot: snapshot.Bytes(), 8244 } 8245 return out, metadata, err 8246 } 8247 8248 return out, metadata, err 8249} 8250 8251func awsAwsjson11_deserializeOpErrorProvisionProduct(response *smithyhttp.Response, metadata *middleware.Metadata) error { 8252 var errorBuffer bytes.Buffer 8253 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 8254 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 8255 } 8256 errorBody := bytes.NewReader(errorBuffer.Bytes()) 8257 8258 errorCode := "UnknownError" 8259 errorMessage := errorCode 8260 8261 code := response.Header.Get("X-Amzn-ErrorType") 8262 if len(code) != 0 { 8263 errorCode = restjson.SanitizeErrorCode(code) 8264 } 8265 8266 var buff [1024]byte 8267 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8268 8269 body := io.TeeReader(errorBody, ringBuffer) 8270 decoder := json.NewDecoder(body) 8271 decoder.UseNumber() 8272 code, message, err := restjson.GetErrorInfo(decoder) 8273 if err != nil { 8274 var snapshot bytes.Buffer 8275 io.Copy(&snapshot, ringBuffer) 8276 err = &smithy.DeserializationError{ 8277 Err: fmt.Errorf("failed to decode response body, %w", err), 8278 Snapshot: snapshot.Bytes(), 8279 } 8280 return err 8281 } 8282 8283 errorBody.Seek(0, io.SeekStart) 8284 if len(code) != 0 { 8285 errorCode = restjson.SanitizeErrorCode(code) 8286 } 8287 if len(message) != 0 { 8288 errorMessage = message 8289 } 8290 8291 switch { 8292 case strings.EqualFold("DuplicateResourceException", errorCode): 8293 return awsAwsjson11_deserializeErrorDuplicateResourceException(response, errorBody) 8294 8295 case strings.EqualFold("InvalidParametersException", errorCode): 8296 return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody) 8297 8298 case strings.EqualFold("ResourceNotFoundException", errorCode): 8299 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 8300 8301 default: 8302 genericError := &smithy.GenericAPIError{ 8303 Code: errorCode, 8304 Message: errorMessage, 8305 } 8306 return genericError 8307 8308 } 8309} 8310 8311type awsAwsjson11_deserializeOpRejectPortfolioShare struct { 8312} 8313 8314func (*awsAwsjson11_deserializeOpRejectPortfolioShare) ID() string { 8315 return "OperationDeserializer" 8316} 8317 8318func (m *awsAwsjson11_deserializeOpRejectPortfolioShare) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 8319 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 8320) { 8321 out, metadata, err = next.HandleDeserialize(ctx, in) 8322 if err != nil { 8323 return out, metadata, err 8324 } 8325 8326 response, ok := out.RawResponse.(*smithyhttp.Response) 8327 if !ok { 8328 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 8329 } 8330 8331 if response.StatusCode < 200 || response.StatusCode >= 300 { 8332 return out, metadata, awsAwsjson11_deserializeOpErrorRejectPortfolioShare(response, &metadata) 8333 } 8334 output := &RejectPortfolioShareOutput{} 8335 out.Result = output 8336 8337 var buff [1024]byte 8338 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8339 8340 body := io.TeeReader(response.Body, ringBuffer) 8341 decoder := json.NewDecoder(body) 8342 decoder.UseNumber() 8343 var shape interface{} 8344 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 8345 var snapshot bytes.Buffer 8346 io.Copy(&snapshot, ringBuffer) 8347 err = &smithy.DeserializationError{ 8348 Err: fmt.Errorf("failed to decode response body, %w", err), 8349 Snapshot: snapshot.Bytes(), 8350 } 8351 return out, metadata, err 8352 } 8353 8354 err = awsAwsjson11_deserializeOpDocumentRejectPortfolioShareOutput(&output, shape) 8355 if err != nil { 8356 var snapshot bytes.Buffer 8357 io.Copy(&snapshot, ringBuffer) 8358 err = &smithy.DeserializationError{ 8359 Err: fmt.Errorf("failed to decode response body, %w", err), 8360 Snapshot: snapshot.Bytes(), 8361 } 8362 return out, metadata, err 8363 } 8364 8365 return out, metadata, err 8366} 8367 8368func awsAwsjson11_deserializeOpErrorRejectPortfolioShare(response *smithyhttp.Response, metadata *middleware.Metadata) error { 8369 var errorBuffer bytes.Buffer 8370 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 8371 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 8372 } 8373 errorBody := bytes.NewReader(errorBuffer.Bytes()) 8374 8375 errorCode := "UnknownError" 8376 errorMessage := errorCode 8377 8378 code := response.Header.Get("X-Amzn-ErrorType") 8379 if len(code) != 0 { 8380 errorCode = restjson.SanitizeErrorCode(code) 8381 } 8382 8383 var buff [1024]byte 8384 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8385 8386 body := io.TeeReader(errorBody, ringBuffer) 8387 decoder := json.NewDecoder(body) 8388 decoder.UseNumber() 8389 code, message, err := restjson.GetErrorInfo(decoder) 8390 if err != nil { 8391 var snapshot bytes.Buffer 8392 io.Copy(&snapshot, ringBuffer) 8393 err = &smithy.DeserializationError{ 8394 Err: fmt.Errorf("failed to decode response body, %w", err), 8395 Snapshot: snapshot.Bytes(), 8396 } 8397 return err 8398 } 8399 8400 errorBody.Seek(0, io.SeekStart) 8401 if len(code) != 0 { 8402 errorCode = restjson.SanitizeErrorCode(code) 8403 } 8404 if len(message) != 0 { 8405 errorMessage = message 8406 } 8407 8408 switch { 8409 case strings.EqualFold("ResourceNotFoundException", errorCode): 8410 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 8411 8412 default: 8413 genericError := &smithy.GenericAPIError{ 8414 Code: errorCode, 8415 Message: errorMessage, 8416 } 8417 return genericError 8418 8419 } 8420} 8421 8422type awsAwsjson11_deserializeOpScanProvisionedProducts struct { 8423} 8424 8425func (*awsAwsjson11_deserializeOpScanProvisionedProducts) ID() string { 8426 return "OperationDeserializer" 8427} 8428 8429func (m *awsAwsjson11_deserializeOpScanProvisionedProducts) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 8430 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 8431) { 8432 out, metadata, err = next.HandleDeserialize(ctx, in) 8433 if err != nil { 8434 return out, metadata, err 8435 } 8436 8437 response, ok := out.RawResponse.(*smithyhttp.Response) 8438 if !ok { 8439 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 8440 } 8441 8442 if response.StatusCode < 200 || response.StatusCode >= 300 { 8443 return out, metadata, awsAwsjson11_deserializeOpErrorScanProvisionedProducts(response, &metadata) 8444 } 8445 output := &ScanProvisionedProductsOutput{} 8446 out.Result = output 8447 8448 var buff [1024]byte 8449 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8450 8451 body := io.TeeReader(response.Body, ringBuffer) 8452 decoder := json.NewDecoder(body) 8453 decoder.UseNumber() 8454 var shape interface{} 8455 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 8456 var snapshot bytes.Buffer 8457 io.Copy(&snapshot, ringBuffer) 8458 err = &smithy.DeserializationError{ 8459 Err: fmt.Errorf("failed to decode response body, %w", err), 8460 Snapshot: snapshot.Bytes(), 8461 } 8462 return out, metadata, err 8463 } 8464 8465 err = awsAwsjson11_deserializeOpDocumentScanProvisionedProductsOutput(&output, shape) 8466 if err != nil { 8467 var snapshot bytes.Buffer 8468 io.Copy(&snapshot, ringBuffer) 8469 err = &smithy.DeserializationError{ 8470 Err: fmt.Errorf("failed to decode response body, %w", err), 8471 Snapshot: snapshot.Bytes(), 8472 } 8473 return out, metadata, err 8474 } 8475 8476 return out, metadata, err 8477} 8478 8479func awsAwsjson11_deserializeOpErrorScanProvisionedProducts(response *smithyhttp.Response, metadata *middleware.Metadata) error { 8480 var errorBuffer bytes.Buffer 8481 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 8482 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 8483 } 8484 errorBody := bytes.NewReader(errorBuffer.Bytes()) 8485 8486 errorCode := "UnknownError" 8487 errorMessage := errorCode 8488 8489 code := response.Header.Get("X-Amzn-ErrorType") 8490 if len(code) != 0 { 8491 errorCode = restjson.SanitizeErrorCode(code) 8492 } 8493 8494 var buff [1024]byte 8495 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8496 8497 body := io.TeeReader(errorBody, ringBuffer) 8498 decoder := json.NewDecoder(body) 8499 decoder.UseNumber() 8500 code, message, err := restjson.GetErrorInfo(decoder) 8501 if err != nil { 8502 var snapshot bytes.Buffer 8503 io.Copy(&snapshot, ringBuffer) 8504 err = &smithy.DeserializationError{ 8505 Err: fmt.Errorf("failed to decode response body, %w", err), 8506 Snapshot: snapshot.Bytes(), 8507 } 8508 return err 8509 } 8510 8511 errorBody.Seek(0, io.SeekStart) 8512 if len(code) != 0 { 8513 errorCode = restjson.SanitizeErrorCode(code) 8514 } 8515 if len(message) != 0 { 8516 errorMessage = message 8517 } 8518 8519 switch { 8520 case strings.EqualFold("InvalidParametersException", errorCode): 8521 return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody) 8522 8523 default: 8524 genericError := &smithy.GenericAPIError{ 8525 Code: errorCode, 8526 Message: errorMessage, 8527 } 8528 return genericError 8529 8530 } 8531} 8532 8533type awsAwsjson11_deserializeOpSearchProducts struct { 8534} 8535 8536func (*awsAwsjson11_deserializeOpSearchProducts) ID() string { 8537 return "OperationDeserializer" 8538} 8539 8540func (m *awsAwsjson11_deserializeOpSearchProducts) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 8541 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 8542) { 8543 out, metadata, err = next.HandleDeserialize(ctx, in) 8544 if err != nil { 8545 return out, metadata, err 8546 } 8547 8548 response, ok := out.RawResponse.(*smithyhttp.Response) 8549 if !ok { 8550 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 8551 } 8552 8553 if response.StatusCode < 200 || response.StatusCode >= 300 { 8554 return out, metadata, awsAwsjson11_deserializeOpErrorSearchProducts(response, &metadata) 8555 } 8556 output := &SearchProductsOutput{} 8557 out.Result = output 8558 8559 var buff [1024]byte 8560 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8561 8562 body := io.TeeReader(response.Body, ringBuffer) 8563 decoder := json.NewDecoder(body) 8564 decoder.UseNumber() 8565 var shape interface{} 8566 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 8567 var snapshot bytes.Buffer 8568 io.Copy(&snapshot, ringBuffer) 8569 err = &smithy.DeserializationError{ 8570 Err: fmt.Errorf("failed to decode response body, %w", err), 8571 Snapshot: snapshot.Bytes(), 8572 } 8573 return out, metadata, err 8574 } 8575 8576 err = awsAwsjson11_deserializeOpDocumentSearchProductsOutput(&output, shape) 8577 if err != nil { 8578 var snapshot bytes.Buffer 8579 io.Copy(&snapshot, ringBuffer) 8580 err = &smithy.DeserializationError{ 8581 Err: fmt.Errorf("failed to decode response body, %w", err), 8582 Snapshot: snapshot.Bytes(), 8583 } 8584 return out, metadata, err 8585 } 8586 8587 return out, metadata, err 8588} 8589 8590func awsAwsjson11_deserializeOpErrorSearchProducts(response *smithyhttp.Response, metadata *middleware.Metadata) error { 8591 var errorBuffer bytes.Buffer 8592 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 8593 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 8594 } 8595 errorBody := bytes.NewReader(errorBuffer.Bytes()) 8596 8597 errorCode := "UnknownError" 8598 errorMessage := errorCode 8599 8600 code := response.Header.Get("X-Amzn-ErrorType") 8601 if len(code) != 0 { 8602 errorCode = restjson.SanitizeErrorCode(code) 8603 } 8604 8605 var buff [1024]byte 8606 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8607 8608 body := io.TeeReader(errorBody, ringBuffer) 8609 decoder := json.NewDecoder(body) 8610 decoder.UseNumber() 8611 code, message, err := restjson.GetErrorInfo(decoder) 8612 if err != nil { 8613 var snapshot bytes.Buffer 8614 io.Copy(&snapshot, ringBuffer) 8615 err = &smithy.DeserializationError{ 8616 Err: fmt.Errorf("failed to decode response body, %w", err), 8617 Snapshot: snapshot.Bytes(), 8618 } 8619 return err 8620 } 8621 8622 errorBody.Seek(0, io.SeekStart) 8623 if len(code) != 0 { 8624 errorCode = restjson.SanitizeErrorCode(code) 8625 } 8626 if len(message) != 0 { 8627 errorMessage = message 8628 } 8629 8630 switch { 8631 case strings.EqualFold("InvalidParametersException", errorCode): 8632 return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody) 8633 8634 default: 8635 genericError := &smithy.GenericAPIError{ 8636 Code: errorCode, 8637 Message: errorMessage, 8638 } 8639 return genericError 8640 8641 } 8642} 8643 8644type awsAwsjson11_deserializeOpSearchProductsAsAdmin struct { 8645} 8646 8647func (*awsAwsjson11_deserializeOpSearchProductsAsAdmin) ID() string { 8648 return "OperationDeserializer" 8649} 8650 8651func (m *awsAwsjson11_deserializeOpSearchProductsAsAdmin) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 8652 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 8653) { 8654 out, metadata, err = next.HandleDeserialize(ctx, in) 8655 if err != nil { 8656 return out, metadata, err 8657 } 8658 8659 response, ok := out.RawResponse.(*smithyhttp.Response) 8660 if !ok { 8661 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 8662 } 8663 8664 if response.StatusCode < 200 || response.StatusCode >= 300 { 8665 return out, metadata, awsAwsjson11_deserializeOpErrorSearchProductsAsAdmin(response, &metadata) 8666 } 8667 output := &SearchProductsAsAdminOutput{} 8668 out.Result = output 8669 8670 var buff [1024]byte 8671 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8672 8673 body := io.TeeReader(response.Body, ringBuffer) 8674 decoder := json.NewDecoder(body) 8675 decoder.UseNumber() 8676 var shape interface{} 8677 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 8678 var snapshot bytes.Buffer 8679 io.Copy(&snapshot, ringBuffer) 8680 err = &smithy.DeserializationError{ 8681 Err: fmt.Errorf("failed to decode response body, %w", err), 8682 Snapshot: snapshot.Bytes(), 8683 } 8684 return out, metadata, err 8685 } 8686 8687 err = awsAwsjson11_deserializeOpDocumentSearchProductsAsAdminOutput(&output, shape) 8688 if err != nil { 8689 var snapshot bytes.Buffer 8690 io.Copy(&snapshot, ringBuffer) 8691 err = &smithy.DeserializationError{ 8692 Err: fmt.Errorf("failed to decode response body, %w", err), 8693 Snapshot: snapshot.Bytes(), 8694 } 8695 return out, metadata, err 8696 } 8697 8698 return out, metadata, err 8699} 8700 8701func awsAwsjson11_deserializeOpErrorSearchProductsAsAdmin(response *smithyhttp.Response, metadata *middleware.Metadata) error { 8702 var errorBuffer bytes.Buffer 8703 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 8704 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 8705 } 8706 errorBody := bytes.NewReader(errorBuffer.Bytes()) 8707 8708 errorCode := "UnknownError" 8709 errorMessage := errorCode 8710 8711 code := response.Header.Get("X-Amzn-ErrorType") 8712 if len(code) != 0 { 8713 errorCode = restjson.SanitizeErrorCode(code) 8714 } 8715 8716 var buff [1024]byte 8717 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8718 8719 body := io.TeeReader(errorBody, ringBuffer) 8720 decoder := json.NewDecoder(body) 8721 decoder.UseNumber() 8722 code, message, err := restjson.GetErrorInfo(decoder) 8723 if err != nil { 8724 var snapshot bytes.Buffer 8725 io.Copy(&snapshot, ringBuffer) 8726 err = &smithy.DeserializationError{ 8727 Err: fmt.Errorf("failed to decode response body, %w", err), 8728 Snapshot: snapshot.Bytes(), 8729 } 8730 return err 8731 } 8732 8733 errorBody.Seek(0, io.SeekStart) 8734 if len(code) != 0 { 8735 errorCode = restjson.SanitizeErrorCode(code) 8736 } 8737 if len(message) != 0 { 8738 errorMessage = message 8739 } 8740 8741 switch { 8742 case strings.EqualFold("InvalidParametersException", errorCode): 8743 return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody) 8744 8745 case strings.EqualFold("ResourceNotFoundException", errorCode): 8746 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 8747 8748 default: 8749 genericError := &smithy.GenericAPIError{ 8750 Code: errorCode, 8751 Message: errorMessage, 8752 } 8753 return genericError 8754 8755 } 8756} 8757 8758type awsAwsjson11_deserializeOpSearchProvisionedProducts struct { 8759} 8760 8761func (*awsAwsjson11_deserializeOpSearchProvisionedProducts) ID() string { 8762 return "OperationDeserializer" 8763} 8764 8765func (m *awsAwsjson11_deserializeOpSearchProvisionedProducts) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 8766 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 8767) { 8768 out, metadata, err = next.HandleDeserialize(ctx, in) 8769 if err != nil { 8770 return out, metadata, err 8771 } 8772 8773 response, ok := out.RawResponse.(*smithyhttp.Response) 8774 if !ok { 8775 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 8776 } 8777 8778 if response.StatusCode < 200 || response.StatusCode >= 300 { 8779 return out, metadata, awsAwsjson11_deserializeOpErrorSearchProvisionedProducts(response, &metadata) 8780 } 8781 output := &SearchProvisionedProductsOutput{} 8782 out.Result = output 8783 8784 var buff [1024]byte 8785 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8786 8787 body := io.TeeReader(response.Body, ringBuffer) 8788 decoder := json.NewDecoder(body) 8789 decoder.UseNumber() 8790 var shape interface{} 8791 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 8792 var snapshot bytes.Buffer 8793 io.Copy(&snapshot, ringBuffer) 8794 err = &smithy.DeserializationError{ 8795 Err: fmt.Errorf("failed to decode response body, %w", err), 8796 Snapshot: snapshot.Bytes(), 8797 } 8798 return out, metadata, err 8799 } 8800 8801 err = awsAwsjson11_deserializeOpDocumentSearchProvisionedProductsOutput(&output, shape) 8802 if err != nil { 8803 var snapshot bytes.Buffer 8804 io.Copy(&snapshot, ringBuffer) 8805 err = &smithy.DeserializationError{ 8806 Err: fmt.Errorf("failed to decode response body, %w", err), 8807 Snapshot: snapshot.Bytes(), 8808 } 8809 return out, metadata, err 8810 } 8811 8812 return out, metadata, err 8813} 8814 8815func awsAwsjson11_deserializeOpErrorSearchProvisionedProducts(response *smithyhttp.Response, metadata *middleware.Metadata) error { 8816 var errorBuffer bytes.Buffer 8817 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 8818 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 8819 } 8820 errorBody := bytes.NewReader(errorBuffer.Bytes()) 8821 8822 errorCode := "UnknownError" 8823 errorMessage := errorCode 8824 8825 code := response.Header.Get("X-Amzn-ErrorType") 8826 if len(code) != 0 { 8827 errorCode = restjson.SanitizeErrorCode(code) 8828 } 8829 8830 var buff [1024]byte 8831 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8832 8833 body := io.TeeReader(errorBody, ringBuffer) 8834 decoder := json.NewDecoder(body) 8835 decoder.UseNumber() 8836 code, message, err := restjson.GetErrorInfo(decoder) 8837 if err != nil { 8838 var snapshot bytes.Buffer 8839 io.Copy(&snapshot, ringBuffer) 8840 err = &smithy.DeserializationError{ 8841 Err: fmt.Errorf("failed to decode response body, %w", err), 8842 Snapshot: snapshot.Bytes(), 8843 } 8844 return err 8845 } 8846 8847 errorBody.Seek(0, io.SeekStart) 8848 if len(code) != 0 { 8849 errorCode = restjson.SanitizeErrorCode(code) 8850 } 8851 if len(message) != 0 { 8852 errorMessage = message 8853 } 8854 8855 switch { 8856 case strings.EqualFold("InvalidParametersException", errorCode): 8857 return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody) 8858 8859 default: 8860 genericError := &smithy.GenericAPIError{ 8861 Code: errorCode, 8862 Message: errorMessage, 8863 } 8864 return genericError 8865 8866 } 8867} 8868 8869type awsAwsjson11_deserializeOpTerminateProvisionedProduct struct { 8870} 8871 8872func (*awsAwsjson11_deserializeOpTerminateProvisionedProduct) ID() string { 8873 return "OperationDeserializer" 8874} 8875 8876func (m *awsAwsjson11_deserializeOpTerminateProvisionedProduct) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 8877 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 8878) { 8879 out, metadata, err = next.HandleDeserialize(ctx, in) 8880 if err != nil { 8881 return out, metadata, err 8882 } 8883 8884 response, ok := out.RawResponse.(*smithyhttp.Response) 8885 if !ok { 8886 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 8887 } 8888 8889 if response.StatusCode < 200 || response.StatusCode >= 300 { 8890 return out, metadata, awsAwsjson11_deserializeOpErrorTerminateProvisionedProduct(response, &metadata) 8891 } 8892 output := &TerminateProvisionedProductOutput{} 8893 out.Result = output 8894 8895 var buff [1024]byte 8896 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8897 8898 body := io.TeeReader(response.Body, ringBuffer) 8899 decoder := json.NewDecoder(body) 8900 decoder.UseNumber() 8901 var shape interface{} 8902 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 8903 var snapshot bytes.Buffer 8904 io.Copy(&snapshot, ringBuffer) 8905 err = &smithy.DeserializationError{ 8906 Err: fmt.Errorf("failed to decode response body, %w", err), 8907 Snapshot: snapshot.Bytes(), 8908 } 8909 return out, metadata, err 8910 } 8911 8912 err = awsAwsjson11_deserializeOpDocumentTerminateProvisionedProductOutput(&output, shape) 8913 if err != nil { 8914 var snapshot bytes.Buffer 8915 io.Copy(&snapshot, ringBuffer) 8916 err = &smithy.DeserializationError{ 8917 Err: fmt.Errorf("failed to decode response body, %w", err), 8918 Snapshot: snapshot.Bytes(), 8919 } 8920 return out, metadata, err 8921 } 8922 8923 return out, metadata, err 8924} 8925 8926func awsAwsjson11_deserializeOpErrorTerminateProvisionedProduct(response *smithyhttp.Response, metadata *middleware.Metadata) error { 8927 var errorBuffer bytes.Buffer 8928 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 8929 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 8930 } 8931 errorBody := bytes.NewReader(errorBuffer.Bytes()) 8932 8933 errorCode := "UnknownError" 8934 errorMessage := errorCode 8935 8936 code := response.Header.Get("X-Amzn-ErrorType") 8937 if len(code) != 0 { 8938 errorCode = restjson.SanitizeErrorCode(code) 8939 } 8940 8941 var buff [1024]byte 8942 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8943 8944 body := io.TeeReader(errorBody, ringBuffer) 8945 decoder := json.NewDecoder(body) 8946 decoder.UseNumber() 8947 code, message, err := restjson.GetErrorInfo(decoder) 8948 if err != nil { 8949 var snapshot bytes.Buffer 8950 io.Copy(&snapshot, ringBuffer) 8951 err = &smithy.DeserializationError{ 8952 Err: fmt.Errorf("failed to decode response body, %w", err), 8953 Snapshot: snapshot.Bytes(), 8954 } 8955 return err 8956 } 8957 8958 errorBody.Seek(0, io.SeekStart) 8959 if len(code) != 0 { 8960 errorCode = restjson.SanitizeErrorCode(code) 8961 } 8962 if len(message) != 0 { 8963 errorMessage = message 8964 } 8965 8966 switch { 8967 case strings.EqualFold("ResourceNotFoundException", errorCode): 8968 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 8969 8970 default: 8971 genericError := &smithy.GenericAPIError{ 8972 Code: errorCode, 8973 Message: errorMessage, 8974 } 8975 return genericError 8976 8977 } 8978} 8979 8980type awsAwsjson11_deserializeOpUpdateConstraint struct { 8981} 8982 8983func (*awsAwsjson11_deserializeOpUpdateConstraint) ID() string { 8984 return "OperationDeserializer" 8985} 8986 8987func (m *awsAwsjson11_deserializeOpUpdateConstraint) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 8988 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 8989) { 8990 out, metadata, err = next.HandleDeserialize(ctx, in) 8991 if err != nil { 8992 return out, metadata, err 8993 } 8994 8995 response, ok := out.RawResponse.(*smithyhttp.Response) 8996 if !ok { 8997 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 8998 } 8999 9000 if response.StatusCode < 200 || response.StatusCode >= 300 { 9001 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateConstraint(response, &metadata) 9002 } 9003 output := &UpdateConstraintOutput{} 9004 out.Result = output 9005 9006 var buff [1024]byte 9007 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9008 9009 body := io.TeeReader(response.Body, ringBuffer) 9010 decoder := json.NewDecoder(body) 9011 decoder.UseNumber() 9012 var shape interface{} 9013 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 9014 var snapshot bytes.Buffer 9015 io.Copy(&snapshot, ringBuffer) 9016 err = &smithy.DeserializationError{ 9017 Err: fmt.Errorf("failed to decode response body, %w", err), 9018 Snapshot: snapshot.Bytes(), 9019 } 9020 return out, metadata, err 9021 } 9022 9023 err = awsAwsjson11_deserializeOpDocumentUpdateConstraintOutput(&output, shape) 9024 if err != nil { 9025 var snapshot bytes.Buffer 9026 io.Copy(&snapshot, ringBuffer) 9027 err = &smithy.DeserializationError{ 9028 Err: fmt.Errorf("failed to decode response body, %w", err), 9029 Snapshot: snapshot.Bytes(), 9030 } 9031 return out, metadata, err 9032 } 9033 9034 return out, metadata, err 9035} 9036 9037func awsAwsjson11_deserializeOpErrorUpdateConstraint(response *smithyhttp.Response, metadata *middleware.Metadata) error { 9038 var errorBuffer bytes.Buffer 9039 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 9040 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 9041 } 9042 errorBody := bytes.NewReader(errorBuffer.Bytes()) 9043 9044 errorCode := "UnknownError" 9045 errorMessage := errorCode 9046 9047 code := response.Header.Get("X-Amzn-ErrorType") 9048 if len(code) != 0 { 9049 errorCode = restjson.SanitizeErrorCode(code) 9050 } 9051 9052 var buff [1024]byte 9053 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9054 9055 body := io.TeeReader(errorBody, ringBuffer) 9056 decoder := json.NewDecoder(body) 9057 decoder.UseNumber() 9058 code, message, err := restjson.GetErrorInfo(decoder) 9059 if err != nil { 9060 var snapshot bytes.Buffer 9061 io.Copy(&snapshot, ringBuffer) 9062 err = &smithy.DeserializationError{ 9063 Err: fmt.Errorf("failed to decode response body, %w", err), 9064 Snapshot: snapshot.Bytes(), 9065 } 9066 return err 9067 } 9068 9069 errorBody.Seek(0, io.SeekStart) 9070 if len(code) != 0 { 9071 errorCode = restjson.SanitizeErrorCode(code) 9072 } 9073 if len(message) != 0 { 9074 errorMessage = message 9075 } 9076 9077 switch { 9078 case strings.EqualFold("InvalidParametersException", errorCode): 9079 return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody) 9080 9081 case strings.EqualFold("ResourceNotFoundException", errorCode): 9082 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 9083 9084 default: 9085 genericError := &smithy.GenericAPIError{ 9086 Code: errorCode, 9087 Message: errorMessage, 9088 } 9089 return genericError 9090 9091 } 9092} 9093 9094type awsAwsjson11_deserializeOpUpdatePortfolio struct { 9095} 9096 9097func (*awsAwsjson11_deserializeOpUpdatePortfolio) ID() string { 9098 return "OperationDeserializer" 9099} 9100 9101func (m *awsAwsjson11_deserializeOpUpdatePortfolio) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 9102 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 9103) { 9104 out, metadata, err = next.HandleDeserialize(ctx, in) 9105 if err != nil { 9106 return out, metadata, err 9107 } 9108 9109 response, ok := out.RawResponse.(*smithyhttp.Response) 9110 if !ok { 9111 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 9112 } 9113 9114 if response.StatusCode < 200 || response.StatusCode >= 300 { 9115 return out, metadata, awsAwsjson11_deserializeOpErrorUpdatePortfolio(response, &metadata) 9116 } 9117 output := &UpdatePortfolioOutput{} 9118 out.Result = output 9119 9120 var buff [1024]byte 9121 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9122 9123 body := io.TeeReader(response.Body, ringBuffer) 9124 decoder := json.NewDecoder(body) 9125 decoder.UseNumber() 9126 var shape interface{} 9127 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 9128 var snapshot bytes.Buffer 9129 io.Copy(&snapshot, ringBuffer) 9130 err = &smithy.DeserializationError{ 9131 Err: fmt.Errorf("failed to decode response body, %w", err), 9132 Snapshot: snapshot.Bytes(), 9133 } 9134 return out, metadata, err 9135 } 9136 9137 err = awsAwsjson11_deserializeOpDocumentUpdatePortfolioOutput(&output, shape) 9138 if err != nil { 9139 var snapshot bytes.Buffer 9140 io.Copy(&snapshot, ringBuffer) 9141 err = &smithy.DeserializationError{ 9142 Err: fmt.Errorf("failed to decode response body, %w", err), 9143 Snapshot: snapshot.Bytes(), 9144 } 9145 return out, metadata, err 9146 } 9147 9148 return out, metadata, err 9149} 9150 9151func awsAwsjson11_deserializeOpErrorUpdatePortfolio(response *smithyhttp.Response, metadata *middleware.Metadata) error { 9152 var errorBuffer bytes.Buffer 9153 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 9154 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 9155 } 9156 errorBody := bytes.NewReader(errorBuffer.Bytes()) 9157 9158 errorCode := "UnknownError" 9159 errorMessage := errorCode 9160 9161 code := response.Header.Get("X-Amzn-ErrorType") 9162 if len(code) != 0 { 9163 errorCode = restjson.SanitizeErrorCode(code) 9164 } 9165 9166 var buff [1024]byte 9167 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9168 9169 body := io.TeeReader(errorBody, ringBuffer) 9170 decoder := json.NewDecoder(body) 9171 decoder.UseNumber() 9172 code, message, err := restjson.GetErrorInfo(decoder) 9173 if err != nil { 9174 var snapshot bytes.Buffer 9175 io.Copy(&snapshot, ringBuffer) 9176 err = &smithy.DeserializationError{ 9177 Err: fmt.Errorf("failed to decode response body, %w", err), 9178 Snapshot: snapshot.Bytes(), 9179 } 9180 return err 9181 } 9182 9183 errorBody.Seek(0, io.SeekStart) 9184 if len(code) != 0 { 9185 errorCode = restjson.SanitizeErrorCode(code) 9186 } 9187 if len(message) != 0 { 9188 errorMessage = message 9189 } 9190 9191 switch { 9192 case strings.EqualFold("InvalidParametersException", errorCode): 9193 return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody) 9194 9195 case strings.EqualFold("LimitExceededException", errorCode): 9196 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 9197 9198 case strings.EqualFold("ResourceNotFoundException", errorCode): 9199 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 9200 9201 case strings.EqualFold("TagOptionNotMigratedException", errorCode): 9202 return awsAwsjson11_deserializeErrorTagOptionNotMigratedException(response, errorBody) 9203 9204 default: 9205 genericError := &smithy.GenericAPIError{ 9206 Code: errorCode, 9207 Message: errorMessage, 9208 } 9209 return genericError 9210 9211 } 9212} 9213 9214type awsAwsjson11_deserializeOpUpdatePortfolioShare struct { 9215} 9216 9217func (*awsAwsjson11_deserializeOpUpdatePortfolioShare) ID() string { 9218 return "OperationDeserializer" 9219} 9220 9221func (m *awsAwsjson11_deserializeOpUpdatePortfolioShare) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 9222 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 9223) { 9224 out, metadata, err = next.HandleDeserialize(ctx, in) 9225 if err != nil { 9226 return out, metadata, err 9227 } 9228 9229 response, ok := out.RawResponse.(*smithyhttp.Response) 9230 if !ok { 9231 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 9232 } 9233 9234 if response.StatusCode < 200 || response.StatusCode >= 300 { 9235 return out, metadata, awsAwsjson11_deserializeOpErrorUpdatePortfolioShare(response, &metadata) 9236 } 9237 output := &UpdatePortfolioShareOutput{} 9238 out.Result = output 9239 9240 var buff [1024]byte 9241 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9242 9243 body := io.TeeReader(response.Body, ringBuffer) 9244 decoder := json.NewDecoder(body) 9245 decoder.UseNumber() 9246 var shape interface{} 9247 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 9248 var snapshot bytes.Buffer 9249 io.Copy(&snapshot, ringBuffer) 9250 err = &smithy.DeserializationError{ 9251 Err: fmt.Errorf("failed to decode response body, %w", err), 9252 Snapshot: snapshot.Bytes(), 9253 } 9254 return out, metadata, err 9255 } 9256 9257 err = awsAwsjson11_deserializeOpDocumentUpdatePortfolioShareOutput(&output, shape) 9258 if err != nil { 9259 var snapshot bytes.Buffer 9260 io.Copy(&snapshot, ringBuffer) 9261 err = &smithy.DeserializationError{ 9262 Err: fmt.Errorf("failed to decode response body, %w", err), 9263 Snapshot: snapshot.Bytes(), 9264 } 9265 return out, metadata, err 9266 } 9267 9268 return out, metadata, err 9269} 9270 9271func awsAwsjson11_deserializeOpErrorUpdatePortfolioShare(response *smithyhttp.Response, metadata *middleware.Metadata) error { 9272 var errorBuffer bytes.Buffer 9273 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 9274 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 9275 } 9276 errorBody := bytes.NewReader(errorBuffer.Bytes()) 9277 9278 errorCode := "UnknownError" 9279 errorMessage := errorCode 9280 9281 code := response.Header.Get("X-Amzn-ErrorType") 9282 if len(code) != 0 { 9283 errorCode = restjson.SanitizeErrorCode(code) 9284 } 9285 9286 var buff [1024]byte 9287 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9288 9289 body := io.TeeReader(errorBody, ringBuffer) 9290 decoder := json.NewDecoder(body) 9291 decoder.UseNumber() 9292 code, message, err := restjson.GetErrorInfo(decoder) 9293 if err != nil { 9294 var snapshot bytes.Buffer 9295 io.Copy(&snapshot, ringBuffer) 9296 err = &smithy.DeserializationError{ 9297 Err: fmt.Errorf("failed to decode response body, %w", err), 9298 Snapshot: snapshot.Bytes(), 9299 } 9300 return err 9301 } 9302 9303 errorBody.Seek(0, io.SeekStart) 9304 if len(code) != 0 { 9305 errorCode = restjson.SanitizeErrorCode(code) 9306 } 9307 if len(message) != 0 { 9308 errorMessage = message 9309 } 9310 9311 switch { 9312 case strings.EqualFold("InvalidParametersException", errorCode): 9313 return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody) 9314 9315 case strings.EqualFold("InvalidStateException", errorCode): 9316 return awsAwsjson11_deserializeErrorInvalidStateException(response, errorBody) 9317 9318 case strings.EqualFold("OperationNotSupportedException", errorCode): 9319 return awsAwsjson11_deserializeErrorOperationNotSupportedException(response, errorBody) 9320 9321 case strings.EqualFold("ResourceNotFoundException", errorCode): 9322 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 9323 9324 default: 9325 genericError := &smithy.GenericAPIError{ 9326 Code: errorCode, 9327 Message: errorMessage, 9328 } 9329 return genericError 9330 9331 } 9332} 9333 9334type awsAwsjson11_deserializeOpUpdateProduct struct { 9335} 9336 9337func (*awsAwsjson11_deserializeOpUpdateProduct) ID() string { 9338 return "OperationDeserializer" 9339} 9340 9341func (m *awsAwsjson11_deserializeOpUpdateProduct) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 9342 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 9343) { 9344 out, metadata, err = next.HandleDeserialize(ctx, in) 9345 if err != nil { 9346 return out, metadata, err 9347 } 9348 9349 response, ok := out.RawResponse.(*smithyhttp.Response) 9350 if !ok { 9351 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 9352 } 9353 9354 if response.StatusCode < 200 || response.StatusCode >= 300 { 9355 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateProduct(response, &metadata) 9356 } 9357 output := &UpdateProductOutput{} 9358 out.Result = output 9359 9360 var buff [1024]byte 9361 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9362 9363 body := io.TeeReader(response.Body, ringBuffer) 9364 decoder := json.NewDecoder(body) 9365 decoder.UseNumber() 9366 var shape interface{} 9367 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 9368 var snapshot bytes.Buffer 9369 io.Copy(&snapshot, ringBuffer) 9370 err = &smithy.DeserializationError{ 9371 Err: fmt.Errorf("failed to decode response body, %w", err), 9372 Snapshot: snapshot.Bytes(), 9373 } 9374 return out, metadata, err 9375 } 9376 9377 err = awsAwsjson11_deserializeOpDocumentUpdateProductOutput(&output, shape) 9378 if err != nil { 9379 var snapshot bytes.Buffer 9380 io.Copy(&snapshot, ringBuffer) 9381 err = &smithy.DeserializationError{ 9382 Err: fmt.Errorf("failed to decode response body, %w", err), 9383 Snapshot: snapshot.Bytes(), 9384 } 9385 return out, metadata, err 9386 } 9387 9388 return out, metadata, err 9389} 9390 9391func awsAwsjson11_deserializeOpErrorUpdateProduct(response *smithyhttp.Response, metadata *middleware.Metadata) error { 9392 var errorBuffer bytes.Buffer 9393 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 9394 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 9395 } 9396 errorBody := bytes.NewReader(errorBuffer.Bytes()) 9397 9398 errorCode := "UnknownError" 9399 errorMessage := errorCode 9400 9401 code := response.Header.Get("X-Amzn-ErrorType") 9402 if len(code) != 0 { 9403 errorCode = restjson.SanitizeErrorCode(code) 9404 } 9405 9406 var buff [1024]byte 9407 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9408 9409 body := io.TeeReader(errorBody, ringBuffer) 9410 decoder := json.NewDecoder(body) 9411 decoder.UseNumber() 9412 code, message, err := restjson.GetErrorInfo(decoder) 9413 if err != nil { 9414 var snapshot bytes.Buffer 9415 io.Copy(&snapshot, ringBuffer) 9416 err = &smithy.DeserializationError{ 9417 Err: fmt.Errorf("failed to decode response body, %w", err), 9418 Snapshot: snapshot.Bytes(), 9419 } 9420 return err 9421 } 9422 9423 errorBody.Seek(0, io.SeekStart) 9424 if len(code) != 0 { 9425 errorCode = restjson.SanitizeErrorCode(code) 9426 } 9427 if len(message) != 0 { 9428 errorMessage = message 9429 } 9430 9431 switch { 9432 case strings.EqualFold("InvalidParametersException", errorCode): 9433 return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody) 9434 9435 case strings.EqualFold("ResourceNotFoundException", errorCode): 9436 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 9437 9438 case strings.EqualFold("TagOptionNotMigratedException", errorCode): 9439 return awsAwsjson11_deserializeErrorTagOptionNotMigratedException(response, errorBody) 9440 9441 default: 9442 genericError := &smithy.GenericAPIError{ 9443 Code: errorCode, 9444 Message: errorMessage, 9445 } 9446 return genericError 9447 9448 } 9449} 9450 9451type awsAwsjson11_deserializeOpUpdateProvisionedProduct struct { 9452} 9453 9454func (*awsAwsjson11_deserializeOpUpdateProvisionedProduct) ID() string { 9455 return "OperationDeserializer" 9456} 9457 9458func (m *awsAwsjson11_deserializeOpUpdateProvisionedProduct) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 9459 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 9460) { 9461 out, metadata, err = next.HandleDeserialize(ctx, in) 9462 if err != nil { 9463 return out, metadata, err 9464 } 9465 9466 response, ok := out.RawResponse.(*smithyhttp.Response) 9467 if !ok { 9468 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 9469 } 9470 9471 if response.StatusCode < 200 || response.StatusCode >= 300 { 9472 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateProvisionedProduct(response, &metadata) 9473 } 9474 output := &UpdateProvisionedProductOutput{} 9475 out.Result = output 9476 9477 var buff [1024]byte 9478 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9479 9480 body := io.TeeReader(response.Body, ringBuffer) 9481 decoder := json.NewDecoder(body) 9482 decoder.UseNumber() 9483 var shape interface{} 9484 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 9485 var snapshot bytes.Buffer 9486 io.Copy(&snapshot, ringBuffer) 9487 err = &smithy.DeserializationError{ 9488 Err: fmt.Errorf("failed to decode response body, %w", err), 9489 Snapshot: snapshot.Bytes(), 9490 } 9491 return out, metadata, err 9492 } 9493 9494 err = awsAwsjson11_deserializeOpDocumentUpdateProvisionedProductOutput(&output, shape) 9495 if err != nil { 9496 var snapshot bytes.Buffer 9497 io.Copy(&snapshot, ringBuffer) 9498 err = &smithy.DeserializationError{ 9499 Err: fmt.Errorf("failed to decode response body, %w", err), 9500 Snapshot: snapshot.Bytes(), 9501 } 9502 return out, metadata, err 9503 } 9504 9505 return out, metadata, err 9506} 9507 9508func awsAwsjson11_deserializeOpErrorUpdateProvisionedProduct(response *smithyhttp.Response, metadata *middleware.Metadata) error { 9509 var errorBuffer bytes.Buffer 9510 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 9511 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 9512 } 9513 errorBody := bytes.NewReader(errorBuffer.Bytes()) 9514 9515 errorCode := "UnknownError" 9516 errorMessage := errorCode 9517 9518 code := response.Header.Get("X-Amzn-ErrorType") 9519 if len(code) != 0 { 9520 errorCode = restjson.SanitizeErrorCode(code) 9521 } 9522 9523 var buff [1024]byte 9524 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9525 9526 body := io.TeeReader(errorBody, ringBuffer) 9527 decoder := json.NewDecoder(body) 9528 decoder.UseNumber() 9529 code, message, err := restjson.GetErrorInfo(decoder) 9530 if err != nil { 9531 var snapshot bytes.Buffer 9532 io.Copy(&snapshot, ringBuffer) 9533 err = &smithy.DeserializationError{ 9534 Err: fmt.Errorf("failed to decode response body, %w", err), 9535 Snapshot: snapshot.Bytes(), 9536 } 9537 return err 9538 } 9539 9540 errorBody.Seek(0, io.SeekStart) 9541 if len(code) != 0 { 9542 errorCode = restjson.SanitizeErrorCode(code) 9543 } 9544 if len(message) != 0 { 9545 errorMessage = message 9546 } 9547 9548 switch { 9549 case strings.EqualFold("InvalidParametersException", errorCode): 9550 return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody) 9551 9552 case strings.EqualFold("ResourceNotFoundException", errorCode): 9553 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 9554 9555 default: 9556 genericError := &smithy.GenericAPIError{ 9557 Code: errorCode, 9558 Message: errorMessage, 9559 } 9560 return genericError 9561 9562 } 9563} 9564 9565type awsAwsjson11_deserializeOpUpdateProvisionedProductProperties struct { 9566} 9567 9568func (*awsAwsjson11_deserializeOpUpdateProvisionedProductProperties) ID() string { 9569 return "OperationDeserializer" 9570} 9571 9572func (m *awsAwsjson11_deserializeOpUpdateProvisionedProductProperties) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 9573 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 9574) { 9575 out, metadata, err = next.HandleDeserialize(ctx, in) 9576 if err != nil { 9577 return out, metadata, err 9578 } 9579 9580 response, ok := out.RawResponse.(*smithyhttp.Response) 9581 if !ok { 9582 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 9583 } 9584 9585 if response.StatusCode < 200 || response.StatusCode >= 300 { 9586 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateProvisionedProductProperties(response, &metadata) 9587 } 9588 output := &UpdateProvisionedProductPropertiesOutput{} 9589 out.Result = output 9590 9591 var buff [1024]byte 9592 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9593 9594 body := io.TeeReader(response.Body, ringBuffer) 9595 decoder := json.NewDecoder(body) 9596 decoder.UseNumber() 9597 var shape interface{} 9598 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 9599 var snapshot bytes.Buffer 9600 io.Copy(&snapshot, ringBuffer) 9601 err = &smithy.DeserializationError{ 9602 Err: fmt.Errorf("failed to decode response body, %w", err), 9603 Snapshot: snapshot.Bytes(), 9604 } 9605 return out, metadata, err 9606 } 9607 9608 err = awsAwsjson11_deserializeOpDocumentUpdateProvisionedProductPropertiesOutput(&output, shape) 9609 if err != nil { 9610 var snapshot bytes.Buffer 9611 io.Copy(&snapshot, ringBuffer) 9612 err = &smithy.DeserializationError{ 9613 Err: fmt.Errorf("failed to decode response body, %w", err), 9614 Snapshot: snapshot.Bytes(), 9615 } 9616 return out, metadata, err 9617 } 9618 9619 return out, metadata, err 9620} 9621 9622func awsAwsjson11_deserializeOpErrorUpdateProvisionedProductProperties(response *smithyhttp.Response, metadata *middleware.Metadata) error { 9623 var errorBuffer bytes.Buffer 9624 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 9625 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 9626 } 9627 errorBody := bytes.NewReader(errorBuffer.Bytes()) 9628 9629 errorCode := "UnknownError" 9630 errorMessage := errorCode 9631 9632 code := response.Header.Get("X-Amzn-ErrorType") 9633 if len(code) != 0 { 9634 errorCode = restjson.SanitizeErrorCode(code) 9635 } 9636 9637 var buff [1024]byte 9638 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9639 9640 body := io.TeeReader(errorBody, ringBuffer) 9641 decoder := json.NewDecoder(body) 9642 decoder.UseNumber() 9643 code, message, err := restjson.GetErrorInfo(decoder) 9644 if err != nil { 9645 var snapshot bytes.Buffer 9646 io.Copy(&snapshot, ringBuffer) 9647 err = &smithy.DeserializationError{ 9648 Err: fmt.Errorf("failed to decode response body, %w", err), 9649 Snapshot: snapshot.Bytes(), 9650 } 9651 return err 9652 } 9653 9654 errorBody.Seek(0, io.SeekStart) 9655 if len(code) != 0 { 9656 errorCode = restjson.SanitizeErrorCode(code) 9657 } 9658 if len(message) != 0 { 9659 errorMessage = message 9660 } 9661 9662 switch { 9663 case strings.EqualFold("InvalidParametersException", errorCode): 9664 return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody) 9665 9666 case strings.EqualFold("InvalidStateException", errorCode): 9667 return awsAwsjson11_deserializeErrorInvalidStateException(response, errorBody) 9668 9669 case strings.EqualFold("ResourceNotFoundException", errorCode): 9670 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 9671 9672 default: 9673 genericError := &smithy.GenericAPIError{ 9674 Code: errorCode, 9675 Message: errorMessage, 9676 } 9677 return genericError 9678 9679 } 9680} 9681 9682type awsAwsjson11_deserializeOpUpdateProvisioningArtifact struct { 9683} 9684 9685func (*awsAwsjson11_deserializeOpUpdateProvisioningArtifact) ID() string { 9686 return "OperationDeserializer" 9687} 9688 9689func (m *awsAwsjson11_deserializeOpUpdateProvisioningArtifact) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 9690 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 9691) { 9692 out, metadata, err = next.HandleDeserialize(ctx, in) 9693 if err != nil { 9694 return out, metadata, err 9695 } 9696 9697 response, ok := out.RawResponse.(*smithyhttp.Response) 9698 if !ok { 9699 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 9700 } 9701 9702 if response.StatusCode < 200 || response.StatusCode >= 300 { 9703 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateProvisioningArtifact(response, &metadata) 9704 } 9705 output := &UpdateProvisioningArtifactOutput{} 9706 out.Result = output 9707 9708 var buff [1024]byte 9709 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9710 9711 body := io.TeeReader(response.Body, ringBuffer) 9712 decoder := json.NewDecoder(body) 9713 decoder.UseNumber() 9714 var shape interface{} 9715 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 9716 var snapshot bytes.Buffer 9717 io.Copy(&snapshot, ringBuffer) 9718 err = &smithy.DeserializationError{ 9719 Err: fmt.Errorf("failed to decode response body, %w", err), 9720 Snapshot: snapshot.Bytes(), 9721 } 9722 return out, metadata, err 9723 } 9724 9725 err = awsAwsjson11_deserializeOpDocumentUpdateProvisioningArtifactOutput(&output, shape) 9726 if err != nil { 9727 var snapshot bytes.Buffer 9728 io.Copy(&snapshot, ringBuffer) 9729 err = &smithy.DeserializationError{ 9730 Err: fmt.Errorf("failed to decode response body, %w", err), 9731 Snapshot: snapshot.Bytes(), 9732 } 9733 return out, metadata, err 9734 } 9735 9736 return out, metadata, err 9737} 9738 9739func awsAwsjson11_deserializeOpErrorUpdateProvisioningArtifact(response *smithyhttp.Response, metadata *middleware.Metadata) error { 9740 var errorBuffer bytes.Buffer 9741 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 9742 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 9743 } 9744 errorBody := bytes.NewReader(errorBuffer.Bytes()) 9745 9746 errorCode := "UnknownError" 9747 errorMessage := errorCode 9748 9749 code := response.Header.Get("X-Amzn-ErrorType") 9750 if len(code) != 0 { 9751 errorCode = restjson.SanitizeErrorCode(code) 9752 } 9753 9754 var buff [1024]byte 9755 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9756 9757 body := io.TeeReader(errorBody, ringBuffer) 9758 decoder := json.NewDecoder(body) 9759 decoder.UseNumber() 9760 code, message, err := restjson.GetErrorInfo(decoder) 9761 if err != nil { 9762 var snapshot bytes.Buffer 9763 io.Copy(&snapshot, ringBuffer) 9764 err = &smithy.DeserializationError{ 9765 Err: fmt.Errorf("failed to decode response body, %w", err), 9766 Snapshot: snapshot.Bytes(), 9767 } 9768 return err 9769 } 9770 9771 errorBody.Seek(0, io.SeekStart) 9772 if len(code) != 0 { 9773 errorCode = restjson.SanitizeErrorCode(code) 9774 } 9775 if len(message) != 0 { 9776 errorMessage = message 9777 } 9778 9779 switch { 9780 case strings.EqualFold("InvalidParametersException", errorCode): 9781 return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody) 9782 9783 case strings.EqualFold("ResourceNotFoundException", errorCode): 9784 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 9785 9786 default: 9787 genericError := &smithy.GenericAPIError{ 9788 Code: errorCode, 9789 Message: errorMessage, 9790 } 9791 return genericError 9792 9793 } 9794} 9795 9796type awsAwsjson11_deserializeOpUpdateServiceAction struct { 9797} 9798 9799func (*awsAwsjson11_deserializeOpUpdateServiceAction) ID() string { 9800 return "OperationDeserializer" 9801} 9802 9803func (m *awsAwsjson11_deserializeOpUpdateServiceAction) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 9804 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 9805) { 9806 out, metadata, err = next.HandleDeserialize(ctx, in) 9807 if err != nil { 9808 return out, metadata, err 9809 } 9810 9811 response, ok := out.RawResponse.(*smithyhttp.Response) 9812 if !ok { 9813 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 9814 } 9815 9816 if response.StatusCode < 200 || response.StatusCode >= 300 { 9817 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateServiceAction(response, &metadata) 9818 } 9819 output := &UpdateServiceActionOutput{} 9820 out.Result = output 9821 9822 var buff [1024]byte 9823 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9824 9825 body := io.TeeReader(response.Body, ringBuffer) 9826 decoder := json.NewDecoder(body) 9827 decoder.UseNumber() 9828 var shape interface{} 9829 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 9830 var snapshot bytes.Buffer 9831 io.Copy(&snapshot, ringBuffer) 9832 err = &smithy.DeserializationError{ 9833 Err: fmt.Errorf("failed to decode response body, %w", err), 9834 Snapshot: snapshot.Bytes(), 9835 } 9836 return out, metadata, err 9837 } 9838 9839 err = awsAwsjson11_deserializeOpDocumentUpdateServiceActionOutput(&output, shape) 9840 if err != nil { 9841 var snapshot bytes.Buffer 9842 io.Copy(&snapshot, ringBuffer) 9843 err = &smithy.DeserializationError{ 9844 Err: fmt.Errorf("failed to decode response body, %w", err), 9845 Snapshot: snapshot.Bytes(), 9846 } 9847 return out, metadata, err 9848 } 9849 9850 return out, metadata, err 9851} 9852 9853func awsAwsjson11_deserializeOpErrorUpdateServiceAction(response *smithyhttp.Response, metadata *middleware.Metadata) error { 9854 var errorBuffer bytes.Buffer 9855 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 9856 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 9857 } 9858 errorBody := bytes.NewReader(errorBuffer.Bytes()) 9859 9860 errorCode := "UnknownError" 9861 errorMessage := errorCode 9862 9863 code := response.Header.Get("X-Amzn-ErrorType") 9864 if len(code) != 0 { 9865 errorCode = restjson.SanitizeErrorCode(code) 9866 } 9867 9868 var buff [1024]byte 9869 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9870 9871 body := io.TeeReader(errorBody, ringBuffer) 9872 decoder := json.NewDecoder(body) 9873 decoder.UseNumber() 9874 code, message, err := restjson.GetErrorInfo(decoder) 9875 if err != nil { 9876 var snapshot bytes.Buffer 9877 io.Copy(&snapshot, ringBuffer) 9878 err = &smithy.DeserializationError{ 9879 Err: fmt.Errorf("failed to decode response body, %w", err), 9880 Snapshot: snapshot.Bytes(), 9881 } 9882 return err 9883 } 9884 9885 errorBody.Seek(0, io.SeekStart) 9886 if len(code) != 0 { 9887 errorCode = restjson.SanitizeErrorCode(code) 9888 } 9889 if len(message) != 0 { 9890 errorMessage = message 9891 } 9892 9893 switch { 9894 case strings.EqualFold("InvalidParametersException", errorCode): 9895 return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody) 9896 9897 case strings.EqualFold("ResourceNotFoundException", errorCode): 9898 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 9899 9900 default: 9901 genericError := &smithy.GenericAPIError{ 9902 Code: errorCode, 9903 Message: errorMessage, 9904 } 9905 return genericError 9906 9907 } 9908} 9909 9910type awsAwsjson11_deserializeOpUpdateTagOption struct { 9911} 9912 9913func (*awsAwsjson11_deserializeOpUpdateTagOption) ID() string { 9914 return "OperationDeserializer" 9915} 9916 9917func (m *awsAwsjson11_deserializeOpUpdateTagOption) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 9918 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 9919) { 9920 out, metadata, err = next.HandleDeserialize(ctx, in) 9921 if err != nil { 9922 return out, metadata, err 9923 } 9924 9925 response, ok := out.RawResponse.(*smithyhttp.Response) 9926 if !ok { 9927 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 9928 } 9929 9930 if response.StatusCode < 200 || response.StatusCode >= 300 { 9931 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateTagOption(response, &metadata) 9932 } 9933 output := &UpdateTagOptionOutput{} 9934 out.Result = output 9935 9936 var buff [1024]byte 9937 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9938 9939 body := io.TeeReader(response.Body, ringBuffer) 9940 decoder := json.NewDecoder(body) 9941 decoder.UseNumber() 9942 var shape interface{} 9943 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 9944 var snapshot bytes.Buffer 9945 io.Copy(&snapshot, ringBuffer) 9946 err = &smithy.DeserializationError{ 9947 Err: fmt.Errorf("failed to decode response body, %w", err), 9948 Snapshot: snapshot.Bytes(), 9949 } 9950 return out, metadata, err 9951 } 9952 9953 err = awsAwsjson11_deserializeOpDocumentUpdateTagOptionOutput(&output, shape) 9954 if err != nil { 9955 var snapshot bytes.Buffer 9956 io.Copy(&snapshot, ringBuffer) 9957 err = &smithy.DeserializationError{ 9958 Err: fmt.Errorf("failed to decode response body, %w", err), 9959 Snapshot: snapshot.Bytes(), 9960 } 9961 return out, metadata, err 9962 } 9963 9964 return out, metadata, err 9965} 9966 9967func awsAwsjson11_deserializeOpErrorUpdateTagOption(response *smithyhttp.Response, metadata *middleware.Metadata) error { 9968 var errorBuffer bytes.Buffer 9969 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 9970 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 9971 } 9972 errorBody := bytes.NewReader(errorBuffer.Bytes()) 9973 9974 errorCode := "UnknownError" 9975 errorMessage := errorCode 9976 9977 code := response.Header.Get("X-Amzn-ErrorType") 9978 if len(code) != 0 { 9979 errorCode = restjson.SanitizeErrorCode(code) 9980 } 9981 9982 var buff [1024]byte 9983 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9984 9985 body := io.TeeReader(errorBody, ringBuffer) 9986 decoder := json.NewDecoder(body) 9987 decoder.UseNumber() 9988 code, message, err := restjson.GetErrorInfo(decoder) 9989 if err != nil { 9990 var snapshot bytes.Buffer 9991 io.Copy(&snapshot, ringBuffer) 9992 err = &smithy.DeserializationError{ 9993 Err: fmt.Errorf("failed to decode response body, %w", err), 9994 Snapshot: snapshot.Bytes(), 9995 } 9996 return err 9997 } 9998 9999 errorBody.Seek(0, io.SeekStart) 10000 if len(code) != 0 { 10001 errorCode = restjson.SanitizeErrorCode(code) 10002 } 10003 if len(message) != 0 { 10004 errorMessage = message 10005 } 10006 10007 switch { 10008 case strings.EqualFold("DuplicateResourceException", errorCode): 10009 return awsAwsjson11_deserializeErrorDuplicateResourceException(response, errorBody) 10010 10011 case strings.EqualFold("InvalidParametersException", errorCode): 10012 return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody) 10013 10014 case strings.EqualFold("ResourceNotFoundException", errorCode): 10015 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 10016 10017 case strings.EqualFold("TagOptionNotMigratedException", errorCode): 10018 return awsAwsjson11_deserializeErrorTagOptionNotMigratedException(response, errorBody) 10019 10020 default: 10021 genericError := &smithy.GenericAPIError{ 10022 Code: errorCode, 10023 Message: errorMessage, 10024 } 10025 return genericError 10026 10027 } 10028} 10029 10030func awsAwsjson11_deserializeErrorDuplicateResourceException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 10031 var buff [1024]byte 10032 ringBuffer := smithyio.NewRingBuffer(buff[:]) 10033 10034 body := io.TeeReader(errorBody, ringBuffer) 10035 decoder := json.NewDecoder(body) 10036 decoder.UseNumber() 10037 var shape interface{} 10038 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 10039 var snapshot bytes.Buffer 10040 io.Copy(&snapshot, ringBuffer) 10041 err = &smithy.DeserializationError{ 10042 Err: fmt.Errorf("failed to decode response body, %w", err), 10043 Snapshot: snapshot.Bytes(), 10044 } 10045 return err 10046 } 10047 10048 output := &types.DuplicateResourceException{} 10049 err := awsAwsjson11_deserializeDocumentDuplicateResourceException(&output, shape) 10050 10051 if err != nil { 10052 var snapshot bytes.Buffer 10053 io.Copy(&snapshot, ringBuffer) 10054 err = &smithy.DeserializationError{ 10055 Err: fmt.Errorf("failed to decode response body, %w", err), 10056 Snapshot: snapshot.Bytes(), 10057 } 10058 return err 10059 } 10060 10061 errorBody.Seek(0, io.SeekStart) 10062 return output 10063} 10064 10065func awsAwsjson11_deserializeErrorInvalidParametersException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 10066 var buff [1024]byte 10067 ringBuffer := smithyio.NewRingBuffer(buff[:]) 10068 10069 body := io.TeeReader(errorBody, ringBuffer) 10070 decoder := json.NewDecoder(body) 10071 decoder.UseNumber() 10072 var shape interface{} 10073 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 10074 var snapshot bytes.Buffer 10075 io.Copy(&snapshot, ringBuffer) 10076 err = &smithy.DeserializationError{ 10077 Err: fmt.Errorf("failed to decode response body, %w", err), 10078 Snapshot: snapshot.Bytes(), 10079 } 10080 return err 10081 } 10082 10083 output := &types.InvalidParametersException{} 10084 err := awsAwsjson11_deserializeDocumentInvalidParametersException(&output, shape) 10085 10086 if err != nil { 10087 var snapshot bytes.Buffer 10088 io.Copy(&snapshot, ringBuffer) 10089 err = &smithy.DeserializationError{ 10090 Err: fmt.Errorf("failed to decode response body, %w", err), 10091 Snapshot: snapshot.Bytes(), 10092 } 10093 return err 10094 } 10095 10096 errorBody.Seek(0, io.SeekStart) 10097 return output 10098} 10099 10100func awsAwsjson11_deserializeErrorInvalidStateException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 10101 var buff [1024]byte 10102 ringBuffer := smithyio.NewRingBuffer(buff[:]) 10103 10104 body := io.TeeReader(errorBody, ringBuffer) 10105 decoder := json.NewDecoder(body) 10106 decoder.UseNumber() 10107 var shape interface{} 10108 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 10109 var snapshot bytes.Buffer 10110 io.Copy(&snapshot, ringBuffer) 10111 err = &smithy.DeserializationError{ 10112 Err: fmt.Errorf("failed to decode response body, %w", err), 10113 Snapshot: snapshot.Bytes(), 10114 } 10115 return err 10116 } 10117 10118 output := &types.InvalidStateException{} 10119 err := awsAwsjson11_deserializeDocumentInvalidStateException(&output, shape) 10120 10121 if err != nil { 10122 var snapshot bytes.Buffer 10123 io.Copy(&snapshot, ringBuffer) 10124 err = &smithy.DeserializationError{ 10125 Err: fmt.Errorf("failed to decode response body, %w", err), 10126 Snapshot: snapshot.Bytes(), 10127 } 10128 return err 10129 } 10130 10131 errorBody.Seek(0, io.SeekStart) 10132 return output 10133} 10134 10135func awsAwsjson11_deserializeErrorLimitExceededException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 10136 var buff [1024]byte 10137 ringBuffer := smithyio.NewRingBuffer(buff[:]) 10138 10139 body := io.TeeReader(errorBody, ringBuffer) 10140 decoder := json.NewDecoder(body) 10141 decoder.UseNumber() 10142 var shape interface{} 10143 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 10144 var snapshot bytes.Buffer 10145 io.Copy(&snapshot, ringBuffer) 10146 err = &smithy.DeserializationError{ 10147 Err: fmt.Errorf("failed to decode response body, %w", err), 10148 Snapshot: snapshot.Bytes(), 10149 } 10150 return err 10151 } 10152 10153 output := &types.LimitExceededException{} 10154 err := awsAwsjson11_deserializeDocumentLimitExceededException(&output, shape) 10155 10156 if err != nil { 10157 var snapshot bytes.Buffer 10158 io.Copy(&snapshot, ringBuffer) 10159 err = &smithy.DeserializationError{ 10160 Err: fmt.Errorf("failed to decode response body, %w", err), 10161 Snapshot: snapshot.Bytes(), 10162 } 10163 return err 10164 } 10165 10166 errorBody.Seek(0, io.SeekStart) 10167 return output 10168} 10169 10170func awsAwsjson11_deserializeErrorOperationNotSupportedException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 10171 var buff [1024]byte 10172 ringBuffer := smithyio.NewRingBuffer(buff[:]) 10173 10174 body := io.TeeReader(errorBody, ringBuffer) 10175 decoder := json.NewDecoder(body) 10176 decoder.UseNumber() 10177 var shape interface{} 10178 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 10179 var snapshot bytes.Buffer 10180 io.Copy(&snapshot, ringBuffer) 10181 err = &smithy.DeserializationError{ 10182 Err: fmt.Errorf("failed to decode response body, %w", err), 10183 Snapshot: snapshot.Bytes(), 10184 } 10185 return err 10186 } 10187 10188 output := &types.OperationNotSupportedException{} 10189 err := awsAwsjson11_deserializeDocumentOperationNotSupportedException(&output, shape) 10190 10191 if err != nil { 10192 var snapshot bytes.Buffer 10193 io.Copy(&snapshot, ringBuffer) 10194 err = &smithy.DeserializationError{ 10195 Err: fmt.Errorf("failed to decode response body, %w", err), 10196 Snapshot: snapshot.Bytes(), 10197 } 10198 return err 10199 } 10200 10201 errorBody.Seek(0, io.SeekStart) 10202 return output 10203} 10204 10205func awsAwsjson11_deserializeErrorResourceInUseException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 10206 var buff [1024]byte 10207 ringBuffer := smithyio.NewRingBuffer(buff[:]) 10208 10209 body := io.TeeReader(errorBody, ringBuffer) 10210 decoder := json.NewDecoder(body) 10211 decoder.UseNumber() 10212 var shape interface{} 10213 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 10214 var snapshot bytes.Buffer 10215 io.Copy(&snapshot, ringBuffer) 10216 err = &smithy.DeserializationError{ 10217 Err: fmt.Errorf("failed to decode response body, %w", err), 10218 Snapshot: snapshot.Bytes(), 10219 } 10220 return err 10221 } 10222 10223 output := &types.ResourceInUseException{} 10224 err := awsAwsjson11_deserializeDocumentResourceInUseException(&output, shape) 10225 10226 if err != nil { 10227 var snapshot bytes.Buffer 10228 io.Copy(&snapshot, ringBuffer) 10229 err = &smithy.DeserializationError{ 10230 Err: fmt.Errorf("failed to decode response body, %w", err), 10231 Snapshot: snapshot.Bytes(), 10232 } 10233 return err 10234 } 10235 10236 errorBody.Seek(0, io.SeekStart) 10237 return output 10238} 10239 10240func awsAwsjson11_deserializeErrorResourceNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 10241 var buff [1024]byte 10242 ringBuffer := smithyio.NewRingBuffer(buff[:]) 10243 10244 body := io.TeeReader(errorBody, ringBuffer) 10245 decoder := json.NewDecoder(body) 10246 decoder.UseNumber() 10247 var shape interface{} 10248 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 10249 var snapshot bytes.Buffer 10250 io.Copy(&snapshot, ringBuffer) 10251 err = &smithy.DeserializationError{ 10252 Err: fmt.Errorf("failed to decode response body, %w", err), 10253 Snapshot: snapshot.Bytes(), 10254 } 10255 return err 10256 } 10257 10258 output := &types.ResourceNotFoundException{} 10259 err := awsAwsjson11_deserializeDocumentResourceNotFoundException(&output, shape) 10260 10261 if err != nil { 10262 var snapshot bytes.Buffer 10263 io.Copy(&snapshot, ringBuffer) 10264 err = &smithy.DeserializationError{ 10265 Err: fmt.Errorf("failed to decode response body, %w", err), 10266 Snapshot: snapshot.Bytes(), 10267 } 10268 return err 10269 } 10270 10271 errorBody.Seek(0, io.SeekStart) 10272 return output 10273} 10274 10275func awsAwsjson11_deserializeErrorTagOptionNotMigratedException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 10276 var buff [1024]byte 10277 ringBuffer := smithyio.NewRingBuffer(buff[:]) 10278 10279 body := io.TeeReader(errorBody, ringBuffer) 10280 decoder := json.NewDecoder(body) 10281 decoder.UseNumber() 10282 var shape interface{} 10283 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 10284 var snapshot bytes.Buffer 10285 io.Copy(&snapshot, ringBuffer) 10286 err = &smithy.DeserializationError{ 10287 Err: fmt.Errorf("failed to decode response body, %w", err), 10288 Snapshot: snapshot.Bytes(), 10289 } 10290 return err 10291 } 10292 10293 output := &types.TagOptionNotMigratedException{} 10294 err := awsAwsjson11_deserializeDocumentTagOptionNotMigratedException(&output, shape) 10295 10296 if err != nil { 10297 var snapshot bytes.Buffer 10298 io.Copy(&snapshot, ringBuffer) 10299 err = &smithy.DeserializationError{ 10300 Err: fmt.Errorf("failed to decode response body, %w", err), 10301 Snapshot: snapshot.Bytes(), 10302 } 10303 return err 10304 } 10305 10306 errorBody.Seek(0, io.SeekStart) 10307 return output 10308} 10309 10310func awsAwsjson11_deserializeDocumentAccountIds(v *[]string, value interface{}) error { 10311 if v == nil { 10312 return fmt.Errorf("unexpected nil of type %T", v) 10313 } 10314 if value == nil { 10315 return nil 10316 } 10317 10318 shape, ok := value.([]interface{}) 10319 if !ok { 10320 return fmt.Errorf("unexpected JSON type %v", value) 10321 } 10322 10323 var cv []string 10324 if *v == nil { 10325 cv = []string{} 10326 } else { 10327 cv = *v 10328 } 10329 10330 for _, value := range shape { 10331 var col string 10332 if value != nil { 10333 jtv, ok := value.(string) 10334 if !ok { 10335 return fmt.Errorf("expected AccountId to be of type string, got %T instead", value) 10336 } 10337 col = jtv 10338 } 10339 cv = append(cv, col) 10340 10341 } 10342 *v = cv 10343 return nil 10344} 10345 10346func awsAwsjson11_deserializeDocumentAllowedValues(v *[]string, value interface{}) error { 10347 if v == nil { 10348 return fmt.Errorf("unexpected nil of type %T", v) 10349 } 10350 if value == nil { 10351 return nil 10352 } 10353 10354 shape, ok := value.([]interface{}) 10355 if !ok { 10356 return fmt.Errorf("unexpected JSON type %v", value) 10357 } 10358 10359 var cv []string 10360 if *v == nil { 10361 cv = []string{} 10362 } else { 10363 cv = *v 10364 } 10365 10366 for _, value := range shape { 10367 var col string 10368 if value != nil { 10369 jtv, ok := value.(string) 10370 if !ok { 10371 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10372 } 10373 col = jtv 10374 } 10375 cv = append(cv, col) 10376 10377 } 10378 *v = cv 10379 return nil 10380} 10381 10382func awsAwsjson11_deserializeDocumentBudgetDetail(v **types.BudgetDetail, value interface{}) error { 10383 if v == nil { 10384 return fmt.Errorf("unexpected nil of type %T", v) 10385 } 10386 if value == nil { 10387 return nil 10388 } 10389 10390 shape, ok := value.(map[string]interface{}) 10391 if !ok { 10392 return fmt.Errorf("unexpected JSON type %v", value) 10393 } 10394 10395 var sv *types.BudgetDetail 10396 if *v == nil { 10397 sv = &types.BudgetDetail{} 10398 } else { 10399 sv = *v 10400 } 10401 10402 for key, value := range shape { 10403 switch key { 10404 case "BudgetName": 10405 if value != nil { 10406 jtv, ok := value.(string) 10407 if !ok { 10408 return fmt.Errorf("expected BudgetName to be of type string, got %T instead", value) 10409 } 10410 sv.BudgetName = ptr.String(jtv) 10411 } 10412 10413 default: 10414 _, _ = key, value 10415 10416 } 10417 } 10418 *v = sv 10419 return nil 10420} 10421 10422func awsAwsjson11_deserializeDocumentBudgets(v *[]types.BudgetDetail, value interface{}) error { 10423 if v == nil { 10424 return fmt.Errorf("unexpected nil of type %T", v) 10425 } 10426 if value == nil { 10427 return nil 10428 } 10429 10430 shape, ok := value.([]interface{}) 10431 if !ok { 10432 return fmt.Errorf("unexpected JSON type %v", value) 10433 } 10434 10435 var cv []types.BudgetDetail 10436 if *v == nil { 10437 cv = []types.BudgetDetail{} 10438 } else { 10439 cv = *v 10440 } 10441 10442 for _, value := range shape { 10443 var col types.BudgetDetail 10444 destAddr := &col 10445 if err := awsAwsjson11_deserializeDocumentBudgetDetail(&destAddr, value); err != nil { 10446 return err 10447 } 10448 col = *destAddr 10449 cv = append(cv, col) 10450 10451 } 10452 *v = cv 10453 return nil 10454} 10455 10456func awsAwsjson11_deserializeDocumentCloudWatchDashboard(v **types.CloudWatchDashboard, value interface{}) error { 10457 if v == nil { 10458 return fmt.Errorf("unexpected nil of type %T", v) 10459 } 10460 if value == nil { 10461 return nil 10462 } 10463 10464 shape, ok := value.(map[string]interface{}) 10465 if !ok { 10466 return fmt.Errorf("unexpected JSON type %v", value) 10467 } 10468 10469 var sv *types.CloudWatchDashboard 10470 if *v == nil { 10471 sv = &types.CloudWatchDashboard{} 10472 } else { 10473 sv = *v 10474 } 10475 10476 for key, value := range shape { 10477 switch key { 10478 case "Name": 10479 if value != nil { 10480 jtv, ok := value.(string) 10481 if !ok { 10482 return fmt.Errorf("expected CloudWatchDashboardName to be of type string, got %T instead", value) 10483 } 10484 sv.Name = ptr.String(jtv) 10485 } 10486 10487 default: 10488 _, _ = key, value 10489 10490 } 10491 } 10492 *v = sv 10493 return nil 10494} 10495 10496func awsAwsjson11_deserializeDocumentCloudWatchDashboards(v *[]types.CloudWatchDashboard, value interface{}) error { 10497 if v == nil { 10498 return fmt.Errorf("unexpected nil of type %T", v) 10499 } 10500 if value == nil { 10501 return nil 10502 } 10503 10504 shape, ok := value.([]interface{}) 10505 if !ok { 10506 return fmt.Errorf("unexpected JSON type %v", value) 10507 } 10508 10509 var cv []types.CloudWatchDashboard 10510 if *v == nil { 10511 cv = []types.CloudWatchDashboard{} 10512 } else { 10513 cv = *v 10514 } 10515 10516 for _, value := range shape { 10517 var col types.CloudWatchDashboard 10518 destAddr := &col 10519 if err := awsAwsjson11_deserializeDocumentCloudWatchDashboard(&destAddr, value); err != nil { 10520 return err 10521 } 10522 col = *destAddr 10523 cv = append(cv, col) 10524 10525 } 10526 *v = cv 10527 return nil 10528} 10529 10530func awsAwsjson11_deserializeDocumentConstraintDetail(v **types.ConstraintDetail, value interface{}) error { 10531 if v == nil { 10532 return fmt.Errorf("unexpected nil of type %T", v) 10533 } 10534 if value == nil { 10535 return nil 10536 } 10537 10538 shape, ok := value.(map[string]interface{}) 10539 if !ok { 10540 return fmt.Errorf("unexpected JSON type %v", value) 10541 } 10542 10543 var sv *types.ConstraintDetail 10544 if *v == nil { 10545 sv = &types.ConstraintDetail{} 10546 } else { 10547 sv = *v 10548 } 10549 10550 for key, value := range shape { 10551 switch key { 10552 case "ConstraintId": 10553 if value != nil { 10554 jtv, ok := value.(string) 10555 if !ok { 10556 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 10557 } 10558 sv.ConstraintId = ptr.String(jtv) 10559 } 10560 10561 case "Description": 10562 if value != nil { 10563 jtv, ok := value.(string) 10564 if !ok { 10565 return fmt.Errorf("expected ConstraintDescription to be of type string, got %T instead", value) 10566 } 10567 sv.Description = ptr.String(jtv) 10568 } 10569 10570 case "Owner": 10571 if value != nil { 10572 jtv, ok := value.(string) 10573 if !ok { 10574 return fmt.Errorf("expected AccountId to be of type string, got %T instead", value) 10575 } 10576 sv.Owner = ptr.String(jtv) 10577 } 10578 10579 case "PortfolioId": 10580 if value != nil { 10581 jtv, ok := value.(string) 10582 if !ok { 10583 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 10584 } 10585 sv.PortfolioId = ptr.String(jtv) 10586 } 10587 10588 case "ProductId": 10589 if value != nil { 10590 jtv, ok := value.(string) 10591 if !ok { 10592 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 10593 } 10594 sv.ProductId = ptr.String(jtv) 10595 } 10596 10597 case "Type": 10598 if value != nil { 10599 jtv, ok := value.(string) 10600 if !ok { 10601 return fmt.Errorf("expected ConstraintType to be of type string, got %T instead", value) 10602 } 10603 sv.Type = ptr.String(jtv) 10604 } 10605 10606 default: 10607 _, _ = key, value 10608 10609 } 10610 } 10611 *v = sv 10612 return nil 10613} 10614 10615func awsAwsjson11_deserializeDocumentConstraintDetails(v *[]types.ConstraintDetail, value interface{}) error { 10616 if v == nil { 10617 return fmt.Errorf("unexpected nil of type %T", v) 10618 } 10619 if value == nil { 10620 return nil 10621 } 10622 10623 shape, ok := value.([]interface{}) 10624 if !ok { 10625 return fmt.Errorf("unexpected JSON type %v", value) 10626 } 10627 10628 var cv []types.ConstraintDetail 10629 if *v == nil { 10630 cv = []types.ConstraintDetail{} 10631 } else { 10632 cv = *v 10633 } 10634 10635 for _, value := range shape { 10636 var col types.ConstraintDetail 10637 destAddr := &col 10638 if err := awsAwsjson11_deserializeDocumentConstraintDetail(&destAddr, value); err != nil { 10639 return err 10640 } 10641 col = *destAddr 10642 cv = append(cv, col) 10643 10644 } 10645 *v = cv 10646 return nil 10647} 10648 10649func awsAwsjson11_deserializeDocumentConstraintSummaries(v *[]types.ConstraintSummary, value interface{}) error { 10650 if v == nil { 10651 return fmt.Errorf("unexpected nil of type %T", v) 10652 } 10653 if value == nil { 10654 return nil 10655 } 10656 10657 shape, ok := value.([]interface{}) 10658 if !ok { 10659 return fmt.Errorf("unexpected JSON type %v", value) 10660 } 10661 10662 var cv []types.ConstraintSummary 10663 if *v == nil { 10664 cv = []types.ConstraintSummary{} 10665 } else { 10666 cv = *v 10667 } 10668 10669 for _, value := range shape { 10670 var col types.ConstraintSummary 10671 destAddr := &col 10672 if err := awsAwsjson11_deserializeDocumentConstraintSummary(&destAddr, value); err != nil { 10673 return err 10674 } 10675 col = *destAddr 10676 cv = append(cv, col) 10677 10678 } 10679 *v = cv 10680 return nil 10681} 10682 10683func awsAwsjson11_deserializeDocumentConstraintSummary(v **types.ConstraintSummary, value interface{}) error { 10684 if v == nil { 10685 return fmt.Errorf("unexpected nil of type %T", v) 10686 } 10687 if value == nil { 10688 return nil 10689 } 10690 10691 shape, ok := value.(map[string]interface{}) 10692 if !ok { 10693 return fmt.Errorf("unexpected JSON type %v", value) 10694 } 10695 10696 var sv *types.ConstraintSummary 10697 if *v == nil { 10698 sv = &types.ConstraintSummary{} 10699 } else { 10700 sv = *v 10701 } 10702 10703 for key, value := range shape { 10704 switch key { 10705 case "Description": 10706 if value != nil { 10707 jtv, ok := value.(string) 10708 if !ok { 10709 return fmt.Errorf("expected ConstraintDescription to be of type string, got %T instead", value) 10710 } 10711 sv.Description = ptr.String(jtv) 10712 } 10713 10714 case "Type": 10715 if value != nil { 10716 jtv, ok := value.(string) 10717 if !ok { 10718 return fmt.Errorf("expected ConstraintType to be of type string, got %T instead", value) 10719 } 10720 sv.Type = ptr.String(jtv) 10721 } 10722 10723 default: 10724 _, _ = key, value 10725 10726 } 10727 } 10728 *v = sv 10729 return nil 10730} 10731 10732func awsAwsjson11_deserializeDocumentDuplicateResourceException(v **types.DuplicateResourceException, value interface{}) error { 10733 if v == nil { 10734 return fmt.Errorf("unexpected nil of type %T", v) 10735 } 10736 if value == nil { 10737 return nil 10738 } 10739 10740 shape, ok := value.(map[string]interface{}) 10741 if !ok { 10742 return fmt.Errorf("unexpected JSON type %v", value) 10743 } 10744 10745 var sv *types.DuplicateResourceException 10746 if *v == nil { 10747 sv = &types.DuplicateResourceException{} 10748 } else { 10749 sv = *v 10750 } 10751 10752 for key, value := range shape { 10753 switch key { 10754 case "Message": 10755 if value != nil { 10756 jtv, ok := value.(string) 10757 if !ok { 10758 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 10759 } 10760 sv.Message = ptr.String(jtv) 10761 } 10762 10763 default: 10764 _, _ = key, value 10765 10766 } 10767 } 10768 *v = sv 10769 return nil 10770} 10771 10772func awsAwsjson11_deserializeDocumentExecutionParameter(v **types.ExecutionParameter, value interface{}) error { 10773 if v == nil { 10774 return fmt.Errorf("unexpected nil of type %T", v) 10775 } 10776 if value == nil { 10777 return nil 10778 } 10779 10780 shape, ok := value.(map[string]interface{}) 10781 if !ok { 10782 return fmt.Errorf("unexpected JSON type %v", value) 10783 } 10784 10785 var sv *types.ExecutionParameter 10786 if *v == nil { 10787 sv = &types.ExecutionParameter{} 10788 } else { 10789 sv = *v 10790 } 10791 10792 for key, value := range shape { 10793 switch key { 10794 case "DefaultValues": 10795 if err := awsAwsjson11_deserializeDocumentExecutionParameterValueList(&sv.DefaultValues, value); err != nil { 10796 return err 10797 } 10798 10799 case "Name": 10800 if value != nil { 10801 jtv, ok := value.(string) 10802 if !ok { 10803 return fmt.Errorf("expected ExecutionParameterKey to be of type string, got %T instead", value) 10804 } 10805 sv.Name = ptr.String(jtv) 10806 } 10807 10808 case "Type": 10809 if value != nil { 10810 jtv, ok := value.(string) 10811 if !ok { 10812 return fmt.Errorf("expected ExecutionParameterType to be of type string, got %T instead", value) 10813 } 10814 sv.Type = ptr.String(jtv) 10815 } 10816 10817 default: 10818 _, _ = key, value 10819 10820 } 10821 } 10822 *v = sv 10823 return nil 10824} 10825 10826func awsAwsjson11_deserializeDocumentExecutionParameters(v *[]types.ExecutionParameter, value interface{}) error { 10827 if v == nil { 10828 return fmt.Errorf("unexpected nil of type %T", v) 10829 } 10830 if value == nil { 10831 return nil 10832 } 10833 10834 shape, ok := value.([]interface{}) 10835 if !ok { 10836 return fmt.Errorf("unexpected JSON type %v", value) 10837 } 10838 10839 var cv []types.ExecutionParameter 10840 if *v == nil { 10841 cv = []types.ExecutionParameter{} 10842 } else { 10843 cv = *v 10844 } 10845 10846 for _, value := range shape { 10847 var col types.ExecutionParameter 10848 destAddr := &col 10849 if err := awsAwsjson11_deserializeDocumentExecutionParameter(&destAddr, value); err != nil { 10850 return err 10851 } 10852 col = *destAddr 10853 cv = append(cv, col) 10854 10855 } 10856 *v = cv 10857 return nil 10858} 10859 10860func awsAwsjson11_deserializeDocumentExecutionParameterValueList(v *[]string, value interface{}) error { 10861 if v == nil { 10862 return fmt.Errorf("unexpected nil of type %T", v) 10863 } 10864 if value == nil { 10865 return nil 10866 } 10867 10868 shape, ok := value.([]interface{}) 10869 if !ok { 10870 return fmt.Errorf("unexpected JSON type %v", value) 10871 } 10872 10873 var cv []string 10874 if *v == nil { 10875 cv = []string{} 10876 } else { 10877 cv = *v 10878 } 10879 10880 for _, value := range shape { 10881 var col string 10882 if value != nil { 10883 jtv, ok := value.(string) 10884 if !ok { 10885 return fmt.Errorf("expected ExecutionParameterValue to be of type string, got %T instead", value) 10886 } 10887 col = jtv 10888 } 10889 cv = append(cv, col) 10890 10891 } 10892 *v = cv 10893 return nil 10894} 10895 10896func awsAwsjson11_deserializeDocumentFailedServiceActionAssociation(v **types.FailedServiceActionAssociation, value interface{}) error { 10897 if v == nil { 10898 return fmt.Errorf("unexpected nil of type %T", v) 10899 } 10900 if value == nil { 10901 return nil 10902 } 10903 10904 shape, ok := value.(map[string]interface{}) 10905 if !ok { 10906 return fmt.Errorf("unexpected JSON type %v", value) 10907 } 10908 10909 var sv *types.FailedServiceActionAssociation 10910 if *v == nil { 10911 sv = &types.FailedServiceActionAssociation{} 10912 } else { 10913 sv = *v 10914 } 10915 10916 for key, value := range shape { 10917 switch key { 10918 case "ErrorCode": 10919 if value != nil { 10920 jtv, ok := value.(string) 10921 if !ok { 10922 return fmt.Errorf("expected ServiceActionAssociationErrorCode to be of type string, got %T instead", value) 10923 } 10924 sv.ErrorCode = types.ServiceActionAssociationErrorCode(jtv) 10925 } 10926 10927 case "ErrorMessage": 10928 if value != nil { 10929 jtv, ok := value.(string) 10930 if !ok { 10931 return fmt.Errorf("expected ServiceActionAssociationErrorMessage to be of type string, got %T instead", value) 10932 } 10933 sv.ErrorMessage = ptr.String(jtv) 10934 } 10935 10936 case "ProductId": 10937 if value != nil { 10938 jtv, ok := value.(string) 10939 if !ok { 10940 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 10941 } 10942 sv.ProductId = ptr.String(jtv) 10943 } 10944 10945 case "ProvisioningArtifactId": 10946 if value != nil { 10947 jtv, ok := value.(string) 10948 if !ok { 10949 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 10950 } 10951 sv.ProvisioningArtifactId = ptr.String(jtv) 10952 } 10953 10954 case "ServiceActionId": 10955 if value != nil { 10956 jtv, ok := value.(string) 10957 if !ok { 10958 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 10959 } 10960 sv.ServiceActionId = ptr.String(jtv) 10961 } 10962 10963 default: 10964 _, _ = key, value 10965 10966 } 10967 } 10968 *v = sv 10969 return nil 10970} 10971 10972func awsAwsjson11_deserializeDocumentFailedServiceActionAssociations(v *[]types.FailedServiceActionAssociation, value interface{}) error { 10973 if v == nil { 10974 return fmt.Errorf("unexpected nil of type %T", v) 10975 } 10976 if value == nil { 10977 return nil 10978 } 10979 10980 shape, ok := value.([]interface{}) 10981 if !ok { 10982 return fmt.Errorf("unexpected JSON type %v", value) 10983 } 10984 10985 var cv []types.FailedServiceActionAssociation 10986 if *v == nil { 10987 cv = []types.FailedServiceActionAssociation{} 10988 } else { 10989 cv = *v 10990 } 10991 10992 for _, value := range shape { 10993 var col types.FailedServiceActionAssociation 10994 destAddr := &col 10995 if err := awsAwsjson11_deserializeDocumentFailedServiceActionAssociation(&destAddr, value); err != nil { 10996 return err 10997 } 10998 col = *destAddr 10999 cv = append(cv, col) 11000 11001 } 11002 *v = cv 11003 return nil 11004} 11005 11006func awsAwsjson11_deserializeDocumentInvalidParametersException(v **types.InvalidParametersException, value interface{}) error { 11007 if v == nil { 11008 return fmt.Errorf("unexpected nil of type %T", v) 11009 } 11010 if value == nil { 11011 return nil 11012 } 11013 11014 shape, ok := value.(map[string]interface{}) 11015 if !ok { 11016 return fmt.Errorf("unexpected JSON type %v", value) 11017 } 11018 11019 var sv *types.InvalidParametersException 11020 if *v == nil { 11021 sv = &types.InvalidParametersException{} 11022 } else { 11023 sv = *v 11024 } 11025 11026 for key, value := range shape { 11027 switch key { 11028 case "Message": 11029 if value != nil { 11030 jtv, ok := value.(string) 11031 if !ok { 11032 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 11033 } 11034 sv.Message = ptr.String(jtv) 11035 } 11036 11037 default: 11038 _, _ = key, value 11039 11040 } 11041 } 11042 *v = sv 11043 return nil 11044} 11045 11046func awsAwsjson11_deserializeDocumentInvalidStateException(v **types.InvalidStateException, value interface{}) error { 11047 if v == nil { 11048 return fmt.Errorf("unexpected nil of type %T", v) 11049 } 11050 if value == nil { 11051 return nil 11052 } 11053 11054 shape, ok := value.(map[string]interface{}) 11055 if !ok { 11056 return fmt.Errorf("unexpected JSON type %v", value) 11057 } 11058 11059 var sv *types.InvalidStateException 11060 if *v == nil { 11061 sv = &types.InvalidStateException{} 11062 } else { 11063 sv = *v 11064 } 11065 11066 for key, value := range shape { 11067 switch key { 11068 case "Message": 11069 if value != nil { 11070 jtv, ok := value.(string) 11071 if !ok { 11072 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 11073 } 11074 sv.Message = ptr.String(jtv) 11075 } 11076 11077 default: 11078 _, _ = key, value 11079 11080 } 11081 } 11082 *v = sv 11083 return nil 11084} 11085 11086func awsAwsjson11_deserializeDocumentLaunchPath(v **types.LaunchPath, value interface{}) error { 11087 if v == nil { 11088 return fmt.Errorf("unexpected nil of type %T", v) 11089 } 11090 if value == nil { 11091 return nil 11092 } 11093 11094 shape, ok := value.(map[string]interface{}) 11095 if !ok { 11096 return fmt.Errorf("unexpected JSON type %v", value) 11097 } 11098 11099 var sv *types.LaunchPath 11100 if *v == nil { 11101 sv = &types.LaunchPath{} 11102 } else { 11103 sv = *v 11104 } 11105 11106 for key, value := range shape { 11107 switch key { 11108 case "Id": 11109 if value != nil { 11110 jtv, ok := value.(string) 11111 if !ok { 11112 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 11113 } 11114 sv.Id = ptr.String(jtv) 11115 } 11116 11117 case "Name": 11118 if value != nil { 11119 jtv, ok := value.(string) 11120 if !ok { 11121 return fmt.Errorf("expected PortfolioName to be of type string, got %T instead", value) 11122 } 11123 sv.Name = ptr.String(jtv) 11124 } 11125 11126 default: 11127 _, _ = key, value 11128 11129 } 11130 } 11131 *v = sv 11132 return nil 11133} 11134 11135func awsAwsjson11_deserializeDocumentLaunchPaths(v *[]types.LaunchPath, value interface{}) error { 11136 if v == nil { 11137 return fmt.Errorf("unexpected nil of type %T", v) 11138 } 11139 if value == nil { 11140 return nil 11141 } 11142 11143 shape, ok := value.([]interface{}) 11144 if !ok { 11145 return fmt.Errorf("unexpected JSON type %v", value) 11146 } 11147 11148 var cv []types.LaunchPath 11149 if *v == nil { 11150 cv = []types.LaunchPath{} 11151 } else { 11152 cv = *v 11153 } 11154 11155 for _, value := range shape { 11156 var col types.LaunchPath 11157 destAddr := &col 11158 if err := awsAwsjson11_deserializeDocumentLaunchPath(&destAddr, value); err != nil { 11159 return err 11160 } 11161 col = *destAddr 11162 cv = append(cv, col) 11163 11164 } 11165 *v = cv 11166 return nil 11167} 11168 11169func awsAwsjson11_deserializeDocumentLaunchPathSummaries(v *[]types.LaunchPathSummary, value interface{}) error { 11170 if v == nil { 11171 return fmt.Errorf("unexpected nil of type %T", v) 11172 } 11173 if value == nil { 11174 return nil 11175 } 11176 11177 shape, ok := value.([]interface{}) 11178 if !ok { 11179 return fmt.Errorf("unexpected JSON type %v", value) 11180 } 11181 11182 var cv []types.LaunchPathSummary 11183 if *v == nil { 11184 cv = []types.LaunchPathSummary{} 11185 } else { 11186 cv = *v 11187 } 11188 11189 for _, value := range shape { 11190 var col types.LaunchPathSummary 11191 destAddr := &col 11192 if err := awsAwsjson11_deserializeDocumentLaunchPathSummary(&destAddr, value); err != nil { 11193 return err 11194 } 11195 col = *destAddr 11196 cv = append(cv, col) 11197 11198 } 11199 *v = cv 11200 return nil 11201} 11202 11203func awsAwsjson11_deserializeDocumentLaunchPathSummary(v **types.LaunchPathSummary, value interface{}) error { 11204 if v == nil { 11205 return fmt.Errorf("unexpected nil of type %T", v) 11206 } 11207 if value == nil { 11208 return nil 11209 } 11210 11211 shape, ok := value.(map[string]interface{}) 11212 if !ok { 11213 return fmt.Errorf("unexpected JSON type %v", value) 11214 } 11215 11216 var sv *types.LaunchPathSummary 11217 if *v == nil { 11218 sv = &types.LaunchPathSummary{} 11219 } else { 11220 sv = *v 11221 } 11222 11223 for key, value := range shape { 11224 switch key { 11225 case "ConstraintSummaries": 11226 if err := awsAwsjson11_deserializeDocumentConstraintSummaries(&sv.ConstraintSummaries, value); err != nil { 11227 return err 11228 } 11229 11230 case "Id": 11231 if value != nil { 11232 jtv, ok := value.(string) 11233 if !ok { 11234 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 11235 } 11236 sv.Id = ptr.String(jtv) 11237 } 11238 11239 case "Name": 11240 if value != nil { 11241 jtv, ok := value.(string) 11242 if !ok { 11243 return fmt.Errorf("expected PortfolioName to be of type string, got %T instead", value) 11244 } 11245 sv.Name = ptr.String(jtv) 11246 } 11247 11248 case "Tags": 11249 if err := awsAwsjson11_deserializeDocumentTags(&sv.Tags, value); err != nil { 11250 return err 11251 } 11252 11253 default: 11254 _, _ = key, value 11255 11256 } 11257 } 11258 *v = sv 11259 return nil 11260} 11261 11262func awsAwsjson11_deserializeDocumentLimitExceededException(v **types.LimitExceededException, value interface{}) error { 11263 if v == nil { 11264 return fmt.Errorf("unexpected nil of type %T", v) 11265 } 11266 if value == nil { 11267 return nil 11268 } 11269 11270 shape, ok := value.(map[string]interface{}) 11271 if !ok { 11272 return fmt.Errorf("unexpected JSON type %v", value) 11273 } 11274 11275 var sv *types.LimitExceededException 11276 if *v == nil { 11277 sv = &types.LimitExceededException{} 11278 } else { 11279 sv = *v 11280 } 11281 11282 for key, value := range shape { 11283 switch key { 11284 case "Message": 11285 if value != nil { 11286 jtv, ok := value.(string) 11287 if !ok { 11288 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 11289 } 11290 sv.Message = ptr.String(jtv) 11291 } 11292 11293 default: 11294 _, _ = key, value 11295 11296 } 11297 } 11298 *v = sv 11299 return nil 11300} 11301 11302func awsAwsjson11_deserializeDocumentNamespaces(v *[]string, value interface{}) error { 11303 if v == nil { 11304 return fmt.Errorf("unexpected nil of type %T", v) 11305 } 11306 if value == nil { 11307 return nil 11308 } 11309 11310 shape, ok := value.([]interface{}) 11311 if !ok { 11312 return fmt.Errorf("unexpected JSON type %v", value) 11313 } 11314 11315 var cv []string 11316 if *v == nil { 11317 cv = []string{} 11318 } else { 11319 cv = *v 11320 } 11321 11322 for _, value := range shape { 11323 var col string 11324 if value != nil { 11325 jtv, ok := value.(string) 11326 if !ok { 11327 return fmt.Errorf("expected AccountId to be of type string, got %T instead", value) 11328 } 11329 col = jtv 11330 } 11331 cv = append(cv, col) 11332 11333 } 11334 *v = cv 11335 return nil 11336} 11337 11338func awsAwsjson11_deserializeDocumentNotificationArns(v *[]string, value interface{}) error { 11339 if v == nil { 11340 return fmt.Errorf("unexpected nil of type %T", v) 11341 } 11342 if value == nil { 11343 return nil 11344 } 11345 11346 shape, ok := value.([]interface{}) 11347 if !ok { 11348 return fmt.Errorf("unexpected JSON type %v", value) 11349 } 11350 11351 var cv []string 11352 if *v == nil { 11353 cv = []string{} 11354 } else { 11355 cv = *v 11356 } 11357 11358 for _, value := range shape { 11359 var col string 11360 if value != nil { 11361 jtv, ok := value.(string) 11362 if !ok { 11363 return fmt.Errorf("expected NotificationArn to be of type string, got %T instead", value) 11364 } 11365 col = jtv 11366 } 11367 cv = append(cv, col) 11368 11369 } 11370 *v = cv 11371 return nil 11372} 11373 11374func awsAwsjson11_deserializeDocumentOperationNotSupportedException(v **types.OperationNotSupportedException, value interface{}) error { 11375 if v == nil { 11376 return fmt.Errorf("unexpected nil of type %T", v) 11377 } 11378 if value == nil { 11379 return nil 11380 } 11381 11382 shape, ok := value.(map[string]interface{}) 11383 if !ok { 11384 return fmt.Errorf("unexpected JSON type %v", value) 11385 } 11386 11387 var sv *types.OperationNotSupportedException 11388 if *v == nil { 11389 sv = &types.OperationNotSupportedException{} 11390 } else { 11391 sv = *v 11392 } 11393 11394 for key, value := range shape { 11395 switch key { 11396 case "Message": 11397 if value != nil { 11398 jtv, ok := value.(string) 11399 if !ok { 11400 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 11401 } 11402 sv.Message = ptr.String(jtv) 11403 } 11404 11405 default: 11406 _, _ = key, value 11407 11408 } 11409 } 11410 *v = sv 11411 return nil 11412} 11413 11414func awsAwsjson11_deserializeDocumentOrganizationNode(v **types.OrganizationNode, value interface{}) error { 11415 if v == nil { 11416 return fmt.Errorf("unexpected nil of type %T", v) 11417 } 11418 if value == nil { 11419 return nil 11420 } 11421 11422 shape, ok := value.(map[string]interface{}) 11423 if !ok { 11424 return fmt.Errorf("unexpected JSON type %v", value) 11425 } 11426 11427 var sv *types.OrganizationNode 11428 if *v == nil { 11429 sv = &types.OrganizationNode{} 11430 } else { 11431 sv = *v 11432 } 11433 11434 for key, value := range shape { 11435 switch key { 11436 case "Type": 11437 if value != nil { 11438 jtv, ok := value.(string) 11439 if !ok { 11440 return fmt.Errorf("expected OrganizationNodeType to be of type string, got %T instead", value) 11441 } 11442 sv.Type = types.OrganizationNodeType(jtv) 11443 } 11444 11445 case "Value": 11446 if value != nil { 11447 jtv, ok := value.(string) 11448 if !ok { 11449 return fmt.Errorf("expected OrganizationNodeValue to be of type string, got %T instead", value) 11450 } 11451 sv.Value = ptr.String(jtv) 11452 } 11453 11454 default: 11455 _, _ = key, value 11456 11457 } 11458 } 11459 *v = sv 11460 return nil 11461} 11462 11463func awsAwsjson11_deserializeDocumentOrganizationNodes(v *[]types.OrganizationNode, value interface{}) error { 11464 if v == nil { 11465 return fmt.Errorf("unexpected nil of type %T", v) 11466 } 11467 if value == nil { 11468 return nil 11469 } 11470 11471 shape, ok := value.([]interface{}) 11472 if !ok { 11473 return fmt.Errorf("unexpected JSON type %v", value) 11474 } 11475 11476 var cv []types.OrganizationNode 11477 if *v == nil { 11478 cv = []types.OrganizationNode{} 11479 } else { 11480 cv = *v 11481 } 11482 11483 for _, value := range shape { 11484 var col types.OrganizationNode 11485 destAddr := &col 11486 if err := awsAwsjson11_deserializeDocumentOrganizationNode(&destAddr, value); err != nil { 11487 return err 11488 } 11489 col = *destAddr 11490 cv = append(cv, col) 11491 11492 } 11493 *v = cv 11494 return nil 11495} 11496 11497func awsAwsjson11_deserializeDocumentParameterConstraints(v **types.ParameterConstraints, value interface{}) error { 11498 if v == nil { 11499 return fmt.Errorf("unexpected nil of type %T", v) 11500 } 11501 if value == nil { 11502 return nil 11503 } 11504 11505 shape, ok := value.(map[string]interface{}) 11506 if !ok { 11507 return fmt.Errorf("unexpected JSON type %v", value) 11508 } 11509 11510 var sv *types.ParameterConstraints 11511 if *v == nil { 11512 sv = &types.ParameterConstraints{} 11513 } else { 11514 sv = *v 11515 } 11516 11517 for key, value := range shape { 11518 switch key { 11519 case "AllowedPattern": 11520 if value != nil { 11521 jtv, ok := value.(string) 11522 if !ok { 11523 return fmt.Errorf("expected String to be of type string, got %T instead", value) 11524 } 11525 sv.AllowedPattern = ptr.String(jtv) 11526 } 11527 11528 case "AllowedValues": 11529 if err := awsAwsjson11_deserializeDocumentAllowedValues(&sv.AllowedValues, value); err != nil { 11530 return err 11531 } 11532 11533 case "ConstraintDescription": 11534 if value != nil { 11535 jtv, ok := value.(string) 11536 if !ok { 11537 return fmt.Errorf("expected String to be of type string, got %T instead", value) 11538 } 11539 sv.ConstraintDescription = ptr.String(jtv) 11540 } 11541 11542 case "MaxLength": 11543 if value != nil { 11544 jtv, ok := value.(string) 11545 if !ok { 11546 return fmt.Errorf("expected String to be of type string, got %T instead", value) 11547 } 11548 sv.MaxLength = ptr.String(jtv) 11549 } 11550 11551 case "MaxValue": 11552 if value != nil { 11553 jtv, ok := value.(string) 11554 if !ok { 11555 return fmt.Errorf("expected String to be of type string, got %T instead", value) 11556 } 11557 sv.MaxValue = ptr.String(jtv) 11558 } 11559 11560 case "MinLength": 11561 if value != nil { 11562 jtv, ok := value.(string) 11563 if !ok { 11564 return fmt.Errorf("expected String to be of type string, got %T instead", value) 11565 } 11566 sv.MinLength = ptr.String(jtv) 11567 } 11568 11569 case "MinValue": 11570 if value != nil { 11571 jtv, ok := value.(string) 11572 if !ok { 11573 return fmt.Errorf("expected String to be of type string, got %T instead", value) 11574 } 11575 sv.MinValue = ptr.String(jtv) 11576 } 11577 11578 default: 11579 _, _ = key, value 11580 11581 } 11582 } 11583 *v = sv 11584 return nil 11585} 11586 11587func awsAwsjson11_deserializeDocumentPortfolioDetail(v **types.PortfolioDetail, value interface{}) error { 11588 if v == nil { 11589 return fmt.Errorf("unexpected nil of type %T", v) 11590 } 11591 if value == nil { 11592 return nil 11593 } 11594 11595 shape, ok := value.(map[string]interface{}) 11596 if !ok { 11597 return fmt.Errorf("unexpected JSON type %v", value) 11598 } 11599 11600 var sv *types.PortfolioDetail 11601 if *v == nil { 11602 sv = &types.PortfolioDetail{} 11603 } else { 11604 sv = *v 11605 } 11606 11607 for key, value := range shape { 11608 switch key { 11609 case "ARN": 11610 if value != nil { 11611 jtv, ok := value.(string) 11612 if !ok { 11613 return fmt.Errorf("expected ResourceARN to be of type string, got %T instead", value) 11614 } 11615 sv.ARN = ptr.String(jtv) 11616 } 11617 11618 case "CreatedTime": 11619 if value != nil { 11620 jtv, ok := value.(json.Number) 11621 if !ok { 11622 return fmt.Errorf("expected CreationTime to be json.Number, got %T instead", value) 11623 } 11624 f64, err := jtv.Float64() 11625 if err != nil { 11626 return err 11627 } 11628 sv.CreatedTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 11629 } 11630 11631 case "Description": 11632 if value != nil { 11633 jtv, ok := value.(string) 11634 if !ok { 11635 return fmt.Errorf("expected PortfolioDescription to be of type string, got %T instead", value) 11636 } 11637 sv.Description = ptr.String(jtv) 11638 } 11639 11640 case "DisplayName": 11641 if value != nil { 11642 jtv, ok := value.(string) 11643 if !ok { 11644 return fmt.Errorf("expected PortfolioDisplayName to be of type string, got %T instead", value) 11645 } 11646 sv.DisplayName = ptr.String(jtv) 11647 } 11648 11649 case "Id": 11650 if value != nil { 11651 jtv, ok := value.(string) 11652 if !ok { 11653 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 11654 } 11655 sv.Id = ptr.String(jtv) 11656 } 11657 11658 case "ProviderName": 11659 if value != nil { 11660 jtv, ok := value.(string) 11661 if !ok { 11662 return fmt.Errorf("expected ProviderName to be of type string, got %T instead", value) 11663 } 11664 sv.ProviderName = ptr.String(jtv) 11665 } 11666 11667 default: 11668 _, _ = key, value 11669 11670 } 11671 } 11672 *v = sv 11673 return nil 11674} 11675 11676func awsAwsjson11_deserializeDocumentPortfolioDetails(v *[]types.PortfolioDetail, value interface{}) error { 11677 if v == nil { 11678 return fmt.Errorf("unexpected nil of type %T", v) 11679 } 11680 if value == nil { 11681 return nil 11682 } 11683 11684 shape, ok := value.([]interface{}) 11685 if !ok { 11686 return fmt.Errorf("unexpected JSON type %v", value) 11687 } 11688 11689 var cv []types.PortfolioDetail 11690 if *v == nil { 11691 cv = []types.PortfolioDetail{} 11692 } else { 11693 cv = *v 11694 } 11695 11696 for _, value := range shape { 11697 var col types.PortfolioDetail 11698 destAddr := &col 11699 if err := awsAwsjson11_deserializeDocumentPortfolioDetail(&destAddr, value); err != nil { 11700 return err 11701 } 11702 col = *destAddr 11703 cv = append(cv, col) 11704 11705 } 11706 *v = cv 11707 return nil 11708} 11709 11710func awsAwsjson11_deserializeDocumentPortfolioShareDetail(v **types.PortfolioShareDetail, value interface{}) error { 11711 if v == nil { 11712 return fmt.Errorf("unexpected nil of type %T", v) 11713 } 11714 if value == nil { 11715 return nil 11716 } 11717 11718 shape, ok := value.(map[string]interface{}) 11719 if !ok { 11720 return fmt.Errorf("unexpected JSON type %v", value) 11721 } 11722 11723 var sv *types.PortfolioShareDetail 11724 if *v == nil { 11725 sv = &types.PortfolioShareDetail{} 11726 } else { 11727 sv = *v 11728 } 11729 11730 for key, value := range shape { 11731 switch key { 11732 case "Accepted": 11733 if value != nil { 11734 jtv, ok := value.(bool) 11735 if !ok { 11736 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 11737 } 11738 sv.Accepted = jtv 11739 } 11740 11741 case "PrincipalId": 11742 if value != nil { 11743 jtv, ok := value.(string) 11744 if !ok { 11745 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 11746 } 11747 sv.PrincipalId = ptr.String(jtv) 11748 } 11749 11750 case "ShareTagOptions": 11751 if value != nil { 11752 jtv, ok := value.(bool) 11753 if !ok { 11754 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 11755 } 11756 sv.ShareTagOptions = jtv 11757 } 11758 11759 case "Type": 11760 if value != nil { 11761 jtv, ok := value.(string) 11762 if !ok { 11763 return fmt.Errorf("expected DescribePortfolioShareType to be of type string, got %T instead", value) 11764 } 11765 sv.Type = types.DescribePortfolioShareType(jtv) 11766 } 11767 11768 default: 11769 _, _ = key, value 11770 11771 } 11772 } 11773 *v = sv 11774 return nil 11775} 11776 11777func awsAwsjson11_deserializeDocumentPortfolioShareDetails(v *[]types.PortfolioShareDetail, value interface{}) error { 11778 if v == nil { 11779 return fmt.Errorf("unexpected nil of type %T", v) 11780 } 11781 if value == nil { 11782 return nil 11783 } 11784 11785 shape, ok := value.([]interface{}) 11786 if !ok { 11787 return fmt.Errorf("unexpected JSON type %v", value) 11788 } 11789 11790 var cv []types.PortfolioShareDetail 11791 if *v == nil { 11792 cv = []types.PortfolioShareDetail{} 11793 } else { 11794 cv = *v 11795 } 11796 11797 for _, value := range shape { 11798 var col types.PortfolioShareDetail 11799 destAddr := &col 11800 if err := awsAwsjson11_deserializeDocumentPortfolioShareDetail(&destAddr, value); err != nil { 11801 return err 11802 } 11803 col = *destAddr 11804 cv = append(cv, col) 11805 11806 } 11807 *v = cv 11808 return nil 11809} 11810 11811func awsAwsjson11_deserializeDocumentPrincipal(v **types.Principal, value interface{}) error { 11812 if v == nil { 11813 return fmt.Errorf("unexpected nil of type %T", v) 11814 } 11815 if value == nil { 11816 return nil 11817 } 11818 11819 shape, ok := value.(map[string]interface{}) 11820 if !ok { 11821 return fmt.Errorf("unexpected JSON type %v", value) 11822 } 11823 11824 var sv *types.Principal 11825 if *v == nil { 11826 sv = &types.Principal{} 11827 } else { 11828 sv = *v 11829 } 11830 11831 for key, value := range shape { 11832 switch key { 11833 case "PrincipalARN": 11834 if value != nil { 11835 jtv, ok := value.(string) 11836 if !ok { 11837 return fmt.Errorf("expected PrincipalARN to be of type string, got %T instead", value) 11838 } 11839 sv.PrincipalARN = ptr.String(jtv) 11840 } 11841 11842 case "PrincipalType": 11843 if value != nil { 11844 jtv, ok := value.(string) 11845 if !ok { 11846 return fmt.Errorf("expected PrincipalType to be of type string, got %T instead", value) 11847 } 11848 sv.PrincipalType = types.PrincipalType(jtv) 11849 } 11850 11851 default: 11852 _, _ = key, value 11853 11854 } 11855 } 11856 *v = sv 11857 return nil 11858} 11859 11860func awsAwsjson11_deserializeDocumentPrincipals(v *[]types.Principal, value interface{}) error { 11861 if v == nil { 11862 return fmt.Errorf("unexpected nil of type %T", v) 11863 } 11864 if value == nil { 11865 return nil 11866 } 11867 11868 shape, ok := value.([]interface{}) 11869 if !ok { 11870 return fmt.Errorf("unexpected JSON type %v", value) 11871 } 11872 11873 var cv []types.Principal 11874 if *v == nil { 11875 cv = []types.Principal{} 11876 } else { 11877 cv = *v 11878 } 11879 11880 for _, value := range shape { 11881 var col types.Principal 11882 destAddr := &col 11883 if err := awsAwsjson11_deserializeDocumentPrincipal(&destAddr, value); err != nil { 11884 return err 11885 } 11886 col = *destAddr 11887 cv = append(cv, col) 11888 11889 } 11890 *v = cv 11891 return nil 11892} 11893 11894func awsAwsjson11_deserializeDocumentProductViewAggregations(v *map[string][]types.ProductViewAggregationValue, value interface{}) error { 11895 if v == nil { 11896 return fmt.Errorf("unexpected nil of type %T", v) 11897 } 11898 if value == nil { 11899 return nil 11900 } 11901 11902 shape, ok := value.(map[string]interface{}) 11903 if !ok { 11904 return fmt.Errorf("unexpected JSON type %v", value) 11905 } 11906 11907 var mv map[string][]types.ProductViewAggregationValue 11908 if *v == nil { 11909 mv = map[string][]types.ProductViewAggregationValue{} 11910 } else { 11911 mv = *v 11912 } 11913 11914 for key, value := range shape { 11915 var parsedVal []types.ProductViewAggregationValue 11916 mapVar := parsedVal 11917 if err := awsAwsjson11_deserializeDocumentProductViewAggregationValues(&mapVar, value); err != nil { 11918 return err 11919 } 11920 parsedVal = mapVar 11921 mv[key] = parsedVal 11922 11923 } 11924 *v = mv 11925 return nil 11926} 11927 11928func awsAwsjson11_deserializeDocumentProductViewAggregationValue(v **types.ProductViewAggregationValue, value interface{}) error { 11929 if v == nil { 11930 return fmt.Errorf("unexpected nil of type %T", v) 11931 } 11932 if value == nil { 11933 return nil 11934 } 11935 11936 shape, ok := value.(map[string]interface{}) 11937 if !ok { 11938 return fmt.Errorf("unexpected JSON type %v", value) 11939 } 11940 11941 var sv *types.ProductViewAggregationValue 11942 if *v == nil { 11943 sv = &types.ProductViewAggregationValue{} 11944 } else { 11945 sv = *v 11946 } 11947 11948 for key, value := range shape { 11949 switch key { 11950 case "ApproximateCount": 11951 if value != nil { 11952 jtv, ok := value.(json.Number) 11953 if !ok { 11954 return fmt.Errorf("expected ApproximateCount to be json.Number, got %T instead", value) 11955 } 11956 i64, err := jtv.Int64() 11957 if err != nil { 11958 return err 11959 } 11960 sv.ApproximateCount = int32(i64) 11961 } 11962 11963 case "Value": 11964 if value != nil { 11965 jtv, ok := value.(string) 11966 if !ok { 11967 return fmt.Errorf("expected AttributeValue to be of type string, got %T instead", value) 11968 } 11969 sv.Value = ptr.String(jtv) 11970 } 11971 11972 default: 11973 _, _ = key, value 11974 11975 } 11976 } 11977 *v = sv 11978 return nil 11979} 11980 11981func awsAwsjson11_deserializeDocumentProductViewAggregationValues(v *[]types.ProductViewAggregationValue, value interface{}) error { 11982 if v == nil { 11983 return fmt.Errorf("unexpected nil of type %T", v) 11984 } 11985 if value == nil { 11986 return nil 11987 } 11988 11989 shape, ok := value.([]interface{}) 11990 if !ok { 11991 return fmt.Errorf("unexpected JSON type %v", value) 11992 } 11993 11994 var cv []types.ProductViewAggregationValue 11995 if *v == nil { 11996 cv = []types.ProductViewAggregationValue{} 11997 } else { 11998 cv = *v 11999 } 12000 12001 for _, value := range shape { 12002 var col types.ProductViewAggregationValue 12003 destAddr := &col 12004 if err := awsAwsjson11_deserializeDocumentProductViewAggregationValue(&destAddr, value); err != nil { 12005 return err 12006 } 12007 col = *destAddr 12008 cv = append(cv, col) 12009 12010 } 12011 *v = cv 12012 return nil 12013} 12014 12015func awsAwsjson11_deserializeDocumentProductViewDetail(v **types.ProductViewDetail, value interface{}) error { 12016 if v == nil { 12017 return fmt.Errorf("unexpected nil of type %T", v) 12018 } 12019 if value == nil { 12020 return nil 12021 } 12022 12023 shape, ok := value.(map[string]interface{}) 12024 if !ok { 12025 return fmt.Errorf("unexpected JSON type %v", value) 12026 } 12027 12028 var sv *types.ProductViewDetail 12029 if *v == nil { 12030 sv = &types.ProductViewDetail{} 12031 } else { 12032 sv = *v 12033 } 12034 12035 for key, value := range shape { 12036 switch key { 12037 case "CreatedTime": 12038 if value != nil { 12039 jtv, ok := value.(json.Number) 12040 if !ok { 12041 return fmt.Errorf("expected CreatedTime to be json.Number, got %T instead", value) 12042 } 12043 f64, err := jtv.Float64() 12044 if err != nil { 12045 return err 12046 } 12047 sv.CreatedTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 12048 } 12049 12050 case "ProductARN": 12051 if value != nil { 12052 jtv, ok := value.(string) 12053 if !ok { 12054 return fmt.Errorf("expected ResourceARN to be of type string, got %T instead", value) 12055 } 12056 sv.ProductARN = ptr.String(jtv) 12057 } 12058 12059 case "ProductViewSummary": 12060 if err := awsAwsjson11_deserializeDocumentProductViewSummary(&sv.ProductViewSummary, value); err != nil { 12061 return err 12062 } 12063 12064 case "Status": 12065 if value != nil { 12066 jtv, ok := value.(string) 12067 if !ok { 12068 return fmt.Errorf("expected Status to be of type string, got %T instead", value) 12069 } 12070 sv.Status = types.Status(jtv) 12071 } 12072 12073 default: 12074 _, _ = key, value 12075 12076 } 12077 } 12078 *v = sv 12079 return nil 12080} 12081 12082func awsAwsjson11_deserializeDocumentProductViewDetails(v *[]types.ProductViewDetail, value interface{}) error { 12083 if v == nil { 12084 return fmt.Errorf("unexpected nil of type %T", v) 12085 } 12086 if value == nil { 12087 return nil 12088 } 12089 12090 shape, ok := value.([]interface{}) 12091 if !ok { 12092 return fmt.Errorf("unexpected JSON type %v", value) 12093 } 12094 12095 var cv []types.ProductViewDetail 12096 if *v == nil { 12097 cv = []types.ProductViewDetail{} 12098 } else { 12099 cv = *v 12100 } 12101 12102 for _, value := range shape { 12103 var col types.ProductViewDetail 12104 destAddr := &col 12105 if err := awsAwsjson11_deserializeDocumentProductViewDetail(&destAddr, value); err != nil { 12106 return err 12107 } 12108 col = *destAddr 12109 cv = append(cv, col) 12110 12111 } 12112 *v = cv 12113 return nil 12114} 12115 12116func awsAwsjson11_deserializeDocumentProductViewSummaries(v *[]types.ProductViewSummary, value interface{}) error { 12117 if v == nil { 12118 return fmt.Errorf("unexpected nil of type %T", v) 12119 } 12120 if value == nil { 12121 return nil 12122 } 12123 12124 shape, ok := value.([]interface{}) 12125 if !ok { 12126 return fmt.Errorf("unexpected JSON type %v", value) 12127 } 12128 12129 var cv []types.ProductViewSummary 12130 if *v == nil { 12131 cv = []types.ProductViewSummary{} 12132 } else { 12133 cv = *v 12134 } 12135 12136 for _, value := range shape { 12137 var col types.ProductViewSummary 12138 destAddr := &col 12139 if err := awsAwsjson11_deserializeDocumentProductViewSummary(&destAddr, value); err != nil { 12140 return err 12141 } 12142 col = *destAddr 12143 cv = append(cv, col) 12144 12145 } 12146 *v = cv 12147 return nil 12148} 12149 12150func awsAwsjson11_deserializeDocumentProductViewSummary(v **types.ProductViewSummary, 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 *types.ProductViewSummary 12164 if *v == nil { 12165 sv = &types.ProductViewSummary{} 12166 } else { 12167 sv = *v 12168 } 12169 12170 for key, value := range shape { 12171 switch key { 12172 case "Distributor": 12173 if value != nil { 12174 jtv, ok := value.(string) 12175 if !ok { 12176 return fmt.Errorf("expected ProductViewDistributor to be of type string, got %T instead", value) 12177 } 12178 sv.Distributor = ptr.String(jtv) 12179 } 12180 12181 case "HasDefaultPath": 12182 if value != nil { 12183 jtv, ok := value.(bool) 12184 if !ok { 12185 return fmt.Errorf("expected HasDefaultPath to be of type *bool, got %T instead", value) 12186 } 12187 sv.HasDefaultPath = jtv 12188 } 12189 12190 case "Id": 12191 if value != nil { 12192 jtv, ok := value.(string) 12193 if !ok { 12194 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 12195 } 12196 sv.Id = ptr.String(jtv) 12197 } 12198 12199 case "Name": 12200 if value != nil { 12201 jtv, ok := value.(string) 12202 if !ok { 12203 return fmt.Errorf("expected ProductViewName to be of type string, got %T instead", value) 12204 } 12205 sv.Name = ptr.String(jtv) 12206 } 12207 12208 case "Owner": 12209 if value != nil { 12210 jtv, ok := value.(string) 12211 if !ok { 12212 return fmt.Errorf("expected ProductViewOwner to be of type string, got %T instead", value) 12213 } 12214 sv.Owner = ptr.String(jtv) 12215 } 12216 12217 case "ProductId": 12218 if value != nil { 12219 jtv, ok := value.(string) 12220 if !ok { 12221 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 12222 } 12223 sv.ProductId = ptr.String(jtv) 12224 } 12225 12226 case "ShortDescription": 12227 if value != nil { 12228 jtv, ok := value.(string) 12229 if !ok { 12230 return fmt.Errorf("expected ProductViewShortDescription to be of type string, got %T instead", value) 12231 } 12232 sv.ShortDescription = ptr.String(jtv) 12233 } 12234 12235 case "SupportDescription": 12236 if value != nil { 12237 jtv, ok := value.(string) 12238 if !ok { 12239 return fmt.Errorf("expected SupportDescription to be of type string, got %T instead", value) 12240 } 12241 sv.SupportDescription = ptr.String(jtv) 12242 } 12243 12244 case "SupportEmail": 12245 if value != nil { 12246 jtv, ok := value.(string) 12247 if !ok { 12248 return fmt.Errorf("expected SupportEmail to be of type string, got %T instead", value) 12249 } 12250 sv.SupportEmail = ptr.String(jtv) 12251 } 12252 12253 case "SupportUrl": 12254 if value != nil { 12255 jtv, ok := value.(string) 12256 if !ok { 12257 return fmt.Errorf("expected SupportUrl to be of type string, got %T instead", value) 12258 } 12259 sv.SupportUrl = ptr.String(jtv) 12260 } 12261 12262 case "Type": 12263 if value != nil { 12264 jtv, ok := value.(string) 12265 if !ok { 12266 return fmt.Errorf("expected ProductType to be of type string, got %T instead", value) 12267 } 12268 sv.Type = types.ProductType(jtv) 12269 } 12270 12271 default: 12272 _, _ = key, value 12273 12274 } 12275 } 12276 *v = sv 12277 return nil 12278} 12279 12280func awsAwsjson11_deserializeDocumentProvisionedProductAttribute(v **types.ProvisionedProductAttribute, value interface{}) error { 12281 if v == nil { 12282 return fmt.Errorf("unexpected nil of type %T", v) 12283 } 12284 if value == nil { 12285 return nil 12286 } 12287 12288 shape, ok := value.(map[string]interface{}) 12289 if !ok { 12290 return fmt.Errorf("unexpected JSON type %v", value) 12291 } 12292 12293 var sv *types.ProvisionedProductAttribute 12294 if *v == nil { 12295 sv = &types.ProvisionedProductAttribute{} 12296 } else { 12297 sv = *v 12298 } 12299 12300 for key, value := range shape { 12301 switch key { 12302 case "Arn": 12303 if value != nil { 12304 jtv, ok := value.(string) 12305 if !ok { 12306 return fmt.Errorf("expected ProvisionedProductNameOrArn to be of type string, got %T instead", value) 12307 } 12308 sv.Arn = ptr.String(jtv) 12309 } 12310 12311 case "CreatedTime": 12312 if value != nil { 12313 jtv, ok := value.(json.Number) 12314 if !ok { 12315 return fmt.Errorf("expected CreatedTime to be json.Number, got %T instead", value) 12316 } 12317 f64, err := jtv.Float64() 12318 if err != nil { 12319 return err 12320 } 12321 sv.CreatedTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 12322 } 12323 12324 case "Id": 12325 if value != nil { 12326 jtv, ok := value.(string) 12327 if !ok { 12328 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 12329 } 12330 sv.Id = ptr.String(jtv) 12331 } 12332 12333 case "IdempotencyToken": 12334 if value != nil { 12335 jtv, ok := value.(string) 12336 if !ok { 12337 return fmt.Errorf("expected IdempotencyToken to be of type string, got %T instead", value) 12338 } 12339 sv.IdempotencyToken = ptr.String(jtv) 12340 } 12341 12342 case "LastProvisioningRecordId": 12343 if value != nil { 12344 jtv, ok := value.(string) 12345 if !ok { 12346 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 12347 } 12348 sv.LastProvisioningRecordId = ptr.String(jtv) 12349 } 12350 12351 case "LastRecordId": 12352 if value != nil { 12353 jtv, ok := value.(string) 12354 if !ok { 12355 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 12356 } 12357 sv.LastRecordId = ptr.String(jtv) 12358 } 12359 12360 case "LastSuccessfulProvisioningRecordId": 12361 if value != nil { 12362 jtv, ok := value.(string) 12363 if !ok { 12364 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 12365 } 12366 sv.LastSuccessfulProvisioningRecordId = ptr.String(jtv) 12367 } 12368 12369 case "Name": 12370 if value != nil { 12371 jtv, ok := value.(string) 12372 if !ok { 12373 return fmt.Errorf("expected ProvisionedProductNameOrArn to be of type string, got %T instead", value) 12374 } 12375 sv.Name = ptr.String(jtv) 12376 } 12377 12378 case "PhysicalId": 12379 if value != nil { 12380 jtv, ok := value.(string) 12381 if !ok { 12382 return fmt.Errorf("expected PhysicalId to be of type string, got %T instead", value) 12383 } 12384 sv.PhysicalId = ptr.String(jtv) 12385 } 12386 12387 case "ProductId": 12388 if value != nil { 12389 jtv, ok := value.(string) 12390 if !ok { 12391 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 12392 } 12393 sv.ProductId = ptr.String(jtv) 12394 } 12395 12396 case "ProductName": 12397 if value != nil { 12398 jtv, ok := value.(string) 12399 if !ok { 12400 return fmt.Errorf("expected ProductViewName to be of type string, got %T instead", value) 12401 } 12402 sv.ProductName = ptr.String(jtv) 12403 } 12404 12405 case "ProvisioningArtifactId": 12406 if value != nil { 12407 jtv, ok := value.(string) 12408 if !ok { 12409 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 12410 } 12411 sv.ProvisioningArtifactId = ptr.String(jtv) 12412 } 12413 12414 case "ProvisioningArtifactName": 12415 if value != nil { 12416 jtv, ok := value.(string) 12417 if !ok { 12418 return fmt.Errorf("expected ProvisioningArtifactName to be of type string, got %T instead", value) 12419 } 12420 sv.ProvisioningArtifactName = ptr.String(jtv) 12421 } 12422 12423 case "Status": 12424 if value != nil { 12425 jtv, ok := value.(string) 12426 if !ok { 12427 return fmt.Errorf("expected ProvisionedProductStatus to be of type string, got %T instead", value) 12428 } 12429 sv.Status = types.ProvisionedProductStatus(jtv) 12430 } 12431 12432 case "StatusMessage": 12433 if value != nil { 12434 jtv, ok := value.(string) 12435 if !ok { 12436 return fmt.Errorf("expected ProvisionedProductStatusMessage to be of type string, got %T instead", value) 12437 } 12438 sv.StatusMessage = ptr.String(jtv) 12439 } 12440 12441 case "Tags": 12442 if err := awsAwsjson11_deserializeDocumentTags(&sv.Tags, value); err != nil { 12443 return err 12444 } 12445 12446 case "Type": 12447 if value != nil { 12448 jtv, ok := value.(string) 12449 if !ok { 12450 return fmt.Errorf("expected ProvisionedProductType to be of type string, got %T instead", value) 12451 } 12452 sv.Type = ptr.String(jtv) 12453 } 12454 12455 case "UserArn": 12456 if value != nil { 12457 jtv, ok := value.(string) 12458 if !ok { 12459 return fmt.Errorf("expected UserArn to be of type string, got %T instead", value) 12460 } 12461 sv.UserArn = ptr.String(jtv) 12462 } 12463 12464 case "UserArnSession": 12465 if value != nil { 12466 jtv, ok := value.(string) 12467 if !ok { 12468 return fmt.Errorf("expected UserArnSession to be of type string, got %T instead", value) 12469 } 12470 sv.UserArnSession = ptr.String(jtv) 12471 } 12472 12473 default: 12474 _, _ = key, value 12475 12476 } 12477 } 12478 *v = sv 12479 return nil 12480} 12481 12482func awsAwsjson11_deserializeDocumentProvisionedProductAttributes(v *[]types.ProvisionedProductAttribute, value interface{}) error { 12483 if v == nil { 12484 return fmt.Errorf("unexpected nil of type %T", v) 12485 } 12486 if value == nil { 12487 return nil 12488 } 12489 12490 shape, ok := value.([]interface{}) 12491 if !ok { 12492 return fmt.Errorf("unexpected JSON type %v", value) 12493 } 12494 12495 var cv []types.ProvisionedProductAttribute 12496 if *v == nil { 12497 cv = []types.ProvisionedProductAttribute{} 12498 } else { 12499 cv = *v 12500 } 12501 12502 for _, value := range shape { 12503 var col types.ProvisionedProductAttribute 12504 destAddr := &col 12505 if err := awsAwsjson11_deserializeDocumentProvisionedProductAttribute(&destAddr, value); err != nil { 12506 return err 12507 } 12508 col = *destAddr 12509 cv = append(cv, col) 12510 12511 } 12512 *v = cv 12513 return nil 12514} 12515 12516func awsAwsjson11_deserializeDocumentProvisionedProductDetail(v **types.ProvisionedProductDetail, value interface{}) error { 12517 if v == nil { 12518 return fmt.Errorf("unexpected nil of type %T", v) 12519 } 12520 if value == nil { 12521 return nil 12522 } 12523 12524 shape, ok := value.(map[string]interface{}) 12525 if !ok { 12526 return fmt.Errorf("unexpected JSON type %v", value) 12527 } 12528 12529 var sv *types.ProvisionedProductDetail 12530 if *v == nil { 12531 sv = &types.ProvisionedProductDetail{} 12532 } else { 12533 sv = *v 12534 } 12535 12536 for key, value := range shape { 12537 switch key { 12538 case "Arn": 12539 if value != nil { 12540 jtv, ok := value.(string) 12541 if !ok { 12542 return fmt.Errorf("expected ProvisionedProductNameOrArn to be of type string, got %T instead", value) 12543 } 12544 sv.Arn = ptr.String(jtv) 12545 } 12546 12547 case "CreatedTime": 12548 if value != nil { 12549 jtv, ok := value.(json.Number) 12550 if !ok { 12551 return fmt.Errorf("expected CreatedTime to be json.Number, got %T instead", value) 12552 } 12553 f64, err := jtv.Float64() 12554 if err != nil { 12555 return err 12556 } 12557 sv.CreatedTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 12558 } 12559 12560 case "Id": 12561 if value != nil { 12562 jtv, ok := value.(string) 12563 if !ok { 12564 return fmt.Errorf("expected ProvisionedProductId to be of type string, got %T instead", value) 12565 } 12566 sv.Id = ptr.String(jtv) 12567 } 12568 12569 case "IdempotencyToken": 12570 if value != nil { 12571 jtv, ok := value.(string) 12572 if !ok { 12573 return fmt.Errorf("expected IdempotencyToken to be of type string, got %T instead", value) 12574 } 12575 sv.IdempotencyToken = ptr.String(jtv) 12576 } 12577 12578 case "LastProvisioningRecordId": 12579 if value != nil { 12580 jtv, ok := value.(string) 12581 if !ok { 12582 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 12583 } 12584 sv.LastProvisioningRecordId = ptr.String(jtv) 12585 } 12586 12587 case "LastRecordId": 12588 if value != nil { 12589 jtv, ok := value.(string) 12590 if !ok { 12591 return fmt.Errorf("expected LastRequestId to be of type string, got %T instead", value) 12592 } 12593 sv.LastRecordId = ptr.String(jtv) 12594 } 12595 12596 case "LastSuccessfulProvisioningRecordId": 12597 if value != nil { 12598 jtv, ok := value.(string) 12599 if !ok { 12600 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 12601 } 12602 sv.LastSuccessfulProvisioningRecordId = ptr.String(jtv) 12603 } 12604 12605 case "LaunchRoleArn": 12606 if value != nil { 12607 jtv, ok := value.(string) 12608 if !ok { 12609 return fmt.Errorf("expected RoleArn to be of type string, got %T instead", value) 12610 } 12611 sv.LaunchRoleArn = ptr.String(jtv) 12612 } 12613 12614 case "Name": 12615 if value != nil { 12616 jtv, ok := value.(string) 12617 if !ok { 12618 return fmt.Errorf("expected ProvisionedProductNameOrArn to be of type string, got %T instead", value) 12619 } 12620 sv.Name = ptr.String(jtv) 12621 } 12622 12623 case "ProductId": 12624 if value != nil { 12625 jtv, ok := value.(string) 12626 if !ok { 12627 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 12628 } 12629 sv.ProductId = ptr.String(jtv) 12630 } 12631 12632 case "ProvisioningArtifactId": 12633 if value != nil { 12634 jtv, ok := value.(string) 12635 if !ok { 12636 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 12637 } 12638 sv.ProvisioningArtifactId = ptr.String(jtv) 12639 } 12640 12641 case "Status": 12642 if value != nil { 12643 jtv, ok := value.(string) 12644 if !ok { 12645 return fmt.Errorf("expected ProvisionedProductStatus to be of type string, got %T instead", value) 12646 } 12647 sv.Status = types.ProvisionedProductStatus(jtv) 12648 } 12649 12650 case "StatusMessage": 12651 if value != nil { 12652 jtv, ok := value.(string) 12653 if !ok { 12654 return fmt.Errorf("expected ProvisionedProductStatusMessage to be of type string, got %T instead", value) 12655 } 12656 sv.StatusMessage = ptr.String(jtv) 12657 } 12658 12659 case "Type": 12660 if value != nil { 12661 jtv, ok := value.(string) 12662 if !ok { 12663 return fmt.Errorf("expected ProvisionedProductType to be of type string, got %T instead", value) 12664 } 12665 sv.Type = ptr.String(jtv) 12666 } 12667 12668 default: 12669 _, _ = key, value 12670 12671 } 12672 } 12673 *v = sv 12674 return nil 12675} 12676 12677func awsAwsjson11_deserializeDocumentProvisionedProductDetails(v *[]types.ProvisionedProductDetail, value interface{}) error { 12678 if v == nil { 12679 return fmt.Errorf("unexpected nil of type %T", v) 12680 } 12681 if value == nil { 12682 return nil 12683 } 12684 12685 shape, ok := value.([]interface{}) 12686 if !ok { 12687 return fmt.Errorf("unexpected JSON type %v", value) 12688 } 12689 12690 var cv []types.ProvisionedProductDetail 12691 if *v == nil { 12692 cv = []types.ProvisionedProductDetail{} 12693 } else { 12694 cv = *v 12695 } 12696 12697 for _, value := range shape { 12698 var col types.ProvisionedProductDetail 12699 destAddr := &col 12700 if err := awsAwsjson11_deserializeDocumentProvisionedProductDetail(&destAddr, value); err != nil { 12701 return err 12702 } 12703 col = *destAddr 12704 cv = append(cv, col) 12705 12706 } 12707 *v = cv 12708 return nil 12709} 12710 12711func awsAwsjson11_deserializeDocumentProvisionedProductPlanDetails(v **types.ProvisionedProductPlanDetails, value interface{}) error { 12712 if v == nil { 12713 return fmt.Errorf("unexpected nil of type %T", v) 12714 } 12715 if value == nil { 12716 return nil 12717 } 12718 12719 shape, ok := value.(map[string]interface{}) 12720 if !ok { 12721 return fmt.Errorf("unexpected JSON type %v", value) 12722 } 12723 12724 var sv *types.ProvisionedProductPlanDetails 12725 if *v == nil { 12726 sv = &types.ProvisionedProductPlanDetails{} 12727 } else { 12728 sv = *v 12729 } 12730 12731 for key, value := range shape { 12732 switch key { 12733 case "CreatedTime": 12734 if value != nil { 12735 jtv, ok := value.(json.Number) 12736 if !ok { 12737 return fmt.Errorf("expected CreatedTime to be json.Number, got %T instead", value) 12738 } 12739 f64, err := jtv.Float64() 12740 if err != nil { 12741 return err 12742 } 12743 sv.CreatedTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 12744 } 12745 12746 case "NotificationArns": 12747 if err := awsAwsjson11_deserializeDocumentNotificationArns(&sv.NotificationArns, value); err != nil { 12748 return err 12749 } 12750 12751 case "PathId": 12752 if value != nil { 12753 jtv, ok := value.(string) 12754 if !ok { 12755 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 12756 } 12757 sv.PathId = ptr.String(jtv) 12758 } 12759 12760 case "PlanId": 12761 if value != nil { 12762 jtv, ok := value.(string) 12763 if !ok { 12764 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 12765 } 12766 sv.PlanId = ptr.String(jtv) 12767 } 12768 12769 case "PlanName": 12770 if value != nil { 12771 jtv, ok := value.(string) 12772 if !ok { 12773 return fmt.Errorf("expected ProvisionedProductPlanName to be of type string, got %T instead", value) 12774 } 12775 sv.PlanName = ptr.String(jtv) 12776 } 12777 12778 case "PlanType": 12779 if value != nil { 12780 jtv, ok := value.(string) 12781 if !ok { 12782 return fmt.Errorf("expected ProvisionedProductPlanType to be of type string, got %T instead", value) 12783 } 12784 sv.PlanType = types.ProvisionedProductPlanType(jtv) 12785 } 12786 12787 case "ProductId": 12788 if value != nil { 12789 jtv, ok := value.(string) 12790 if !ok { 12791 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 12792 } 12793 sv.ProductId = ptr.String(jtv) 12794 } 12795 12796 case "ProvisioningArtifactId": 12797 if value != nil { 12798 jtv, ok := value.(string) 12799 if !ok { 12800 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 12801 } 12802 sv.ProvisioningArtifactId = ptr.String(jtv) 12803 } 12804 12805 case "ProvisioningParameters": 12806 if err := awsAwsjson11_deserializeDocumentUpdateProvisioningParameters(&sv.ProvisioningParameters, value); err != nil { 12807 return err 12808 } 12809 12810 case "ProvisionProductId": 12811 if value != nil { 12812 jtv, ok := value.(string) 12813 if !ok { 12814 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 12815 } 12816 sv.ProvisionProductId = ptr.String(jtv) 12817 } 12818 12819 case "ProvisionProductName": 12820 if value != nil { 12821 jtv, ok := value.(string) 12822 if !ok { 12823 return fmt.Errorf("expected ProvisionedProductName to be of type string, got %T instead", value) 12824 } 12825 sv.ProvisionProductName = ptr.String(jtv) 12826 } 12827 12828 case "Status": 12829 if value != nil { 12830 jtv, ok := value.(string) 12831 if !ok { 12832 return fmt.Errorf("expected ProvisionedProductPlanStatus to be of type string, got %T instead", value) 12833 } 12834 sv.Status = types.ProvisionedProductPlanStatus(jtv) 12835 } 12836 12837 case "StatusMessage": 12838 if value != nil { 12839 jtv, ok := value.(string) 12840 if !ok { 12841 return fmt.Errorf("expected StatusMessage to be of type string, got %T instead", value) 12842 } 12843 sv.StatusMessage = ptr.String(jtv) 12844 } 12845 12846 case "Tags": 12847 if err := awsAwsjson11_deserializeDocumentTags(&sv.Tags, value); err != nil { 12848 return err 12849 } 12850 12851 case "UpdatedTime": 12852 if value != nil { 12853 jtv, ok := value.(json.Number) 12854 if !ok { 12855 return fmt.Errorf("expected UpdatedTime to be json.Number, got %T instead", value) 12856 } 12857 f64, err := jtv.Float64() 12858 if err != nil { 12859 return err 12860 } 12861 sv.UpdatedTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 12862 } 12863 12864 default: 12865 _, _ = key, value 12866 12867 } 12868 } 12869 *v = sv 12870 return nil 12871} 12872 12873func awsAwsjson11_deserializeDocumentProvisionedProductPlans(v *[]types.ProvisionedProductPlanSummary, value interface{}) error { 12874 if v == nil { 12875 return fmt.Errorf("unexpected nil of type %T", v) 12876 } 12877 if value == nil { 12878 return nil 12879 } 12880 12881 shape, ok := value.([]interface{}) 12882 if !ok { 12883 return fmt.Errorf("unexpected JSON type %v", value) 12884 } 12885 12886 var cv []types.ProvisionedProductPlanSummary 12887 if *v == nil { 12888 cv = []types.ProvisionedProductPlanSummary{} 12889 } else { 12890 cv = *v 12891 } 12892 12893 for _, value := range shape { 12894 var col types.ProvisionedProductPlanSummary 12895 destAddr := &col 12896 if err := awsAwsjson11_deserializeDocumentProvisionedProductPlanSummary(&destAddr, value); err != nil { 12897 return err 12898 } 12899 col = *destAddr 12900 cv = append(cv, col) 12901 12902 } 12903 *v = cv 12904 return nil 12905} 12906 12907func awsAwsjson11_deserializeDocumentProvisionedProductPlanSummary(v **types.ProvisionedProductPlanSummary, value interface{}) error { 12908 if v == nil { 12909 return fmt.Errorf("unexpected nil of type %T", v) 12910 } 12911 if value == nil { 12912 return nil 12913 } 12914 12915 shape, ok := value.(map[string]interface{}) 12916 if !ok { 12917 return fmt.Errorf("unexpected JSON type %v", value) 12918 } 12919 12920 var sv *types.ProvisionedProductPlanSummary 12921 if *v == nil { 12922 sv = &types.ProvisionedProductPlanSummary{} 12923 } else { 12924 sv = *v 12925 } 12926 12927 for key, value := range shape { 12928 switch key { 12929 case "PlanId": 12930 if value != nil { 12931 jtv, ok := value.(string) 12932 if !ok { 12933 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 12934 } 12935 sv.PlanId = ptr.String(jtv) 12936 } 12937 12938 case "PlanName": 12939 if value != nil { 12940 jtv, ok := value.(string) 12941 if !ok { 12942 return fmt.Errorf("expected ProvisionedProductPlanName to be of type string, got %T instead", value) 12943 } 12944 sv.PlanName = ptr.String(jtv) 12945 } 12946 12947 case "PlanType": 12948 if value != nil { 12949 jtv, ok := value.(string) 12950 if !ok { 12951 return fmt.Errorf("expected ProvisionedProductPlanType to be of type string, got %T instead", value) 12952 } 12953 sv.PlanType = types.ProvisionedProductPlanType(jtv) 12954 } 12955 12956 case "ProvisioningArtifactId": 12957 if value != nil { 12958 jtv, ok := value.(string) 12959 if !ok { 12960 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 12961 } 12962 sv.ProvisioningArtifactId = ptr.String(jtv) 12963 } 12964 12965 case "ProvisionProductId": 12966 if value != nil { 12967 jtv, ok := value.(string) 12968 if !ok { 12969 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 12970 } 12971 sv.ProvisionProductId = ptr.String(jtv) 12972 } 12973 12974 case "ProvisionProductName": 12975 if value != nil { 12976 jtv, ok := value.(string) 12977 if !ok { 12978 return fmt.Errorf("expected ProvisionedProductName to be of type string, got %T instead", value) 12979 } 12980 sv.ProvisionProductName = ptr.String(jtv) 12981 } 12982 12983 default: 12984 _, _ = key, value 12985 12986 } 12987 } 12988 *v = sv 12989 return nil 12990} 12991 12992func awsAwsjson11_deserializeDocumentProvisionedProductProperties(v *map[string]string, value interface{}) error { 12993 if v == nil { 12994 return fmt.Errorf("unexpected nil of type %T", v) 12995 } 12996 if value == nil { 12997 return nil 12998 } 12999 13000 shape, ok := value.(map[string]interface{}) 13001 if !ok { 13002 return fmt.Errorf("unexpected JSON type %v", value) 13003 } 13004 13005 var mv map[string]string 13006 if *v == nil { 13007 mv = map[string]string{} 13008 } else { 13009 mv = *v 13010 } 13011 13012 for key, value := range shape { 13013 var parsedVal string 13014 if value != nil { 13015 jtv, ok := value.(string) 13016 if !ok { 13017 return fmt.Errorf("expected PropertyValue to be of type string, got %T instead", value) 13018 } 13019 parsedVal = jtv 13020 } 13021 mv[key] = parsedVal 13022 13023 } 13024 *v = mv 13025 return nil 13026} 13027 13028func awsAwsjson11_deserializeDocumentProvisioningArtifact(v **types.ProvisioningArtifact, value interface{}) error { 13029 if v == nil { 13030 return fmt.Errorf("unexpected nil of type %T", v) 13031 } 13032 if value == nil { 13033 return nil 13034 } 13035 13036 shape, ok := value.(map[string]interface{}) 13037 if !ok { 13038 return fmt.Errorf("unexpected JSON type %v", value) 13039 } 13040 13041 var sv *types.ProvisioningArtifact 13042 if *v == nil { 13043 sv = &types.ProvisioningArtifact{} 13044 } else { 13045 sv = *v 13046 } 13047 13048 for key, value := range shape { 13049 switch key { 13050 case "CreatedTime": 13051 if value != nil { 13052 jtv, ok := value.(json.Number) 13053 if !ok { 13054 return fmt.Errorf("expected ProvisioningArtifactCreatedTime to be json.Number, got %T instead", value) 13055 } 13056 f64, err := jtv.Float64() 13057 if err != nil { 13058 return err 13059 } 13060 sv.CreatedTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 13061 } 13062 13063 case "Description": 13064 if value != nil { 13065 jtv, ok := value.(string) 13066 if !ok { 13067 return fmt.Errorf("expected ProvisioningArtifactDescription to be of type string, got %T instead", value) 13068 } 13069 sv.Description = ptr.String(jtv) 13070 } 13071 13072 case "Guidance": 13073 if value != nil { 13074 jtv, ok := value.(string) 13075 if !ok { 13076 return fmt.Errorf("expected ProvisioningArtifactGuidance to be of type string, got %T instead", value) 13077 } 13078 sv.Guidance = types.ProvisioningArtifactGuidance(jtv) 13079 } 13080 13081 case "Id": 13082 if value != nil { 13083 jtv, ok := value.(string) 13084 if !ok { 13085 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 13086 } 13087 sv.Id = ptr.String(jtv) 13088 } 13089 13090 case "Name": 13091 if value != nil { 13092 jtv, ok := value.(string) 13093 if !ok { 13094 return fmt.Errorf("expected ProvisioningArtifactName to be of type string, got %T instead", value) 13095 } 13096 sv.Name = ptr.String(jtv) 13097 } 13098 13099 default: 13100 _, _ = key, value 13101 13102 } 13103 } 13104 *v = sv 13105 return nil 13106} 13107 13108func awsAwsjson11_deserializeDocumentProvisioningArtifactDetail(v **types.ProvisioningArtifactDetail, value interface{}) error { 13109 if v == nil { 13110 return fmt.Errorf("unexpected nil of type %T", v) 13111 } 13112 if value == nil { 13113 return nil 13114 } 13115 13116 shape, ok := value.(map[string]interface{}) 13117 if !ok { 13118 return fmt.Errorf("unexpected JSON type %v", value) 13119 } 13120 13121 var sv *types.ProvisioningArtifactDetail 13122 if *v == nil { 13123 sv = &types.ProvisioningArtifactDetail{} 13124 } else { 13125 sv = *v 13126 } 13127 13128 for key, value := range shape { 13129 switch key { 13130 case "Active": 13131 if value != nil { 13132 jtv, ok := value.(bool) 13133 if !ok { 13134 return fmt.Errorf("expected ProvisioningArtifactActive to be of type *bool, got %T instead", value) 13135 } 13136 sv.Active = ptr.Bool(jtv) 13137 } 13138 13139 case "CreatedTime": 13140 if value != nil { 13141 jtv, ok := value.(json.Number) 13142 if !ok { 13143 return fmt.Errorf("expected CreationTime to be json.Number, got %T instead", value) 13144 } 13145 f64, err := jtv.Float64() 13146 if err != nil { 13147 return err 13148 } 13149 sv.CreatedTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 13150 } 13151 13152 case "Description": 13153 if value != nil { 13154 jtv, ok := value.(string) 13155 if !ok { 13156 return fmt.Errorf("expected ProvisioningArtifactName to be of type string, got %T instead", value) 13157 } 13158 sv.Description = ptr.String(jtv) 13159 } 13160 13161 case "Guidance": 13162 if value != nil { 13163 jtv, ok := value.(string) 13164 if !ok { 13165 return fmt.Errorf("expected ProvisioningArtifactGuidance to be of type string, got %T instead", value) 13166 } 13167 sv.Guidance = types.ProvisioningArtifactGuidance(jtv) 13168 } 13169 13170 case "Id": 13171 if value != nil { 13172 jtv, ok := value.(string) 13173 if !ok { 13174 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 13175 } 13176 sv.Id = ptr.String(jtv) 13177 } 13178 13179 case "Name": 13180 if value != nil { 13181 jtv, ok := value.(string) 13182 if !ok { 13183 return fmt.Errorf("expected ProvisioningArtifactName to be of type string, got %T instead", value) 13184 } 13185 sv.Name = ptr.String(jtv) 13186 } 13187 13188 case "Type": 13189 if value != nil { 13190 jtv, ok := value.(string) 13191 if !ok { 13192 return fmt.Errorf("expected ProvisioningArtifactType to be of type string, got %T instead", value) 13193 } 13194 sv.Type = types.ProvisioningArtifactType(jtv) 13195 } 13196 13197 default: 13198 _, _ = key, value 13199 13200 } 13201 } 13202 *v = sv 13203 return nil 13204} 13205 13206func awsAwsjson11_deserializeDocumentProvisioningArtifactDetails(v *[]types.ProvisioningArtifactDetail, value interface{}) error { 13207 if v == nil { 13208 return fmt.Errorf("unexpected nil of type %T", v) 13209 } 13210 if value == nil { 13211 return nil 13212 } 13213 13214 shape, ok := value.([]interface{}) 13215 if !ok { 13216 return fmt.Errorf("unexpected JSON type %v", value) 13217 } 13218 13219 var cv []types.ProvisioningArtifactDetail 13220 if *v == nil { 13221 cv = []types.ProvisioningArtifactDetail{} 13222 } else { 13223 cv = *v 13224 } 13225 13226 for _, value := range shape { 13227 var col types.ProvisioningArtifactDetail 13228 destAddr := &col 13229 if err := awsAwsjson11_deserializeDocumentProvisioningArtifactDetail(&destAddr, value); err != nil { 13230 return err 13231 } 13232 col = *destAddr 13233 cv = append(cv, col) 13234 13235 } 13236 *v = cv 13237 return nil 13238} 13239 13240func awsAwsjson11_deserializeDocumentProvisioningArtifactInfo(v *map[string]string, value interface{}) error { 13241 if v == nil { 13242 return fmt.Errorf("unexpected nil of type %T", v) 13243 } 13244 if value == nil { 13245 return nil 13246 } 13247 13248 shape, ok := value.(map[string]interface{}) 13249 if !ok { 13250 return fmt.Errorf("unexpected JSON type %v", value) 13251 } 13252 13253 var mv map[string]string 13254 if *v == nil { 13255 mv = map[string]string{} 13256 } else { 13257 mv = *v 13258 } 13259 13260 for key, value := range shape { 13261 var parsedVal string 13262 if value != nil { 13263 jtv, ok := value.(string) 13264 if !ok { 13265 return fmt.Errorf("expected ProvisioningArtifactInfoValue to be of type string, got %T instead", value) 13266 } 13267 parsedVal = jtv 13268 } 13269 mv[key] = parsedVal 13270 13271 } 13272 *v = mv 13273 return nil 13274} 13275 13276func awsAwsjson11_deserializeDocumentProvisioningArtifactOutput(v **types.ProvisioningArtifactOutput, value interface{}) error { 13277 if v == nil { 13278 return fmt.Errorf("unexpected nil of type %T", v) 13279 } 13280 if value == nil { 13281 return nil 13282 } 13283 13284 shape, ok := value.(map[string]interface{}) 13285 if !ok { 13286 return fmt.Errorf("unexpected JSON type %v", value) 13287 } 13288 13289 var sv *types.ProvisioningArtifactOutput 13290 if *v == nil { 13291 sv = &types.ProvisioningArtifactOutput{} 13292 } else { 13293 sv = *v 13294 } 13295 13296 for key, value := range shape { 13297 switch key { 13298 case "Description": 13299 if value != nil { 13300 jtv, ok := value.(string) 13301 if !ok { 13302 return fmt.Errorf("expected OutputDescription to be of type string, got %T instead", value) 13303 } 13304 sv.Description = ptr.String(jtv) 13305 } 13306 13307 case "Key": 13308 if value != nil { 13309 jtv, ok := value.(string) 13310 if !ok { 13311 return fmt.Errorf("expected ProvisioningArtifactOutputKey to be of type string, got %T instead", value) 13312 } 13313 sv.Key = ptr.String(jtv) 13314 } 13315 13316 default: 13317 _, _ = key, value 13318 13319 } 13320 } 13321 *v = sv 13322 return nil 13323} 13324 13325func awsAwsjson11_deserializeDocumentProvisioningArtifactOutputs(v *[]types.ProvisioningArtifactOutput, value interface{}) error { 13326 if v == nil { 13327 return fmt.Errorf("unexpected nil of type %T", v) 13328 } 13329 if value == nil { 13330 return nil 13331 } 13332 13333 shape, ok := value.([]interface{}) 13334 if !ok { 13335 return fmt.Errorf("unexpected JSON type %v", value) 13336 } 13337 13338 var cv []types.ProvisioningArtifactOutput 13339 if *v == nil { 13340 cv = []types.ProvisioningArtifactOutput{} 13341 } else { 13342 cv = *v 13343 } 13344 13345 for _, value := range shape { 13346 var col types.ProvisioningArtifactOutput 13347 destAddr := &col 13348 if err := awsAwsjson11_deserializeDocumentProvisioningArtifactOutput(&destAddr, value); err != nil { 13349 return err 13350 } 13351 col = *destAddr 13352 cv = append(cv, col) 13353 13354 } 13355 *v = cv 13356 return nil 13357} 13358 13359func awsAwsjson11_deserializeDocumentProvisioningArtifactParameter(v **types.ProvisioningArtifactParameter, value interface{}) error { 13360 if v == nil { 13361 return fmt.Errorf("unexpected nil of type %T", v) 13362 } 13363 if value == nil { 13364 return nil 13365 } 13366 13367 shape, ok := value.(map[string]interface{}) 13368 if !ok { 13369 return fmt.Errorf("unexpected JSON type %v", value) 13370 } 13371 13372 var sv *types.ProvisioningArtifactParameter 13373 if *v == nil { 13374 sv = &types.ProvisioningArtifactParameter{} 13375 } else { 13376 sv = *v 13377 } 13378 13379 for key, value := range shape { 13380 switch key { 13381 case "DefaultValue": 13382 if value != nil { 13383 jtv, ok := value.(string) 13384 if !ok { 13385 return fmt.Errorf("expected DefaultValue to be of type string, got %T instead", value) 13386 } 13387 sv.DefaultValue = ptr.String(jtv) 13388 } 13389 13390 case "Description": 13391 if value != nil { 13392 jtv, ok := value.(string) 13393 if !ok { 13394 return fmt.Errorf("expected Description to be of type string, got %T instead", value) 13395 } 13396 sv.Description = ptr.String(jtv) 13397 } 13398 13399 case "IsNoEcho": 13400 if value != nil { 13401 jtv, ok := value.(bool) 13402 if !ok { 13403 return fmt.Errorf("expected NoEcho to be of type *bool, got %T instead", value) 13404 } 13405 sv.IsNoEcho = jtv 13406 } 13407 13408 case "ParameterConstraints": 13409 if err := awsAwsjson11_deserializeDocumentParameterConstraints(&sv.ParameterConstraints, value); err != nil { 13410 return err 13411 } 13412 13413 case "ParameterKey": 13414 if value != nil { 13415 jtv, ok := value.(string) 13416 if !ok { 13417 return fmt.Errorf("expected ParameterKey to be of type string, got %T instead", value) 13418 } 13419 sv.ParameterKey = ptr.String(jtv) 13420 } 13421 13422 case "ParameterType": 13423 if value != nil { 13424 jtv, ok := value.(string) 13425 if !ok { 13426 return fmt.Errorf("expected ParameterType to be of type string, got %T instead", value) 13427 } 13428 sv.ParameterType = ptr.String(jtv) 13429 } 13430 13431 default: 13432 _, _ = key, value 13433 13434 } 13435 } 13436 *v = sv 13437 return nil 13438} 13439 13440func awsAwsjson11_deserializeDocumentProvisioningArtifactParameters(v *[]types.ProvisioningArtifactParameter, value interface{}) error { 13441 if v == nil { 13442 return fmt.Errorf("unexpected nil of type %T", v) 13443 } 13444 if value == nil { 13445 return nil 13446 } 13447 13448 shape, ok := value.([]interface{}) 13449 if !ok { 13450 return fmt.Errorf("unexpected JSON type %v", value) 13451 } 13452 13453 var cv []types.ProvisioningArtifactParameter 13454 if *v == nil { 13455 cv = []types.ProvisioningArtifactParameter{} 13456 } else { 13457 cv = *v 13458 } 13459 13460 for _, value := range shape { 13461 var col types.ProvisioningArtifactParameter 13462 destAddr := &col 13463 if err := awsAwsjson11_deserializeDocumentProvisioningArtifactParameter(&destAddr, value); err != nil { 13464 return err 13465 } 13466 col = *destAddr 13467 cv = append(cv, col) 13468 13469 } 13470 *v = cv 13471 return nil 13472} 13473 13474func awsAwsjson11_deserializeDocumentProvisioningArtifactPreferences(v **types.ProvisioningArtifactPreferences, value interface{}) error { 13475 if v == nil { 13476 return fmt.Errorf("unexpected nil of type %T", v) 13477 } 13478 if value == nil { 13479 return nil 13480 } 13481 13482 shape, ok := value.(map[string]interface{}) 13483 if !ok { 13484 return fmt.Errorf("unexpected JSON type %v", value) 13485 } 13486 13487 var sv *types.ProvisioningArtifactPreferences 13488 if *v == nil { 13489 sv = &types.ProvisioningArtifactPreferences{} 13490 } else { 13491 sv = *v 13492 } 13493 13494 for key, value := range shape { 13495 switch key { 13496 case "StackSetAccounts": 13497 if err := awsAwsjson11_deserializeDocumentStackSetAccounts(&sv.StackSetAccounts, value); err != nil { 13498 return err 13499 } 13500 13501 case "StackSetRegions": 13502 if err := awsAwsjson11_deserializeDocumentStackSetRegions(&sv.StackSetRegions, value); err != nil { 13503 return err 13504 } 13505 13506 default: 13507 _, _ = key, value 13508 13509 } 13510 } 13511 *v = sv 13512 return nil 13513} 13514 13515func awsAwsjson11_deserializeDocumentProvisioningArtifacts(v *[]types.ProvisioningArtifact, value interface{}) error { 13516 if v == nil { 13517 return fmt.Errorf("unexpected nil of type %T", v) 13518 } 13519 if value == nil { 13520 return nil 13521 } 13522 13523 shape, ok := value.([]interface{}) 13524 if !ok { 13525 return fmt.Errorf("unexpected JSON type %v", value) 13526 } 13527 13528 var cv []types.ProvisioningArtifact 13529 if *v == nil { 13530 cv = []types.ProvisioningArtifact{} 13531 } else { 13532 cv = *v 13533 } 13534 13535 for _, value := range shape { 13536 var col types.ProvisioningArtifact 13537 destAddr := &col 13538 if err := awsAwsjson11_deserializeDocumentProvisioningArtifact(&destAddr, value); err != nil { 13539 return err 13540 } 13541 col = *destAddr 13542 cv = append(cv, col) 13543 13544 } 13545 *v = cv 13546 return nil 13547} 13548 13549func awsAwsjson11_deserializeDocumentProvisioningArtifactSummaries(v *[]types.ProvisioningArtifactSummary, value interface{}) error { 13550 if v == nil { 13551 return fmt.Errorf("unexpected nil of type %T", v) 13552 } 13553 if value == nil { 13554 return nil 13555 } 13556 13557 shape, ok := value.([]interface{}) 13558 if !ok { 13559 return fmt.Errorf("unexpected JSON type %v", value) 13560 } 13561 13562 var cv []types.ProvisioningArtifactSummary 13563 if *v == nil { 13564 cv = []types.ProvisioningArtifactSummary{} 13565 } else { 13566 cv = *v 13567 } 13568 13569 for _, value := range shape { 13570 var col types.ProvisioningArtifactSummary 13571 destAddr := &col 13572 if err := awsAwsjson11_deserializeDocumentProvisioningArtifactSummary(&destAddr, value); err != nil { 13573 return err 13574 } 13575 col = *destAddr 13576 cv = append(cv, col) 13577 13578 } 13579 *v = cv 13580 return nil 13581} 13582 13583func awsAwsjson11_deserializeDocumentProvisioningArtifactSummary(v **types.ProvisioningArtifactSummary, value interface{}) error { 13584 if v == nil { 13585 return fmt.Errorf("unexpected nil of type %T", v) 13586 } 13587 if value == nil { 13588 return nil 13589 } 13590 13591 shape, ok := value.(map[string]interface{}) 13592 if !ok { 13593 return fmt.Errorf("unexpected JSON type %v", value) 13594 } 13595 13596 var sv *types.ProvisioningArtifactSummary 13597 if *v == nil { 13598 sv = &types.ProvisioningArtifactSummary{} 13599 } else { 13600 sv = *v 13601 } 13602 13603 for key, value := range shape { 13604 switch key { 13605 case "CreatedTime": 13606 if value != nil { 13607 jtv, ok := value.(json.Number) 13608 if !ok { 13609 return fmt.Errorf("expected ProvisioningArtifactCreatedTime to be json.Number, got %T instead", value) 13610 } 13611 f64, err := jtv.Float64() 13612 if err != nil { 13613 return err 13614 } 13615 sv.CreatedTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 13616 } 13617 13618 case "Description": 13619 if value != nil { 13620 jtv, ok := value.(string) 13621 if !ok { 13622 return fmt.Errorf("expected ProvisioningArtifactDescription to be of type string, got %T instead", value) 13623 } 13624 sv.Description = ptr.String(jtv) 13625 } 13626 13627 case "Id": 13628 if value != nil { 13629 jtv, ok := value.(string) 13630 if !ok { 13631 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 13632 } 13633 sv.Id = ptr.String(jtv) 13634 } 13635 13636 case "Name": 13637 if value != nil { 13638 jtv, ok := value.(string) 13639 if !ok { 13640 return fmt.Errorf("expected ProvisioningArtifactName to be of type string, got %T instead", value) 13641 } 13642 sv.Name = ptr.String(jtv) 13643 } 13644 13645 case "ProvisioningArtifactMetadata": 13646 if err := awsAwsjson11_deserializeDocumentProvisioningArtifactInfo(&sv.ProvisioningArtifactMetadata, value); err != nil { 13647 return err 13648 } 13649 13650 default: 13651 _, _ = key, value 13652 13653 } 13654 } 13655 *v = sv 13656 return nil 13657} 13658 13659func awsAwsjson11_deserializeDocumentProvisioningArtifactView(v **types.ProvisioningArtifactView, value interface{}) error { 13660 if v == nil { 13661 return fmt.Errorf("unexpected nil of type %T", v) 13662 } 13663 if value == nil { 13664 return nil 13665 } 13666 13667 shape, ok := value.(map[string]interface{}) 13668 if !ok { 13669 return fmt.Errorf("unexpected JSON type %v", value) 13670 } 13671 13672 var sv *types.ProvisioningArtifactView 13673 if *v == nil { 13674 sv = &types.ProvisioningArtifactView{} 13675 } else { 13676 sv = *v 13677 } 13678 13679 for key, value := range shape { 13680 switch key { 13681 case "ProductViewSummary": 13682 if err := awsAwsjson11_deserializeDocumentProductViewSummary(&sv.ProductViewSummary, value); err != nil { 13683 return err 13684 } 13685 13686 case "ProvisioningArtifact": 13687 if err := awsAwsjson11_deserializeDocumentProvisioningArtifact(&sv.ProvisioningArtifact, value); err != nil { 13688 return err 13689 } 13690 13691 default: 13692 _, _ = key, value 13693 13694 } 13695 } 13696 *v = sv 13697 return nil 13698} 13699 13700func awsAwsjson11_deserializeDocumentProvisioningArtifactViews(v *[]types.ProvisioningArtifactView, value interface{}) error { 13701 if v == nil { 13702 return fmt.Errorf("unexpected nil of type %T", v) 13703 } 13704 if value == nil { 13705 return nil 13706 } 13707 13708 shape, ok := value.([]interface{}) 13709 if !ok { 13710 return fmt.Errorf("unexpected JSON type %v", value) 13711 } 13712 13713 var cv []types.ProvisioningArtifactView 13714 if *v == nil { 13715 cv = []types.ProvisioningArtifactView{} 13716 } else { 13717 cv = *v 13718 } 13719 13720 for _, value := range shape { 13721 var col types.ProvisioningArtifactView 13722 destAddr := &col 13723 if err := awsAwsjson11_deserializeDocumentProvisioningArtifactView(&destAddr, value); err != nil { 13724 return err 13725 } 13726 col = *destAddr 13727 cv = append(cv, col) 13728 13729 } 13730 *v = cv 13731 return nil 13732} 13733 13734func awsAwsjson11_deserializeDocumentRecordDetail(v **types.RecordDetail, value interface{}) error { 13735 if v == nil { 13736 return fmt.Errorf("unexpected nil of type %T", v) 13737 } 13738 if value == nil { 13739 return nil 13740 } 13741 13742 shape, ok := value.(map[string]interface{}) 13743 if !ok { 13744 return fmt.Errorf("unexpected JSON type %v", value) 13745 } 13746 13747 var sv *types.RecordDetail 13748 if *v == nil { 13749 sv = &types.RecordDetail{} 13750 } else { 13751 sv = *v 13752 } 13753 13754 for key, value := range shape { 13755 switch key { 13756 case "CreatedTime": 13757 if value != nil { 13758 jtv, ok := value.(json.Number) 13759 if !ok { 13760 return fmt.Errorf("expected CreatedTime to be json.Number, got %T instead", value) 13761 } 13762 f64, err := jtv.Float64() 13763 if err != nil { 13764 return err 13765 } 13766 sv.CreatedTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 13767 } 13768 13769 case "LaunchRoleArn": 13770 if value != nil { 13771 jtv, ok := value.(string) 13772 if !ok { 13773 return fmt.Errorf("expected RoleArn to be of type string, got %T instead", value) 13774 } 13775 sv.LaunchRoleArn = ptr.String(jtv) 13776 } 13777 13778 case "PathId": 13779 if value != nil { 13780 jtv, ok := value.(string) 13781 if !ok { 13782 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 13783 } 13784 sv.PathId = ptr.String(jtv) 13785 } 13786 13787 case "ProductId": 13788 if value != nil { 13789 jtv, ok := value.(string) 13790 if !ok { 13791 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 13792 } 13793 sv.ProductId = ptr.String(jtv) 13794 } 13795 13796 case "ProvisionedProductId": 13797 if value != nil { 13798 jtv, ok := value.(string) 13799 if !ok { 13800 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 13801 } 13802 sv.ProvisionedProductId = ptr.String(jtv) 13803 } 13804 13805 case "ProvisionedProductName": 13806 if value != nil { 13807 jtv, ok := value.(string) 13808 if !ok { 13809 return fmt.Errorf("expected ProvisionedProductName to be of type string, got %T instead", value) 13810 } 13811 sv.ProvisionedProductName = ptr.String(jtv) 13812 } 13813 13814 case "ProvisionedProductType": 13815 if value != nil { 13816 jtv, ok := value.(string) 13817 if !ok { 13818 return fmt.Errorf("expected ProvisionedProductType to be of type string, got %T instead", value) 13819 } 13820 sv.ProvisionedProductType = ptr.String(jtv) 13821 } 13822 13823 case "ProvisioningArtifactId": 13824 if value != nil { 13825 jtv, ok := value.(string) 13826 if !ok { 13827 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 13828 } 13829 sv.ProvisioningArtifactId = ptr.String(jtv) 13830 } 13831 13832 case "RecordErrors": 13833 if err := awsAwsjson11_deserializeDocumentRecordErrors(&sv.RecordErrors, value); err != nil { 13834 return err 13835 } 13836 13837 case "RecordId": 13838 if value != nil { 13839 jtv, ok := value.(string) 13840 if !ok { 13841 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 13842 } 13843 sv.RecordId = ptr.String(jtv) 13844 } 13845 13846 case "RecordTags": 13847 if err := awsAwsjson11_deserializeDocumentRecordTags(&sv.RecordTags, value); err != nil { 13848 return err 13849 } 13850 13851 case "RecordType": 13852 if value != nil { 13853 jtv, ok := value.(string) 13854 if !ok { 13855 return fmt.Errorf("expected RecordType to be of type string, got %T instead", value) 13856 } 13857 sv.RecordType = ptr.String(jtv) 13858 } 13859 13860 case "Status": 13861 if value != nil { 13862 jtv, ok := value.(string) 13863 if !ok { 13864 return fmt.Errorf("expected RecordStatus to be of type string, got %T instead", value) 13865 } 13866 sv.Status = types.RecordStatus(jtv) 13867 } 13868 13869 case "UpdatedTime": 13870 if value != nil { 13871 jtv, ok := value.(json.Number) 13872 if !ok { 13873 return fmt.Errorf("expected UpdatedTime to be json.Number, got %T instead", value) 13874 } 13875 f64, err := jtv.Float64() 13876 if err != nil { 13877 return err 13878 } 13879 sv.UpdatedTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 13880 } 13881 13882 default: 13883 _, _ = key, value 13884 13885 } 13886 } 13887 *v = sv 13888 return nil 13889} 13890 13891func awsAwsjson11_deserializeDocumentRecordDetails(v *[]types.RecordDetail, value interface{}) error { 13892 if v == nil { 13893 return fmt.Errorf("unexpected nil of type %T", v) 13894 } 13895 if value == nil { 13896 return nil 13897 } 13898 13899 shape, ok := value.([]interface{}) 13900 if !ok { 13901 return fmt.Errorf("unexpected JSON type %v", value) 13902 } 13903 13904 var cv []types.RecordDetail 13905 if *v == nil { 13906 cv = []types.RecordDetail{} 13907 } else { 13908 cv = *v 13909 } 13910 13911 for _, value := range shape { 13912 var col types.RecordDetail 13913 destAddr := &col 13914 if err := awsAwsjson11_deserializeDocumentRecordDetail(&destAddr, value); err != nil { 13915 return err 13916 } 13917 col = *destAddr 13918 cv = append(cv, col) 13919 13920 } 13921 *v = cv 13922 return nil 13923} 13924 13925func awsAwsjson11_deserializeDocumentRecordError(v **types.RecordError, value interface{}) error { 13926 if v == nil { 13927 return fmt.Errorf("unexpected nil of type %T", v) 13928 } 13929 if value == nil { 13930 return nil 13931 } 13932 13933 shape, ok := value.(map[string]interface{}) 13934 if !ok { 13935 return fmt.Errorf("unexpected JSON type %v", value) 13936 } 13937 13938 var sv *types.RecordError 13939 if *v == nil { 13940 sv = &types.RecordError{} 13941 } else { 13942 sv = *v 13943 } 13944 13945 for key, value := range shape { 13946 switch key { 13947 case "Code": 13948 if value != nil { 13949 jtv, ok := value.(string) 13950 if !ok { 13951 return fmt.Errorf("expected ErrorCode to be of type string, got %T instead", value) 13952 } 13953 sv.Code = ptr.String(jtv) 13954 } 13955 13956 case "Description": 13957 if value != nil { 13958 jtv, ok := value.(string) 13959 if !ok { 13960 return fmt.Errorf("expected ErrorDescription to be of type string, got %T instead", value) 13961 } 13962 sv.Description = ptr.String(jtv) 13963 } 13964 13965 default: 13966 _, _ = key, value 13967 13968 } 13969 } 13970 *v = sv 13971 return nil 13972} 13973 13974func awsAwsjson11_deserializeDocumentRecordErrors(v *[]types.RecordError, value interface{}) error { 13975 if v == nil { 13976 return fmt.Errorf("unexpected nil of type %T", v) 13977 } 13978 if value == nil { 13979 return nil 13980 } 13981 13982 shape, ok := value.([]interface{}) 13983 if !ok { 13984 return fmt.Errorf("unexpected JSON type %v", value) 13985 } 13986 13987 var cv []types.RecordError 13988 if *v == nil { 13989 cv = []types.RecordError{} 13990 } else { 13991 cv = *v 13992 } 13993 13994 for _, value := range shape { 13995 var col types.RecordError 13996 destAddr := &col 13997 if err := awsAwsjson11_deserializeDocumentRecordError(&destAddr, value); err != nil { 13998 return err 13999 } 14000 col = *destAddr 14001 cv = append(cv, col) 14002 14003 } 14004 *v = cv 14005 return nil 14006} 14007 14008func awsAwsjson11_deserializeDocumentRecordOutput(v **types.RecordOutput, value interface{}) error { 14009 if v == nil { 14010 return fmt.Errorf("unexpected nil of type %T", v) 14011 } 14012 if value == nil { 14013 return nil 14014 } 14015 14016 shape, ok := value.(map[string]interface{}) 14017 if !ok { 14018 return fmt.Errorf("unexpected JSON type %v", value) 14019 } 14020 14021 var sv *types.RecordOutput 14022 if *v == nil { 14023 sv = &types.RecordOutput{} 14024 } else { 14025 sv = *v 14026 } 14027 14028 for key, value := range shape { 14029 switch key { 14030 case "Description": 14031 if value != nil { 14032 jtv, ok := value.(string) 14033 if !ok { 14034 return fmt.Errorf("expected Description to be of type string, got %T instead", value) 14035 } 14036 sv.Description = ptr.String(jtv) 14037 } 14038 14039 case "OutputKey": 14040 if value != nil { 14041 jtv, ok := value.(string) 14042 if !ok { 14043 return fmt.Errorf("expected OutputKey to be of type string, got %T instead", value) 14044 } 14045 sv.OutputKey = ptr.String(jtv) 14046 } 14047 14048 case "OutputValue": 14049 if value != nil { 14050 jtv, ok := value.(string) 14051 if !ok { 14052 return fmt.Errorf("expected OutputValue to be of type string, got %T instead", value) 14053 } 14054 sv.OutputValue = ptr.String(jtv) 14055 } 14056 14057 default: 14058 _, _ = key, value 14059 14060 } 14061 } 14062 *v = sv 14063 return nil 14064} 14065 14066func awsAwsjson11_deserializeDocumentRecordOutputs(v *[]types.RecordOutput, value interface{}) error { 14067 if v == nil { 14068 return fmt.Errorf("unexpected nil of type %T", v) 14069 } 14070 if value == nil { 14071 return nil 14072 } 14073 14074 shape, ok := value.([]interface{}) 14075 if !ok { 14076 return fmt.Errorf("unexpected JSON type %v", value) 14077 } 14078 14079 var cv []types.RecordOutput 14080 if *v == nil { 14081 cv = []types.RecordOutput{} 14082 } else { 14083 cv = *v 14084 } 14085 14086 for _, value := range shape { 14087 var col types.RecordOutput 14088 destAddr := &col 14089 if err := awsAwsjson11_deserializeDocumentRecordOutput(&destAddr, value); err != nil { 14090 return err 14091 } 14092 col = *destAddr 14093 cv = append(cv, col) 14094 14095 } 14096 *v = cv 14097 return nil 14098} 14099 14100func awsAwsjson11_deserializeDocumentRecordTag(v **types.RecordTag, value interface{}) error { 14101 if v == nil { 14102 return fmt.Errorf("unexpected nil of type %T", v) 14103 } 14104 if value == nil { 14105 return nil 14106 } 14107 14108 shape, ok := value.(map[string]interface{}) 14109 if !ok { 14110 return fmt.Errorf("unexpected JSON type %v", value) 14111 } 14112 14113 var sv *types.RecordTag 14114 if *v == nil { 14115 sv = &types.RecordTag{} 14116 } else { 14117 sv = *v 14118 } 14119 14120 for key, value := range shape { 14121 switch key { 14122 case "Key": 14123 if value != nil { 14124 jtv, ok := value.(string) 14125 if !ok { 14126 return fmt.Errorf("expected RecordTagKey to be of type string, got %T instead", value) 14127 } 14128 sv.Key = ptr.String(jtv) 14129 } 14130 14131 case "Value": 14132 if value != nil { 14133 jtv, ok := value.(string) 14134 if !ok { 14135 return fmt.Errorf("expected RecordTagValue to be of type string, got %T instead", value) 14136 } 14137 sv.Value = ptr.String(jtv) 14138 } 14139 14140 default: 14141 _, _ = key, value 14142 14143 } 14144 } 14145 *v = sv 14146 return nil 14147} 14148 14149func awsAwsjson11_deserializeDocumentRecordTags(v *[]types.RecordTag, value interface{}) error { 14150 if v == nil { 14151 return fmt.Errorf("unexpected nil of type %T", v) 14152 } 14153 if value == nil { 14154 return nil 14155 } 14156 14157 shape, ok := value.([]interface{}) 14158 if !ok { 14159 return fmt.Errorf("unexpected JSON type %v", value) 14160 } 14161 14162 var cv []types.RecordTag 14163 if *v == nil { 14164 cv = []types.RecordTag{} 14165 } else { 14166 cv = *v 14167 } 14168 14169 for _, value := range shape { 14170 var col types.RecordTag 14171 destAddr := &col 14172 if err := awsAwsjson11_deserializeDocumentRecordTag(&destAddr, value); err != nil { 14173 return err 14174 } 14175 col = *destAddr 14176 cv = append(cv, col) 14177 14178 } 14179 *v = cv 14180 return nil 14181} 14182 14183func awsAwsjson11_deserializeDocumentResourceChange(v **types.ResourceChange, value interface{}) error { 14184 if v == nil { 14185 return fmt.Errorf("unexpected nil of type %T", v) 14186 } 14187 if value == nil { 14188 return nil 14189 } 14190 14191 shape, ok := value.(map[string]interface{}) 14192 if !ok { 14193 return fmt.Errorf("unexpected JSON type %v", value) 14194 } 14195 14196 var sv *types.ResourceChange 14197 if *v == nil { 14198 sv = &types.ResourceChange{} 14199 } else { 14200 sv = *v 14201 } 14202 14203 for key, value := range shape { 14204 switch key { 14205 case "Action": 14206 if value != nil { 14207 jtv, ok := value.(string) 14208 if !ok { 14209 return fmt.Errorf("expected ChangeAction to be of type string, got %T instead", value) 14210 } 14211 sv.Action = types.ChangeAction(jtv) 14212 } 14213 14214 case "Details": 14215 if err := awsAwsjson11_deserializeDocumentResourceChangeDetails(&sv.Details, value); err != nil { 14216 return err 14217 } 14218 14219 case "LogicalResourceId": 14220 if value != nil { 14221 jtv, ok := value.(string) 14222 if !ok { 14223 return fmt.Errorf("expected LogicalResourceId to be of type string, got %T instead", value) 14224 } 14225 sv.LogicalResourceId = ptr.String(jtv) 14226 } 14227 14228 case "PhysicalResourceId": 14229 if value != nil { 14230 jtv, ok := value.(string) 14231 if !ok { 14232 return fmt.Errorf("expected PhysicalResourceId to be of type string, got %T instead", value) 14233 } 14234 sv.PhysicalResourceId = ptr.String(jtv) 14235 } 14236 14237 case "Replacement": 14238 if value != nil { 14239 jtv, ok := value.(string) 14240 if !ok { 14241 return fmt.Errorf("expected Replacement to be of type string, got %T instead", value) 14242 } 14243 sv.Replacement = types.Replacement(jtv) 14244 } 14245 14246 case "ResourceType": 14247 if value != nil { 14248 jtv, ok := value.(string) 14249 if !ok { 14250 return fmt.Errorf("expected PlanResourceType to be of type string, got %T instead", value) 14251 } 14252 sv.ResourceType = ptr.String(jtv) 14253 } 14254 14255 case "Scope": 14256 if err := awsAwsjson11_deserializeDocumentScope(&sv.Scope, value); err != nil { 14257 return err 14258 } 14259 14260 default: 14261 _, _ = key, value 14262 14263 } 14264 } 14265 *v = sv 14266 return nil 14267} 14268 14269func awsAwsjson11_deserializeDocumentResourceChangeDetail(v **types.ResourceChangeDetail, value interface{}) error { 14270 if v == nil { 14271 return fmt.Errorf("unexpected nil of type %T", v) 14272 } 14273 if value == nil { 14274 return nil 14275 } 14276 14277 shape, ok := value.(map[string]interface{}) 14278 if !ok { 14279 return fmt.Errorf("unexpected JSON type %v", value) 14280 } 14281 14282 var sv *types.ResourceChangeDetail 14283 if *v == nil { 14284 sv = &types.ResourceChangeDetail{} 14285 } else { 14286 sv = *v 14287 } 14288 14289 for key, value := range shape { 14290 switch key { 14291 case "CausingEntity": 14292 if value != nil { 14293 jtv, ok := value.(string) 14294 if !ok { 14295 return fmt.Errorf("expected CausingEntity to be of type string, got %T instead", value) 14296 } 14297 sv.CausingEntity = ptr.String(jtv) 14298 } 14299 14300 case "Evaluation": 14301 if value != nil { 14302 jtv, ok := value.(string) 14303 if !ok { 14304 return fmt.Errorf("expected EvaluationType to be of type string, got %T instead", value) 14305 } 14306 sv.Evaluation = types.EvaluationType(jtv) 14307 } 14308 14309 case "Target": 14310 if err := awsAwsjson11_deserializeDocumentResourceTargetDefinition(&sv.Target, value); err != nil { 14311 return err 14312 } 14313 14314 default: 14315 _, _ = key, value 14316 14317 } 14318 } 14319 *v = sv 14320 return nil 14321} 14322 14323func awsAwsjson11_deserializeDocumentResourceChangeDetails(v *[]types.ResourceChangeDetail, value interface{}) error { 14324 if v == nil { 14325 return fmt.Errorf("unexpected nil of type %T", v) 14326 } 14327 if value == nil { 14328 return nil 14329 } 14330 14331 shape, ok := value.([]interface{}) 14332 if !ok { 14333 return fmt.Errorf("unexpected JSON type %v", value) 14334 } 14335 14336 var cv []types.ResourceChangeDetail 14337 if *v == nil { 14338 cv = []types.ResourceChangeDetail{} 14339 } else { 14340 cv = *v 14341 } 14342 14343 for _, value := range shape { 14344 var col types.ResourceChangeDetail 14345 destAddr := &col 14346 if err := awsAwsjson11_deserializeDocumentResourceChangeDetail(&destAddr, value); err != nil { 14347 return err 14348 } 14349 col = *destAddr 14350 cv = append(cv, col) 14351 14352 } 14353 *v = cv 14354 return nil 14355} 14356 14357func awsAwsjson11_deserializeDocumentResourceChanges(v *[]types.ResourceChange, value interface{}) error { 14358 if v == nil { 14359 return fmt.Errorf("unexpected nil of type %T", v) 14360 } 14361 if value == nil { 14362 return nil 14363 } 14364 14365 shape, ok := value.([]interface{}) 14366 if !ok { 14367 return fmt.Errorf("unexpected JSON type %v", value) 14368 } 14369 14370 var cv []types.ResourceChange 14371 if *v == nil { 14372 cv = []types.ResourceChange{} 14373 } else { 14374 cv = *v 14375 } 14376 14377 for _, value := range shape { 14378 var col types.ResourceChange 14379 destAddr := &col 14380 if err := awsAwsjson11_deserializeDocumentResourceChange(&destAddr, value); err != nil { 14381 return err 14382 } 14383 col = *destAddr 14384 cv = append(cv, col) 14385 14386 } 14387 *v = cv 14388 return nil 14389} 14390 14391func awsAwsjson11_deserializeDocumentResourceDetail(v **types.ResourceDetail, value interface{}) error { 14392 if v == nil { 14393 return fmt.Errorf("unexpected nil of type %T", v) 14394 } 14395 if value == nil { 14396 return nil 14397 } 14398 14399 shape, ok := value.(map[string]interface{}) 14400 if !ok { 14401 return fmt.Errorf("unexpected JSON type %v", value) 14402 } 14403 14404 var sv *types.ResourceDetail 14405 if *v == nil { 14406 sv = &types.ResourceDetail{} 14407 } else { 14408 sv = *v 14409 } 14410 14411 for key, value := range shape { 14412 switch key { 14413 case "ARN": 14414 if value != nil { 14415 jtv, ok := value.(string) 14416 if !ok { 14417 return fmt.Errorf("expected ResourceDetailARN to be of type string, got %T instead", value) 14418 } 14419 sv.ARN = ptr.String(jtv) 14420 } 14421 14422 case "CreatedTime": 14423 if value != nil { 14424 jtv, ok := value.(json.Number) 14425 if !ok { 14426 return fmt.Errorf("expected ResourceDetailCreatedTime to be json.Number, got %T instead", value) 14427 } 14428 f64, err := jtv.Float64() 14429 if err != nil { 14430 return err 14431 } 14432 sv.CreatedTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 14433 } 14434 14435 case "Description": 14436 if value != nil { 14437 jtv, ok := value.(string) 14438 if !ok { 14439 return fmt.Errorf("expected ResourceDetailDescription to be of type string, got %T instead", value) 14440 } 14441 sv.Description = ptr.String(jtv) 14442 } 14443 14444 case "Id": 14445 if value != nil { 14446 jtv, ok := value.(string) 14447 if !ok { 14448 return fmt.Errorf("expected ResourceDetailId to be of type string, got %T instead", value) 14449 } 14450 sv.Id = ptr.String(jtv) 14451 } 14452 14453 case "Name": 14454 if value != nil { 14455 jtv, ok := value.(string) 14456 if !ok { 14457 return fmt.Errorf("expected ResourceDetailName to be of type string, got %T instead", value) 14458 } 14459 sv.Name = ptr.String(jtv) 14460 } 14461 14462 default: 14463 _, _ = key, value 14464 14465 } 14466 } 14467 *v = sv 14468 return nil 14469} 14470 14471func awsAwsjson11_deserializeDocumentResourceDetails(v *[]types.ResourceDetail, value interface{}) error { 14472 if v == nil { 14473 return fmt.Errorf("unexpected nil of type %T", v) 14474 } 14475 if value == nil { 14476 return nil 14477 } 14478 14479 shape, ok := value.([]interface{}) 14480 if !ok { 14481 return fmt.Errorf("unexpected JSON type %v", value) 14482 } 14483 14484 var cv []types.ResourceDetail 14485 if *v == nil { 14486 cv = []types.ResourceDetail{} 14487 } else { 14488 cv = *v 14489 } 14490 14491 for _, value := range shape { 14492 var col types.ResourceDetail 14493 destAddr := &col 14494 if err := awsAwsjson11_deserializeDocumentResourceDetail(&destAddr, value); err != nil { 14495 return err 14496 } 14497 col = *destAddr 14498 cv = append(cv, col) 14499 14500 } 14501 *v = cv 14502 return nil 14503} 14504 14505func awsAwsjson11_deserializeDocumentResourceInUseException(v **types.ResourceInUseException, value interface{}) error { 14506 if v == nil { 14507 return fmt.Errorf("unexpected nil of type %T", v) 14508 } 14509 if value == nil { 14510 return nil 14511 } 14512 14513 shape, ok := value.(map[string]interface{}) 14514 if !ok { 14515 return fmt.Errorf("unexpected JSON type %v", value) 14516 } 14517 14518 var sv *types.ResourceInUseException 14519 if *v == nil { 14520 sv = &types.ResourceInUseException{} 14521 } else { 14522 sv = *v 14523 } 14524 14525 for key, value := range shape { 14526 switch key { 14527 case "Message": 14528 if value != nil { 14529 jtv, ok := value.(string) 14530 if !ok { 14531 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 14532 } 14533 sv.Message = ptr.String(jtv) 14534 } 14535 14536 default: 14537 _, _ = key, value 14538 14539 } 14540 } 14541 *v = sv 14542 return nil 14543} 14544 14545func awsAwsjson11_deserializeDocumentResourceNotFoundException(v **types.ResourceNotFoundException, value interface{}) error { 14546 if v == nil { 14547 return fmt.Errorf("unexpected nil of type %T", v) 14548 } 14549 if value == nil { 14550 return nil 14551 } 14552 14553 shape, ok := value.(map[string]interface{}) 14554 if !ok { 14555 return fmt.Errorf("unexpected JSON type %v", value) 14556 } 14557 14558 var sv *types.ResourceNotFoundException 14559 if *v == nil { 14560 sv = &types.ResourceNotFoundException{} 14561 } else { 14562 sv = *v 14563 } 14564 14565 for key, value := range shape { 14566 switch key { 14567 case "Message": 14568 if value != nil { 14569 jtv, ok := value.(string) 14570 if !ok { 14571 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 14572 } 14573 sv.Message = ptr.String(jtv) 14574 } 14575 14576 default: 14577 _, _ = key, value 14578 14579 } 14580 } 14581 *v = sv 14582 return nil 14583} 14584 14585func awsAwsjson11_deserializeDocumentResourceTargetDefinition(v **types.ResourceTargetDefinition, value interface{}) error { 14586 if v == nil { 14587 return fmt.Errorf("unexpected nil of type %T", v) 14588 } 14589 if value == nil { 14590 return nil 14591 } 14592 14593 shape, ok := value.(map[string]interface{}) 14594 if !ok { 14595 return fmt.Errorf("unexpected JSON type %v", value) 14596 } 14597 14598 var sv *types.ResourceTargetDefinition 14599 if *v == nil { 14600 sv = &types.ResourceTargetDefinition{} 14601 } else { 14602 sv = *v 14603 } 14604 14605 for key, value := range shape { 14606 switch key { 14607 case "Attribute": 14608 if value != nil { 14609 jtv, ok := value.(string) 14610 if !ok { 14611 return fmt.Errorf("expected ResourceAttribute to be of type string, got %T instead", value) 14612 } 14613 sv.Attribute = types.ResourceAttribute(jtv) 14614 } 14615 14616 case "Name": 14617 if value != nil { 14618 jtv, ok := value.(string) 14619 if !ok { 14620 return fmt.Errorf("expected PropertyName to be of type string, got %T instead", value) 14621 } 14622 sv.Name = ptr.String(jtv) 14623 } 14624 14625 case "RequiresRecreation": 14626 if value != nil { 14627 jtv, ok := value.(string) 14628 if !ok { 14629 return fmt.Errorf("expected RequiresRecreation to be of type string, got %T instead", value) 14630 } 14631 sv.RequiresRecreation = types.RequiresRecreation(jtv) 14632 } 14633 14634 default: 14635 _, _ = key, value 14636 14637 } 14638 } 14639 *v = sv 14640 return nil 14641} 14642 14643func awsAwsjson11_deserializeDocumentScope(v *[]types.ResourceAttribute, value interface{}) error { 14644 if v == nil { 14645 return fmt.Errorf("unexpected nil of type %T", v) 14646 } 14647 if value == nil { 14648 return nil 14649 } 14650 14651 shape, ok := value.([]interface{}) 14652 if !ok { 14653 return fmt.Errorf("unexpected JSON type %v", value) 14654 } 14655 14656 var cv []types.ResourceAttribute 14657 if *v == nil { 14658 cv = []types.ResourceAttribute{} 14659 } else { 14660 cv = *v 14661 } 14662 14663 for _, value := range shape { 14664 var col types.ResourceAttribute 14665 if value != nil { 14666 jtv, ok := value.(string) 14667 if !ok { 14668 return fmt.Errorf("expected ResourceAttribute to be of type string, got %T instead", value) 14669 } 14670 col = types.ResourceAttribute(jtv) 14671 } 14672 cv = append(cv, col) 14673 14674 } 14675 *v = cv 14676 return nil 14677} 14678 14679func awsAwsjson11_deserializeDocumentServiceActionDefinitionMap(v *map[string]string, value interface{}) error { 14680 if v == nil { 14681 return fmt.Errorf("unexpected nil of type %T", v) 14682 } 14683 if value == nil { 14684 return nil 14685 } 14686 14687 shape, ok := value.(map[string]interface{}) 14688 if !ok { 14689 return fmt.Errorf("unexpected JSON type %v", value) 14690 } 14691 14692 var mv map[string]string 14693 if *v == nil { 14694 mv = map[string]string{} 14695 } else { 14696 mv = *v 14697 } 14698 14699 for key, value := range shape { 14700 var parsedVal string 14701 if value != nil { 14702 jtv, ok := value.(string) 14703 if !ok { 14704 return fmt.Errorf("expected ServiceActionDefinitionValue to be of type string, got %T instead", value) 14705 } 14706 parsedVal = jtv 14707 } 14708 mv[key] = parsedVal 14709 14710 } 14711 *v = mv 14712 return nil 14713} 14714 14715func awsAwsjson11_deserializeDocumentServiceActionDetail(v **types.ServiceActionDetail, value interface{}) error { 14716 if v == nil { 14717 return fmt.Errorf("unexpected nil of type %T", v) 14718 } 14719 if value == nil { 14720 return nil 14721 } 14722 14723 shape, ok := value.(map[string]interface{}) 14724 if !ok { 14725 return fmt.Errorf("unexpected JSON type %v", value) 14726 } 14727 14728 var sv *types.ServiceActionDetail 14729 if *v == nil { 14730 sv = &types.ServiceActionDetail{} 14731 } else { 14732 sv = *v 14733 } 14734 14735 for key, value := range shape { 14736 switch key { 14737 case "Definition": 14738 if err := awsAwsjson11_deserializeDocumentServiceActionDefinitionMap(&sv.Definition, value); err != nil { 14739 return err 14740 } 14741 14742 case "ServiceActionSummary": 14743 if err := awsAwsjson11_deserializeDocumentServiceActionSummary(&sv.ServiceActionSummary, value); err != nil { 14744 return err 14745 } 14746 14747 default: 14748 _, _ = key, value 14749 14750 } 14751 } 14752 *v = sv 14753 return nil 14754} 14755 14756func awsAwsjson11_deserializeDocumentServiceActionSummaries(v *[]types.ServiceActionSummary, value interface{}) error { 14757 if v == nil { 14758 return fmt.Errorf("unexpected nil of type %T", v) 14759 } 14760 if value == nil { 14761 return nil 14762 } 14763 14764 shape, ok := value.([]interface{}) 14765 if !ok { 14766 return fmt.Errorf("unexpected JSON type %v", value) 14767 } 14768 14769 var cv []types.ServiceActionSummary 14770 if *v == nil { 14771 cv = []types.ServiceActionSummary{} 14772 } else { 14773 cv = *v 14774 } 14775 14776 for _, value := range shape { 14777 var col types.ServiceActionSummary 14778 destAddr := &col 14779 if err := awsAwsjson11_deserializeDocumentServiceActionSummary(&destAddr, value); err != nil { 14780 return err 14781 } 14782 col = *destAddr 14783 cv = append(cv, col) 14784 14785 } 14786 *v = cv 14787 return nil 14788} 14789 14790func awsAwsjson11_deserializeDocumentServiceActionSummary(v **types.ServiceActionSummary, value interface{}) error { 14791 if v == nil { 14792 return fmt.Errorf("unexpected nil of type %T", v) 14793 } 14794 if value == nil { 14795 return nil 14796 } 14797 14798 shape, ok := value.(map[string]interface{}) 14799 if !ok { 14800 return fmt.Errorf("unexpected JSON type %v", value) 14801 } 14802 14803 var sv *types.ServiceActionSummary 14804 if *v == nil { 14805 sv = &types.ServiceActionSummary{} 14806 } else { 14807 sv = *v 14808 } 14809 14810 for key, value := range shape { 14811 switch key { 14812 case "DefinitionType": 14813 if value != nil { 14814 jtv, ok := value.(string) 14815 if !ok { 14816 return fmt.Errorf("expected ServiceActionDefinitionType to be of type string, got %T instead", value) 14817 } 14818 sv.DefinitionType = types.ServiceActionDefinitionType(jtv) 14819 } 14820 14821 case "Description": 14822 if value != nil { 14823 jtv, ok := value.(string) 14824 if !ok { 14825 return fmt.Errorf("expected ServiceActionDescription to be of type string, got %T instead", value) 14826 } 14827 sv.Description = ptr.String(jtv) 14828 } 14829 14830 case "Id": 14831 if value != nil { 14832 jtv, ok := value.(string) 14833 if !ok { 14834 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 14835 } 14836 sv.Id = ptr.String(jtv) 14837 } 14838 14839 case "Name": 14840 if value != nil { 14841 jtv, ok := value.(string) 14842 if !ok { 14843 return fmt.Errorf("expected ServiceActionName to be of type string, got %T instead", value) 14844 } 14845 sv.Name = ptr.String(jtv) 14846 } 14847 14848 default: 14849 _, _ = key, value 14850 14851 } 14852 } 14853 *v = sv 14854 return nil 14855} 14856 14857func awsAwsjson11_deserializeDocumentShareDetails(v **types.ShareDetails, value interface{}) error { 14858 if v == nil { 14859 return fmt.Errorf("unexpected nil of type %T", v) 14860 } 14861 if value == nil { 14862 return nil 14863 } 14864 14865 shape, ok := value.(map[string]interface{}) 14866 if !ok { 14867 return fmt.Errorf("unexpected JSON type %v", value) 14868 } 14869 14870 var sv *types.ShareDetails 14871 if *v == nil { 14872 sv = &types.ShareDetails{} 14873 } else { 14874 sv = *v 14875 } 14876 14877 for key, value := range shape { 14878 switch key { 14879 case "ShareErrors": 14880 if err := awsAwsjson11_deserializeDocumentShareErrors(&sv.ShareErrors, value); err != nil { 14881 return err 14882 } 14883 14884 case "SuccessfulShares": 14885 if err := awsAwsjson11_deserializeDocumentSuccessfulShares(&sv.SuccessfulShares, value); err != nil { 14886 return err 14887 } 14888 14889 default: 14890 _, _ = key, value 14891 14892 } 14893 } 14894 *v = sv 14895 return nil 14896} 14897 14898func awsAwsjson11_deserializeDocumentShareError(v **types.ShareError, value interface{}) error { 14899 if v == nil { 14900 return fmt.Errorf("unexpected nil of type %T", v) 14901 } 14902 if value == nil { 14903 return nil 14904 } 14905 14906 shape, ok := value.(map[string]interface{}) 14907 if !ok { 14908 return fmt.Errorf("unexpected JSON type %v", value) 14909 } 14910 14911 var sv *types.ShareError 14912 if *v == nil { 14913 sv = &types.ShareError{} 14914 } else { 14915 sv = *v 14916 } 14917 14918 for key, value := range shape { 14919 switch key { 14920 case "Accounts": 14921 if err := awsAwsjson11_deserializeDocumentNamespaces(&sv.Accounts, value); err != nil { 14922 return err 14923 } 14924 14925 case "Error": 14926 if value != nil { 14927 jtv, ok := value.(string) 14928 if !ok { 14929 return fmt.Errorf("expected Error to be of type string, got %T instead", value) 14930 } 14931 sv.Error = ptr.String(jtv) 14932 } 14933 14934 case "Message": 14935 if value != nil { 14936 jtv, ok := value.(string) 14937 if !ok { 14938 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 14939 } 14940 sv.Message = ptr.String(jtv) 14941 } 14942 14943 default: 14944 _, _ = key, value 14945 14946 } 14947 } 14948 *v = sv 14949 return nil 14950} 14951 14952func awsAwsjson11_deserializeDocumentShareErrors(v *[]types.ShareError, value interface{}) error { 14953 if v == nil { 14954 return fmt.Errorf("unexpected nil of type %T", v) 14955 } 14956 if value == nil { 14957 return nil 14958 } 14959 14960 shape, ok := value.([]interface{}) 14961 if !ok { 14962 return fmt.Errorf("unexpected JSON type %v", value) 14963 } 14964 14965 var cv []types.ShareError 14966 if *v == nil { 14967 cv = []types.ShareError{} 14968 } else { 14969 cv = *v 14970 } 14971 14972 for _, value := range shape { 14973 var col types.ShareError 14974 destAddr := &col 14975 if err := awsAwsjson11_deserializeDocumentShareError(&destAddr, value); err != nil { 14976 return err 14977 } 14978 col = *destAddr 14979 cv = append(cv, col) 14980 14981 } 14982 *v = cv 14983 return nil 14984} 14985 14986func awsAwsjson11_deserializeDocumentStackInstance(v **types.StackInstance, value interface{}) error { 14987 if v == nil { 14988 return fmt.Errorf("unexpected nil of type %T", v) 14989 } 14990 if value == nil { 14991 return nil 14992 } 14993 14994 shape, ok := value.(map[string]interface{}) 14995 if !ok { 14996 return fmt.Errorf("unexpected JSON type %v", value) 14997 } 14998 14999 var sv *types.StackInstance 15000 if *v == nil { 15001 sv = &types.StackInstance{} 15002 } else { 15003 sv = *v 15004 } 15005 15006 for key, value := range shape { 15007 switch key { 15008 case "Account": 15009 if value != nil { 15010 jtv, ok := value.(string) 15011 if !ok { 15012 return fmt.Errorf("expected AccountId to be of type string, got %T instead", value) 15013 } 15014 sv.Account = ptr.String(jtv) 15015 } 15016 15017 case "Region": 15018 if value != nil { 15019 jtv, ok := value.(string) 15020 if !ok { 15021 return fmt.Errorf("expected Region to be of type string, got %T instead", value) 15022 } 15023 sv.Region = ptr.String(jtv) 15024 } 15025 15026 case "StackInstanceStatus": 15027 if value != nil { 15028 jtv, ok := value.(string) 15029 if !ok { 15030 return fmt.Errorf("expected StackInstanceStatus to be of type string, got %T instead", value) 15031 } 15032 sv.StackInstanceStatus = types.StackInstanceStatus(jtv) 15033 } 15034 15035 default: 15036 _, _ = key, value 15037 15038 } 15039 } 15040 *v = sv 15041 return nil 15042} 15043 15044func awsAwsjson11_deserializeDocumentStackInstances(v *[]types.StackInstance, value interface{}) error { 15045 if v == nil { 15046 return fmt.Errorf("unexpected nil of type %T", v) 15047 } 15048 if value == nil { 15049 return nil 15050 } 15051 15052 shape, ok := value.([]interface{}) 15053 if !ok { 15054 return fmt.Errorf("unexpected JSON type %v", value) 15055 } 15056 15057 var cv []types.StackInstance 15058 if *v == nil { 15059 cv = []types.StackInstance{} 15060 } else { 15061 cv = *v 15062 } 15063 15064 for _, value := range shape { 15065 var col types.StackInstance 15066 destAddr := &col 15067 if err := awsAwsjson11_deserializeDocumentStackInstance(&destAddr, value); err != nil { 15068 return err 15069 } 15070 col = *destAddr 15071 cv = append(cv, col) 15072 15073 } 15074 *v = cv 15075 return nil 15076} 15077 15078func awsAwsjson11_deserializeDocumentStackSetAccounts(v *[]string, value interface{}) error { 15079 if v == nil { 15080 return fmt.Errorf("unexpected nil of type %T", v) 15081 } 15082 if value == nil { 15083 return nil 15084 } 15085 15086 shape, ok := value.([]interface{}) 15087 if !ok { 15088 return fmt.Errorf("unexpected JSON type %v", value) 15089 } 15090 15091 var cv []string 15092 if *v == nil { 15093 cv = []string{} 15094 } else { 15095 cv = *v 15096 } 15097 15098 for _, value := range shape { 15099 var col string 15100 if value != nil { 15101 jtv, ok := value.(string) 15102 if !ok { 15103 return fmt.Errorf("expected AccountId to be of type string, got %T instead", value) 15104 } 15105 col = jtv 15106 } 15107 cv = append(cv, col) 15108 15109 } 15110 *v = cv 15111 return nil 15112} 15113 15114func awsAwsjson11_deserializeDocumentStackSetRegions(v *[]string, value interface{}) error { 15115 if v == nil { 15116 return fmt.Errorf("unexpected nil of type %T", v) 15117 } 15118 if value == nil { 15119 return nil 15120 } 15121 15122 shape, ok := value.([]interface{}) 15123 if !ok { 15124 return fmt.Errorf("unexpected JSON type %v", value) 15125 } 15126 15127 var cv []string 15128 if *v == nil { 15129 cv = []string{} 15130 } else { 15131 cv = *v 15132 } 15133 15134 for _, value := range shape { 15135 var col string 15136 if value != nil { 15137 jtv, ok := value.(string) 15138 if !ok { 15139 return fmt.Errorf("expected Region to be of type string, got %T instead", value) 15140 } 15141 col = jtv 15142 } 15143 cv = append(cv, col) 15144 15145 } 15146 *v = cv 15147 return nil 15148} 15149 15150func awsAwsjson11_deserializeDocumentSuccessfulShares(v *[]string, value interface{}) error { 15151 if v == nil { 15152 return fmt.Errorf("unexpected nil of type %T", v) 15153 } 15154 if value == nil { 15155 return nil 15156 } 15157 15158 shape, ok := value.([]interface{}) 15159 if !ok { 15160 return fmt.Errorf("unexpected JSON type %v", value) 15161 } 15162 15163 var cv []string 15164 if *v == nil { 15165 cv = []string{} 15166 } else { 15167 cv = *v 15168 } 15169 15170 for _, value := range shape { 15171 var col string 15172 if value != nil { 15173 jtv, ok := value.(string) 15174 if !ok { 15175 return fmt.Errorf("expected AccountId to be of type string, got %T instead", value) 15176 } 15177 col = jtv 15178 } 15179 cv = append(cv, col) 15180 15181 } 15182 *v = cv 15183 return nil 15184} 15185 15186func awsAwsjson11_deserializeDocumentTag(v **types.Tag, value interface{}) error { 15187 if v == nil { 15188 return fmt.Errorf("unexpected nil of type %T", v) 15189 } 15190 if value == nil { 15191 return nil 15192 } 15193 15194 shape, ok := value.(map[string]interface{}) 15195 if !ok { 15196 return fmt.Errorf("unexpected JSON type %v", value) 15197 } 15198 15199 var sv *types.Tag 15200 if *v == nil { 15201 sv = &types.Tag{} 15202 } else { 15203 sv = *v 15204 } 15205 15206 for key, value := range shape { 15207 switch key { 15208 case "Key": 15209 if value != nil { 15210 jtv, ok := value.(string) 15211 if !ok { 15212 return fmt.Errorf("expected TagKey to be of type string, got %T instead", value) 15213 } 15214 sv.Key = ptr.String(jtv) 15215 } 15216 15217 case "Value": 15218 if value != nil { 15219 jtv, ok := value.(string) 15220 if !ok { 15221 return fmt.Errorf("expected TagValue to be of type string, got %T instead", value) 15222 } 15223 sv.Value = ptr.String(jtv) 15224 } 15225 15226 default: 15227 _, _ = key, value 15228 15229 } 15230 } 15231 *v = sv 15232 return nil 15233} 15234 15235func awsAwsjson11_deserializeDocumentTagOptionDetail(v **types.TagOptionDetail, value interface{}) error { 15236 if v == nil { 15237 return fmt.Errorf("unexpected nil of type %T", v) 15238 } 15239 if value == nil { 15240 return nil 15241 } 15242 15243 shape, ok := value.(map[string]interface{}) 15244 if !ok { 15245 return fmt.Errorf("unexpected JSON type %v", value) 15246 } 15247 15248 var sv *types.TagOptionDetail 15249 if *v == nil { 15250 sv = &types.TagOptionDetail{} 15251 } else { 15252 sv = *v 15253 } 15254 15255 for key, value := range shape { 15256 switch key { 15257 case "Active": 15258 if value != nil { 15259 jtv, ok := value.(bool) 15260 if !ok { 15261 return fmt.Errorf("expected TagOptionActive to be of type *bool, got %T instead", value) 15262 } 15263 sv.Active = ptr.Bool(jtv) 15264 } 15265 15266 case "Id": 15267 if value != nil { 15268 jtv, ok := value.(string) 15269 if !ok { 15270 return fmt.Errorf("expected TagOptionId to be of type string, got %T instead", value) 15271 } 15272 sv.Id = ptr.String(jtv) 15273 } 15274 15275 case "Key": 15276 if value != nil { 15277 jtv, ok := value.(string) 15278 if !ok { 15279 return fmt.Errorf("expected TagOptionKey to be of type string, got %T instead", value) 15280 } 15281 sv.Key = ptr.String(jtv) 15282 } 15283 15284 case "Owner": 15285 if value != nil { 15286 jtv, ok := value.(string) 15287 if !ok { 15288 return fmt.Errorf("expected Owner to be of type string, got %T instead", value) 15289 } 15290 sv.Owner = ptr.String(jtv) 15291 } 15292 15293 case "Value": 15294 if value != nil { 15295 jtv, ok := value.(string) 15296 if !ok { 15297 return fmt.Errorf("expected TagOptionValue to be of type string, got %T instead", value) 15298 } 15299 sv.Value = ptr.String(jtv) 15300 } 15301 15302 default: 15303 _, _ = key, value 15304 15305 } 15306 } 15307 *v = sv 15308 return nil 15309} 15310 15311func awsAwsjson11_deserializeDocumentTagOptionDetails(v *[]types.TagOptionDetail, value interface{}) error { 15312 if v == nil { 15313 return fmt.Errorf("unexpected nil of type %T", v) 15314 } 15315 if value == nil { 15316 return nil 15317 } 15318 15319 shape, ok := value.([]interface{}) 15320 if !ok { 15321 return fmt.Errorf("unexpected JSON type %v", value) 15322 } 15323 15324 var cv []types.TagOptionDetail 15325 if *v == nil { 15326 cv = []types.TagOptionDetail{} 15327 } else { 15328 cv = *v 15329 } 15330 15331 for _, value := range shape { 15332 var col types.TagOptionDetail 15333 destAddr := &col 15334 if err := awsAwsjson11_deserializeDocumentTagOptionDetail(&destAddr, value); err != nil { 15335 return err 15336 } 15337 col = *destAddr 15338 cv = append(cv, col) 15339 15340 } 15341 *v = cv 15342 return nil 15343} 15344 15345func awsAwsjson11_deserializeDocumentTagOptionNotMigratedException(v **types.TagOptionNotMigratedException, value interface{}) error { 15346 if v == nil { 15347 return fmt.Errorf("unexpected nil of type %T", v) 15348 } 15349 if value == nil { 15350 return nil 15351 } 15352 15353 shape, ok := value.(map[string]interface{}) 15354 if !ok { 15355 return fmt.Errorf("unexpected JSON type %v", value) 15356 } 15357 15358 var sv *types.TagOptionNotMigratedException 15359 if *v == nil { 15360 sv = &types.TagOptionNotMigratedException{} 15361 } else { 15362 sv = *v 15363 } 15364 15365 for key, value := range shape { 15366 switch key { 15367 case "Message": 15368 if value != nil { 15369 jtv, ok := value.(string) 15370 if !ok { 15371 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 15372 } 15373 sv.Message = ptr.String(jtv) 15374 } 15375 15376 default: 15377 _, _ = key, value 15378 15379 } 15380 } 15381 *v = sv 15382 return nil 15383} 15384 15385func awsAwsjson11_deserializeDocumentTagOptionSummaries(v *[]types.TagOptionSummary, value interface{}) error { 15386 if v == nil { 15387 return fmt.Errorf("unexpected nil of type %T", v) 15388 } 15389 if value == nil { 15390 return nil 15391 } 15392 15393 shape, ok := value.([]interface{}) 15394 if !ok { 15395 return fmt.Errorf("unexpected JSON type %v", value) 15396 } 15397 15398 var cv []types.TagOptionSummary 15399 if *v == nil { 15400 cv = []types.TagOptionSummary{} 15401 } else { 15402 cv = *v 15403 } 15404 15405 for _, value := range shape { 15406 var col types.TagOptionSummary 15407 destAddr := &col 15408 if err := awsAwsjson11_deserializeDocumentTagOptionSummary(&destAddr, value); err != nil { 15409 return err 15410 } 15411 col = *destAddr 15412 cv = append(cv, col) 15413 15414 } 15415 *v = cv 15416 return nil 15417} 15418 15419func awsAwsjson11_deserializeDocumentTagOptionSummary(v **types.TagOptionSummary, value interface{}) error { 15420 if v == nil { 15421 return fmt.Errorf("unexpected nil of type %T", v) 15422 } 15423 if value == nil { 15424 return nil 15425 } 15426 15427 shape, ok := value.(map[string]interface{}) 15428 if !ok { 15429 return fmt.Errorf("unexpected JSON type %v", value) 15430 } 15431 15432 var sv *types.TagOptionSummary 15433 if *v == nil { 15434 sv = &types.TagOptionSummary{} 15435 } else { 15436 sv = *v 15437 } 15438 15439 for key, value := range shape { 15440 switch key { 15441 case "Key": 15442 if value != nil { 15443 jtv, ok := value.(string) 15444 if !ok { 15445 return fmt.Errorf("expected TagOptionKey to be of type string, got %T instead", value) 15446 } 15447 sv.Key = ptr.String(jtv) 15448 } 15449 15450 case "Values": 15451 if err := awsAwsjson11_deserializeDocumentTagOptionValues(&sv.Values, value); err != nil { 15452 return err 15453 } 15454 15455 default: 15456 _, _ = key, value 15457 15458 } 15459 } 15460 *v = sv 15461 return nil 15462} 15463 15464func awsAwsjson11_deserializeDocumentTagOptionValues(v *[]string, value interface{}) error { 15465 if v == nil { 15466 return fmt.Errorf("unexpected nil of type %T", v) 15467 } 15468 if value == nil { 15469 return nil 15470 } 15471 15472 shape, ok := value.([]interface{}) 15473 if !ok { 15474 return fmt.Errorf("unexpected JSON type %v", value) 15475 } 15476 15477 var cv []string 15478 if *v == nil { 15479 cv = []string{} 15480 } else { 15481 cv = *v 15482 } 15483 15484 for _, value := range shape { 15485 var col string 15486 if value != nil { 15487 jtv, ok := value.(string) 15488 if !ok { 15489 return fmt.Errorf("expected TagOptionValue to be of type string, got %T instead", value) 15490 } 15491 col = jtv 15492 } 15493 cv = append(cv, col) 15494 15495 } 15496 *v = cv 15497 return nil 15498} 15499 15500func awsAwsjson11_deserializeDocumentTags(v *[]types.Tag, value interface{}) error { 15501 if v == nil { 15502 return fmt.Errorf("unexpected nil of type %T", v) 15503 } 15504 if value == nil { 15505 return nil 15506 } 15507 15508 shape, ok := value.([]interface{}) 15509 if !ok { 15510 return fmt.Errorf("unexpected JSON type %v", value) 15511 } 15512 15513 var cv []types.Tag 15514 if *v == nil { 15515 cv = []types.Tag{} 15516 } else { 15517 cv = *v 15518 } 15519 15520 for _, value := range shape { 15521 var col types.Tag 15522 destAddr := &col 15523 if err := awsAwsjson11_deserializeDocumentTag(&destAddr, value); err != nil { 15524 return err 15525 } 15526 col = *destAddr 15527 cv = append(cv, col) 15528 15529 } 15530 *v = cv 15531 return nil 15532} 15533 15534func awsAwsjson11_deserializeDocumentUpdateProvisioningParameter(v **types.UpdateProvisioningParameter, value interface{}) error { 15535 if v == nil { 15536 return fmt.Errorf("unexpected nil of type %T", v) 15537 } 15538 if value == nil { 15539 return nil 15540 } 15541 15542 shape, ok := value.(map[string]interface{}) 15543 if !ok { 15544 return fmt.Errorf("unexpected JSON type %v", value) 15545 } 15546 15547 var sv *types.UpdateProvisioningParameter 15548 if *v == nil { 15549 sv = &types.UpdateProvisioningParameter{} 15550 } else { 15551 sv = *v 15552 } 15553 15554 for key, value := range shape { 15555 switch key { 15556 case "Key": 15557 if value != nil { 15558 jtv, ok := value.(string) 15559 if !ok { 15560 return fmt.Errorf("expected ParameterKey to be of type string, got %T instead", value) 15561 } 15562 sv.Key = ptr.String(jtv) 15563 } 15564 15565 case "UsePreviousValue": 15566 if value != nil { 15567 jtv, ok := value.(bool) 15568 if !ok { 15569 return fmt.Errorf("expected UsePreviousValue to be of type *bool, got %T instead", value) 15570 } 15571 sv.UsePreviousValue = jtv 15572 } 15573 15574 case "Value": 15575 if value != nil { 15576 jtv, ok := value.(string) 15577 if !ok { 15578 return fmt.Errorf("expected ParameterValue to be of type string, got %T instead", value) 15579 } 15580 sv.Value = ptr.String(jtv) 15581 } 15582 15583 default: 15584 _, _ = key, value 15585 15586 } 15587 } 15588 *v = sv 15589 return nil 15590} 15591 15592func awsAwsjson11_deserializeDocumentUpdateProvisioningParameters(v *[]types.UpdateProvisioningParameter, value interface{}) error { 15593 if v == nil { 15594 return fmt.Errorf("unexpected nil of type %T", v) 15595 } 15596 if value == nil { 15597 return nil 15598 } 15599 15600 shape, ok := value.([]interface{}) 15601 if !ok { 15602 return fmt.Errorf("unexpected JSON type %v", value) 15603 } 15604 15605 var cv []types.UpdateProvisioningParameter 15606 if *v == nil { 15607 cv = []types.UpdateProvisioningParameter{} 15608 } else { 15609 cv = *v 15610 } 15611 15612 for _, value := range shape { 15613 var col types.UpdateProvisioningParameter 15614 destAddr := &col 15615 if err := awsAwsjson11_deserializeDocumentUpdateProvisioningParameter(&destAddr, value); err != nil { 15616 return err 15617 } 15618 col = *destAddr 15619 cv = append(cv, col) 15620 15621 } 15622 *v = cv 15623 return nil 15624} 15625 15626func awsAwsjson11_deserializeDocumentUsageInstruction(v **types.UsageInstruction, value interface{}) error { 15627 if v == nil { 15628 return fmt.Errorf("unexpected nil of type %T", v) 15629 } 15630 if value == nil { 15631 return nil 15632 } 15633 15634 shape, ok := value.(map[string]interface{}) 15635 if !ok { 15636 return fmt.Errorf("unexpected JSON type %v", value) 15637 } 15638 15639 var sv *types.UsageInstruction 15640 if *v == nil { 15641 sv = &types.UsageInstruction{} 15642 } else { 15643 sv = *v 15644 } 15645 15646 for key, value := range shape { 15647 switch key { 15648 case "Type": 15649 if value != nil { 15650 jtv, ok := value.(string) 15651 if !ok { 15652 return fmt.Errorf("expected InstructionType to be of type string, got %T instead", value) 15653 } 15654 sv.Type = ptr.String(jtv) 15655 } 15656 15657 case "Value": 15658 if value != nil { 15659 jtv, ok := value.(string) 15660 if !ok { 15661 return fmt.Errorf("expected InstructionValue to be of type string, got %T instead", value) 15662 } 15663 sv.Value = ptr.String(jtv) 15664 } 15665 15666 default: 15667 _, _ = key, value 15668 15669 } 15670 } 15671 *v = sv 15672 return nil 15673} 15674 15675func awsAwsjson11_deserializeDocumentUsageInstructions(v *[]types.UsageInstruction, value interface{}) error { 15676 if v == nil { 15677 return fmt.Errorf("unexpected nil of type %T", v) 15678 } 15679 if value == nil { 15680 return nil 15681 } 15682 15683 shape, ok := value.([]interface{}) 15684 if !ok { 15685 return fmt.Errorf("unexpected JSON type %v", value) 15686 } 15687 15688 var cv []types.UsageInstruction 15689 if *v == nil { 15690 cv = []types.UsageInstruction{} 15691 } else { 15692 cv = *v 15693 } 15694 15695 for _, value := range shape { 15696 var col types.UsageInstruction 15697 destAddr := &col 15698 if err := awsAwsjson11_deserializeDocumentUsageInstruction(&destAddr, value); err != nil { 15699 return err 15700 } 15701 col = *destAddr 15702 cv = append(cv, col) 15703 15704 } 15705 *v = cv 15706 return nil 15707} 15708 15709func awsAwsjson11_deserializeOpDocumentAcceptPortfolioShareOutput(v **AcceptPortfolioShareOutput, value interface{}) error { 15710 if v == nil { 15711 return fmt.Errorf("unexpected nil of type %T", v) 15712 } 15713 if value == nil { 15714 return nil 15715 } 15716 15717 shape, ok := value.(map[string]interface{}) 15718 if !ok { 15719 return fmt.Errorf("unexpected JSON type %v", value) 15720 } 15721 15722 var sv *AcceptPortfolioShareOutput 15723 if *v == nil { 15724 sv = &AcceptPortfolioShareOutput{} 15725 } else { 15726 sv = *v 15727 } 15728 15729 for key, value := range shape { 15730 switch key { 15731 default: 15732 _, _ = key, value 15733 15734 } 15735 } 15736 *v = sv 15737 return nil 15738} 15739 15740func awsAwsjson11_deserializeOpDocumentAssociateBudgetWithResourceOutput(v **AssociateBudgetWithResourceOutput, value interface{}) error { 15741 if v == nil { 15742 return fmt.Errorf("unexpected nil of type %T", v) 15743 } 15744 if value == nil { 15745 return nil 15746 } 15747 15748 shape, ok := value.(map[string]interface{}) 15749 if !ok { 15750 return fmt.Errorf("unexpected JSON type %v", value) 15751 } 15752 15753 var sv *AssociateBudgetWithResourceOutput 15754 if *v == nil { 15755 sv = &AssociateBudgetWithResourceOutput{} 15756 } else { 15757 sv = *v 15758 } 15759 15760 for key, value := range shape { 15761 switch key { 15762 default: 15763 _, _ = key, value 15764 15765 } 15766 } 15767 *v = sv 15768 return nil 15769} 15770 15771func awsAwsjson11_deserializeOpDocumentAssociatePrincipalWithPortfolioOutput(v **AssociatePrincipalWithPortfolioOutput, value interface{}) error { 15772 if v == nil { 15773 return fmt.Errorf("unexpected nil of type %T", v) 15774 } 15775 if value == nil { 15776 return nil 15777 } 15778 15779 shape, ok := value.(map[string]interface{}) 15780 if !ok { 15781 return fmt.Errorf("unexpected JSON type %v", value) 15782 } 15783 15784 var sv *AssociatePrincipalWithPortfolioOutput 15785 if *v == nil { 15786 sv = &AssociatePrincipalWithPortfolioOutput{} 15787 } else { 15788 sv = *v 15789 } 15790 15791 for key, value := range shape { 15792 switch key { 15793 default: 15794 _, _ = key, value 15795 15796 } 15797 } 15798 *v = sv 15799 return nil 15800} 15801 15802func awsAwsjson11_deserializeOpDocumentAssociateProductWithPortfolioOutput(v **AssociateProductWithPortfolioOutput, value interface{}) error { 15803 if v == nil { 15804 return fmt.Errorf("unexpected nil of type %T", v) 15805 } 15806 if value == nil { 15807 return nil 15808 } 15809 15810 shape, ok := value.(map[string]interface{}) 15811 if !ok { 15812 return fmt.Errorf("unexpected JSON type %v", value) 15813 } 15814 15815 var sv *AssociateProductWithPortfolioOutput 15816 if *v == nil { 15817 sv = &AssociateProductWithPortfolioOutput{} 15818 } else { 15819 sv = *v 15820 } 15821 15822 for key, value := range shape { 15823 switch key { 15824 default: 15825 _, _ = key, value 15826 15827 } 15828 } 15829 *v = sv 15830 return nil 15831} 15832 15833func awsAwsjson11_deserializeOpDocumentAssociateServiceActionWithProvisioningArtifactOutput(v **AssociateServiceActionWithProvisioningArtifactOutput, value interface{}) error { 15834 if v == nil { 15835 return fmt.Errorf("unexpected nil of type %T", v) 15836 } 15837 if value == nil { 15838 return nil 15839 } 15840 15841 shape, ok := value.(map[string]interface{}) 15842 if !ok { 15843 return fmt.Errorf("unexpected JSON type %v", value) 15844 } 15845 15846 var sv *AssociateServiceActionWithProvisioningArtifactOutput 15847 if *v == nil { 15848 sv = &AssociateServiceActionWithProvisioningArtifactOutput{} 15849 } else { 15850 sv = *v 15851 } 15852 15853 for key, value := range shape { 15854 switch key { 15855 default: 15856 _, _ = key, value 15857 15858 } 15859 } 15860 *v = sv 15861 return nil 15862} 15863 15864func awsAwsjson11_deserializeOpDocumentAssociateTagOptionWithResourceOutput(v **AssociateTagOptionWithResourceOutput, value interface{}) error { 15865 if v == nil { 15866 return fmt.Errorf("unexpected nil of type %T", v) 15867 } 15868 if value == nil { 15869 return nil 15870 } 15871 15872 shape, ok := value.(map[string]interface{}) 15873 if !ok { 15874 return fmt.Errorf("unexpected JSON type %v", value) 15875 } 15876 15877 var sv *AssociateTagOptionWithResourceOutput 15878 if *v == nil { 15879 sv = &AssociateTagOptionWithResourceOutput{} 15880 } else { 15881 sv = *v 15882 } 15883 15884 for key, value := range shape { 15885 switch key { 15886 default: 15887 _, _ = key, value 15888 15889 } 15890 } 15891 *v = sv 15892 return nil 15893} 15894 15895func awsAwsjson11_deserializeOpDocumentBatchAssociateServiceActionWithProvisioningArtifactOutput(v **BatchAssociateServiceActionWithProvisioningArtifactOutput, value interface{}) error { 15896 if v == nil { 15897 return fmt.Errorf("unexpected nil of type %T", v) 15898 } 15899 if value == nil { 15900 return nil 15901 } 15902 15903 shape, ok := value.(map[string]interface{}) 15904 if !ok { 15905 return fmt.Errorf("unexpected JSON type %v", value) 15906 } 15907 15908 var sv *BatchAssociateServiceActionWithProvisioningArtifactOutput 15909 if *v == nil { 15910 sv = &BatchAssociateServiceActionWithProvisioningArtifactOutput{} 15911 } else { 15912 sv = *v 15913 } 15914 15915 for key, value := range shape { 15916 switch key { 15917 case "FailedServiceActionAssociations": 15918 if err := awsAwsjson11_deserializeDocumentFailedServiceActionAssociations(&sv.FailedServiceActionAssociations, value); err != nil { 15919 return err 15920 } 15921 15922 default: 15923 _, _ = key, value 15924 15925 } 15926 } 15927 *v = sv 15928 return nil 15929} 15930 15931func awsAwsjson11_deserializeOpDocumentBatchDisassociateServiceActionFromProvisioningArtifactOutput(v **BatchDisassociateServiceActionFromProvisioningArtifactOutput, value interface{}) error { 15932 if v == nil { 15933 return fmt.Errorf("unexpected nil of type %T", v) 15934 } 15935 if value == nil { 15936 return nil 15937 } 15938 15939 shape, ok := value.(map[string]interface{}) 15940 if !ok { 15941 return fmt.Errorf("unexpected JSON type %v", value) 15942 } 15943 15944 var sv *BatchDisassociateServiceActionFromProvisioningArtifactOutput 15945 if *v == nil { 15946 sv = &BatchDisassociateServiceActionFromProvisioningArtifactOutput{} 15947 } else { 15948 sv = *v 15949 } 15950 15951 for key, value := range shape { 15952 switch key { 15953 case "FailedServiceActionAssociations": 15954 if err := awsAwsjson11_deserializeDocumentFailedServiceActionAssociations(&sv.FailedServiceActionAssociations, value); err != nil { 15955 return err 15956 } 15957 15958 default: 15959 _, _ = key, value 15960 15961 } 15962 } 15963 *v = sv 15964 return nil 15965} 15966 15967func awsAwsjson11_deserializeOpDocumentCopyProductOutput(v **CopyProductOutput, value interface{}) error { 15968 if v == nil { 15969 return fmt.Errorf("unexpected nil of type %T", v) 15970 } 15971 if value == nil { 15972 return nil 15973 } 15974 15975 shape, ok := value.(map[string]interface{}) 15976 if !ok { 15977 return fmt.Errorf("unexpected JSON type %v", value) 15978 } 15979 15980 var sv *CopyProductOutput 15981 if *v == nil { 15982 sv = &CopyProductOutput{} 15983 } else { 15984 sv = *v 15985 } 15986 15987 for key, value := range shape { 15988 switch key { 15989 case "CopyProductToken": 15990 if value != nil { 15991 jtv, ok := value.(string) 15992 if !ok { 15993 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 15994 } 15995 sv.CopyProductToken = ptr.String(jtv) 15996 } 15997 15998 default: 15999 _, _ = key, value 16000 16001 } 16002 } 16003 *v = sv 16004 return nil 16005} 16006 16007func awsAwsjson11_deserializeOpDocumentCreateConstraintOutput(v **CreateConstraintOutput, value interface{}) error { 16008 if v == nil { 16009 return fmt.Errorf("unexpected nil of type %T", v) 16010 } 16011 if value == nil { 16012 return nil 16013 } 16014 16015 shape, ok := value.(map[string]interface{}) 16016 if !ok { 16017 return fmt.Errorf("unexpected JSON type %v", value) 16018 } 16019 16020 var sv *CreateConstraintOutput 16021 if *v == nil { 16022 sv = &CreateConstraintOutput{} 16023 } else { 16024 sv = *v 16025 } 16026 16027 for key, value := range shape { 16028 switch key { 16029 case "ConstraintDetail": 16030 if err := awsAwsjson11_deserializeDocumentConstraintDetail(&sv.ConstraintDetail, value); err != nil { 16031 return err 16032 } 16033 16034 case "ConstraintParameters": 16035 if value != nil { 16036 jtv, ok := value.(string) 16037 if !ok { 16038 return fmt.Errorf("expected ConstraintParameters to be of type string, got %T instead", value) 16039 } 16040 sv.ConstraintParameters = ptr.String(jtv) 16041 } 16042 16043 case "Status": 16044 if value != nil { 16045 jtv, ok := value.(string) 16046 if !ok { 16047 return fmt.Errorf("expected Status to be of type string, got %T instead", value) 16048 } 16049 sv.Status = types.Status(jtv) 16050 } 16051 16052 default: 16053 _, _ = key, value 16054 16055 } 16056 } 16057 *v = sv 16058 return nil 16059} 16060 16061func awsAwsjson11_deserializeOpDocumentCreatePortfolioOutput(v **CreatePortfolioOutput, value interface{}) error { 16062 if v == nil { 16063 return fmt.Errorf("unexpected nil of type %T", v) 16064 } 16065 if value == nil { 16066 return nil 16067 } 16068 16069 shape, ok := value.(map[string]interface{}) 16070 if !ok { 16071 return fmt.Errorf("unexpected JSON type %v", value) 16072 } 16073 16074 var sv *CreatePortfolioOutput 16075 if *v == nil { 16076 sv = &CreatePortfolioOutput{} 16077 } else { 16078 sv = *v 16079 } 16080 16081 for key, value := range shape { 16082 switch key { 16083 case "PortfolioDetail": 16084 if err := awsAwsjson11_deserializeDocumentPortfolioDetail(&sv.PortfolioDetail, value); err != nil { 16085 return err 16086 } 16087 16088 case "Tags": 16089 if err := awsAwsjson11_deserializeDocumentTags(&sv.Tags, value); err != nil { 16090 return err 16091 } 16092 16093 default: 16094 _, _ = key, value 16095 16096 } 16097 } 16098 *v = sv 16099 return nil 16100} 16101 16102func awsAwsjson11_deserializeOpDocumentCreatePortfolioShareOutput(v **CreatePortfolioShareOutput, value interface{}) error { 16103 if v == nil { 16104 return fmt.Errorf("unexpected nil of type %T", v) 16105 } 16106 if value == nil { 16107 return nil 16108 } 16109 16110 shape, ok := value.(map[string]interface{}) 16111 if !ok { 16112 return fmt.Errorf("unexpected JSON type %v", value) 16113 } 16114 16115 var sv *CreatePortfolioShareOutput 16116 if *v == nil { 16117 sv = &CreatePortfolioShareOutput{} 16118 } else { 16119 sv = *v 16120 } 16121 16122 for key, value := range shape { 16123 switch key { 16124 case "PortfolioShareToken": 16125 if value != nil { 16126 jtv, ok := value.(string) 16127 if !ok { 16128 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 16129 } 16130 sv.PortfolioShareToken = ptr.String(jtv) 16131 } 16132 16133 default: 16134 _, _ = key, value 16135 16136 } 16137 } 16138 *v = sv 16139 return nil 16140} 16141 16142func awsAwsjson11_deserializeOpDocumentCreateProductOutput(v **CreateProductOutput, value interface{}) error { 16143 if v == nil { 16144 return fmt.Errorf("unexpected nil of type %T", v) 16145 } 16146 if value == nil { 16147 return nil 16148 } 16149 16150 shape, ok := value.(map[string]interface{}) 16151 if !ok { 16152 return fmt.Errorf("unexpected JSON type %v", value) 16153 } 16154 16155 var sv *CreateProductOutput 16156 if *v == nil { 16157 sv = &CreateProductOutput{} 16158 } else { 16159 sv = *v 16160 } 16161 16162 for key, value := range shape { 16163 switch key { 16164 case "ProductViewDetail": 16165 if err := awsAwsjson11_deserializeDocumentProductViewDetail(&sv.ProductViewDetail, value); err != nil { 16166 return err 16167 } 16168 16169 case "ProvisioningArtifactDetail": 16170 if err := awsAwsjson11_deserializeDocumentProvisioningArtifactDetail(&sv.ProvisioningArtifactDetail, value); err != nil { 16171 return err 16172 } 16173 16174 case "Tags": 16175 if err := awsAwsjson11_deserializeDocumentTags(&sv.Tags, value); err != nil { 16176 return err 16177 } 16178 16179 default: 16180 _, _ = key, value 16181 16182 } 16183 } 16184 *v = sv 16185 return nil 16186} 16187 16188func awsAwsjson11_deserializeOpDocumentCreateProvisionedProductPlanOutput(v **CreateProvisionedProductPlanOutput, value interface{}) error { 16189 if v == nil { 16190 return fmt.Errorf("unexpected nil of type %T", v) 16191 } 16192 if value == nil { 16193 return nil 16194 } 16195 16196 shape, ok := value.(map[string]interface{}) 16197 if !ok { 16198 return fmt.Errorf("unexpected JSON type %v", value) 16199 } 16200 16201 var sv *CreateProvisionedProductPlanOutput 16202 if *v == nil { 16203 sv = &CreateProvisionedProductPlanOutput{} 16204 } else { 16205 sv = *v 16206 } 16207 16208 for key, value := range shape { 16209 switch key { 16210 case "PlanId": 16211 if value != nil { 16212 jtv, ok := value.(string) 16213 if !ok { 16214 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 16215 } 16216 sv.PlanId = ptr.String(jtv) 16217 } 16218 16219 case "PlanName": 16220 if value != nil { 16221 jtv, ok := value.(string) 16222 if !ok { 16223 return fmt.Errorf("expected ProvisionedProductPlanName to be of type string, got %T instead", value) 16224 } 16225 sv.PlanName = ptr.String(jtv) 16226 } 16227 16228 case "ProvisionedProductName": 16229 if value != nil { 16230 jtv, ok := value.(string) 16231 if !ok { 16232 return fmt.Errorf("expected ProvisionedProductName to be of type string, got %T instead", value) 16233 } 16234 sv.ProvisionedProductName = ptr.String(jtv) 16235 } 16236 16237 case "ProvisioningArtifactId": 16238 if value != nil { 16239 jtv, ok := value.(string) 16240 if !ok { 16241 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 16242 } 16243 sv.ProvisioningArtifactId = ptr.String(jtv) 16244 } 16245 16246 case "ProvisionProductId": 16247 if value != nil { 16248 jtv, ok := value.(string) 16249 if !ok { 16250 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 16251 } 16252 sv.ProvisionProductId = ptr.String(jtv) 16253 } 16254 16255 default: 16256 _, _ = key, value 16257 16258 } 16259 } 16260 *v = sv 16261 return nil 16262} 16263 16264func awsAwsjson11_deserializeOpDocumentCreateProvisioningArtifactOutput(v **CreateProvisioningArtifactOutput, value interface{}) error { 16265 if v == nil { 16266 return fmt.Errorf("unexpected nil of type %T", v) 16267 } 16268 if value == nil { 16269 return nil 16270 } 16271 16272 shape, ok := value.(map[string]interface{}) 16273 if !ok { 16274 return fmt.Errorf("unexpected JSON type %v", value) 16275 } 16276 16277 var sv *CreateProvisioningArtifactOutput 16278 if *v == nil { 16279 sv = &CreateProvisioningArtifactOutput{} 16280 } else { 16281 sv = *v 16282 } 16283 16284 for key, value := range shape { 16285 switch key { 16286 case "Info": 16287 if err := awsAwsjson11_deserializeDocumentProvisioningArtifactInfo(&sv.Info, value); err != nil { 16288 return err 16289 } 16290 16291 case "ProvisioningArtifactDetail": 16292 if err := awsAwsjson11_deserializeDocumentProvisioningArtifactDetail(&sv.ProvisioningArtifactDetail, value); err != nil { 16293 return err 16294 } 16295 16296 case "Status": 16297 if value != nil { 16298 jtv, ok := value.(string) 16299 if !ok { 16300 return fmt.Errorf("expected Status to be of type string, got %T instead", value) 16301 } 16302 sv.Status = types.Status(jtv) 16303 } 16304 16305 default: 16306 _, _ = key, value 16307 16308 } 16309 } 16310 *v = sv 16311 return nil 16312} 16313 16314func awsAwsjson11_deserializeOpDocumentCreateServiceActionOutput(v **CreateServiceActionOutput, value interface{}) error { 16315 if v == nil { 16316 return fmt.Errorf("unexpected nil of type %T", v) 16317 } 16318 if value == nil { 16319 return nil 16320 } 16321 16322 shape, ok := value.(map[string]interface{}) 16323 if !ok { 16324 return fmt.Errorf("unexpected JSON type %v", value) 16325 } 16326 16327 var sv *CreateServiceActionOutput 16328 if *v == nil { 16329 sv = &CreateServiceActionOutput{} 16330 } else { 16331 sv = *v 16332 } 16333 16334 for key, value := range shape { 16335 switch key { 16336 case "ServiceActionDetail": 16337 if err := awsAwsjson11_deserializeDocumentServiceActionDetail(&sv.ServiceActionDetail, value); err != nil { 16338 return err 16339 } 16340 16341 default: 16342 _, _ = key, value 16343 16344 } 16345 } 16346 *v = sv 16347 return nil 16348} 16349 16350func awsAwsjson11_deserializeOpDocumentCreateTagOptionOutput(v **CreateTagOptionOutput, value interface{}) error { 16351 if v == nil { 16352 return fmt.Errorf("unexpected nil of type %T", v) 16353 } 16354 if value == nil { 16355 return nil 16356 } 16357 16358 shape, ok := value.(map[string]interface{}) 16359 if !ok { 16360 return fmt.Errorf("unexpected JSON type %v", value) 16361 } 16362 16363 var sv *CreateTagOptionOutput 16364 if *v == nil { 16365 sv = &CreateTagOptionOutput{} 16366 } else { 16367 sv = *v 16368 } 16369 16370 for key, value := range shape { 16371 switch key { 16372 case "TagOptionDetail": 16373 if err := awsAwsjson11_deserializeDocumentTagOptionDetail(&sv.TagOptionDetail, value); err != nil { 16374 return err 16375 } 16376 16377 default: 16378 _, _ = key, value 16379 16380 } 16381 } 16382 *v = sv 16383 return nil 16384} 16385 16386func awsAwsjson11_deserializeOpDocumentDeleteConstraintOutput(v **DeleteConstraintOutput, value interface{}) error { 16387 if v == nil { 16388 return fmt.Errorf("unexpected nil of type %T", v) 16389 } 16390 if value == nil { 16391 return nil 16392 } 16393 16394 shape, ok := value.(map[string]interface{}) 16395 if !ok { 16396 return fmt.Errorf("unexpected JSON type %v", value) 16397 } 16398 16399 var sv *DeleteConstraintOutput 16400 if *v == nil { 16401 sv = &DeleteConstraintOutput{} 16402 } else { 16403 sv = *v 16404 } 16405 16406 for key, value := range shape { 16407 switch key { 16408 default: 16409 _, _ = key, value 16410 16411 } 16412 } 16413 *v = sv 16414 return nil 16415} 16416 16417func awsAwsjson11_deserializeOpDocumentDeletePortfolioOutput(v **DeletePortfolioOutput, value interface{}) error { 16418 if v == nil { 16419 return fmt.Errorf("unexpected nil of type %T", v) 16420 } 16421 if value == nil { 16422 return nil 16423 } 16424 16425 shape, ok := value.(map[string]interface{}) 16426 if !ok { 16427 return fmt.Errorf("unexpected JSON type %v", value) 16428 } 16429 16430 var sv *DeletePortfolioOutput 16431 if *v == nil { 16432 sv = &DeletePortfolioOutput{} 16433 } else { 16434 sv = *v 16435 } 16436 16437 for key, value := range shape { 16438 switch key { 16439 default: 16440 _, _ = key, value 16441 16442 } 16443 } 16444 *v = sv 16445 return nil 16446} 16447 16448func awsAwsjson11_deserializeOpDocumentDeletePortfolioShareOutput(v **DeletePortfolioShareOutput, value interface{}) error { 16449 if v == nil { 16450 return fmt.Errorf("unexpected nil of type %T", v) 16451 } 16452 if value == nil { 16453 return nil 16454 } 16455 16456 shape, ok := value.(map[string]interface{}) 16457 if !ok { 16458 return fmt.Errorf("unexpected JSON type %v", value) 16459 } 16460 16461 var sv *DeletePortfolioShareOutput 16462 if *v == nil { 16463 sv = &DeletePortfolioShareOutput{} 16464 } else { 16465 sv = *v 16466 } 16467 16468 for key, value := range shape { 16469 switch key { 16470 case "PortfolioShareToken": 16471 if value != nil { 16472 jtv, ok := value.(string) 16473 if !ok { 16474 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 16475 } 16476 sv.PortfolioShareToken = ptr.String(jtv) 16477 } 16478 16479 default: 16480 _, _ = key, value 16481 16482 } 16483 } 16484 *v = sv 16485 return nil 16486} 16487 16488func awsAwsjson11_deserializeOpDocumentDeleteProductOutput(v **DeleteProductOutput, value interface{}) error { 16489 if v == nil { 16490 return fmt.Errorf("unexpected nil of type %T", v) 16491 } 16492 if value == nil { 16493 return nil 16494 } 16495 16496 shape, ok := value.(map[string]interface{}) 16497 if !ok { 16498 return fmt.Errorf("unexpected JSON type %v", value) 16499 } 16500 16501 var sv *DeleteProductOutput 16502 if *v == nil { 16503 sv = &DeleteProductOutput{} 16504 } else { 16505 sv = *v 16506 } 16507 16508 for key, value := range shape { 16509 switch key { 16510 default: 16511 _, _ = key, value 16512 16513 } 16514 } 16515 *v = sv 16516 return nil 16517} 16518 16519func awsAwsjson11_deserializeOpDocumentDeleteProvisionedProductPlanOutput(v **DeleteProvisionedProductPlanOutput, value interface{}) error { 16520 if v == nil { 16521 return fmt.Errorf("unexpected nil of type %T", v) 16522 } 16523 if value == nil { 16524 return nil 16525 } 16526 16527 shape, ok := value.(map[string]interface{}) 16528 if !ok { 16529 return fmt.Errorf("unexpected JSON type %v", value) 16530 } 16531 16532 var sv *DeleteProvisionedProductPlanOutput 16533 if *v == nil { 16534 sv = &DeleteProvisionedProductPlanOutput{} 16535 } else { 16536 sv = *v 16537 } 16538 16539 for key, value := range shape { 16540 switch key { 16541 default: 16542 _, _ = key, value 16543 16544 } 16545 } 16546 *v = sv 16547 return nil 16548} 16549 16550func awsAwsjson11_deserializeOpDocumentDeleteProvisioningArtifactOutput(v **DeleteProvisioningArtifactOutput, value interface{}) error { 16551 if v == nil { 16552 return fmt.Errorf("unexpected nil of type %T", v) 16553 } 16554 if value == nil { 16555 return nil 16556 } 16557 16558 shape, ok := value.(map[string]interface{}) 16559 if !ok { 16560 return fmt.Errorf("unexpected JSON type %v", value) 16561 } 16562 16563 var sv *DeleteProvisioningArtifactOutput 16564 if *v == nil { 16565 sv = &DeleteProvisioningArtifactOutput{} 16566 } else { 16567 sv = *v 16568 } 16569 16570 for key, value := range shape { 16571 switch key { 16572 default: 16573 _, _ = key, value 16574 16575 } 16576 } 16577 *v = sv 16578 return nil 16579} 16580 16581func awsAwsjson11_deserializeOpDocumentDeleteServiceActionOutput(v **DeleteServiceActionOutput, value interface{}) error { 16582 if v == nil { 16583 return fmt.Errorf("unexpected nil of type %T", v) 16584 } 16585 if value == nil { 16586 return nil 16587 } 16588 16589 shape, ok := value.(map[string]interface{}) 16590 if !ok { 16591 return fmt.Errorf("unexpected JSON type %v", value) 16592 } 16593 16594 var sv *DeleteServiceActionOutput 16595 if *v == nil { 16596 sv = &DeleteServiceActionOutput{} 16597 } else { 16598 sv = *v 16599 } 16600 16601 for key, value := range shape { 16602 switch key { 16603 default: 16604 _, _ = key, value 16605 16606 } 16607 } 16608 *v = sv 16609 return nil 16610} 16611 16612func awsAwsjson11_deserializeOpDocumentDeleteTagOptionOutput(v **DeleteTagOptionOutput, value interface{}) error { 16613 if v == nil { 16614 return fmt.Errorf("unexpected nil of type %T", v) 16615 } 16616 if value == nil { 16617 return nil 16618 } 16619 16620 shape, ok := value.(map[string]interface{}) 16621 if !ok { 16622 return fmt.Errorf("unexpected JSON type %v", value) 16623 } 16624 16625 var sv *DeleteTagOptionOutput 16626 if *v == nil { 16627 sv = &DeleteTagOptionOutput{} 16628 } else { 16629 sv = *v 16630 } 16631 16632 for key, value := range shape { 16633 switch key { 16634 default: 16635 _, _ = key, value 16636 16637 } 16638 } 16639 *v = sv 16640 return nil 16641} 16642 16643func awsAwsjson11_deserializeOpDocumentDescribeConstraintOutput(v **DescribeConstraintOutput, value interface{}) error { 16644 if v == nil { 16645 return fmt.Errorf("unexpected nil of type %T", v) 16646 } 16647 if value == nil { 16648 return nil 16649 } 16650 16651 shape, ok := value.(map[string]interface{}) 16652 if !ok { 16653 return fmt.Errorf("unexpected JSON type %v", value) 16654 } 16655 16656 var sv *DescribeConstraintOutput 16657 if *v == nil { 16658 sv = &DescribeConstraintOutput{} 16659 } else { 16660 sv = *v 16661 } 16662 16663 for key, value := range shape { 16664 switch key { 16665 case "ConstraintDetail": 16666 if err := awsAwsjson11_deserializeDocumentConstraintDetail(&sv.ConstraintDetail, value); err != nil { 16667 return err 16668 } 16669 16670 case "ConstraintParameters": 16671 if value != nil { 16672 jtv, ok := value.(string) 16673 if !ok { 16674 return fmt.Errorf("expected ConstraintParameters to be of type string, got %T instead", value) 16675 } 16676 sv.ConstraintParameters = ptr.String(jtv) 16677 } 16678 16679 case "Status": 16680 if value != nil { 16681 jtv, ok := value.(string) 16682 if !ok { 16683 return fmt.Errorf("expected Status to be of type string, got %T instead", value) 16684 } 16685 sv.Status = types.Status(jtv) 16686 } 16687 16688 default: 16689 _, _ = key, value 16690 16691 } 16692 } 16693 *v = sv 16694 return nil 16695} 16696 16697func awsAwsjson11_deserializeOpDocumentDescribeCopyProductStatusOutput(v **DescribeCopyProductStatusOutput, value interface{}) error { 16698 if v == nil { 16699 return fmt.Errorf("unexpected nil of type %T", v) 16700 } 16701 if value == nil { 16702 return nil 16703 } 16704 16705 shape, ok := value.(map[string]interface{}) 16706 if !ok { 16707 return fmt.Errorf("unexpected JSON type %v", value) 16708 } 16709 16710 var sv *DescribeCopyProductStatusOutput 16711 if *v == nil { 16712 sv = &DescribeCopyProductStatusOutput{} 16713 } else { 16714 sv = *v 16715 } 16716 16717 for key, value := range shape { 16718 switch key { 16719 case "CopyProductStatus": 16720 if value != nil { 16721 jtv, ok := value.(string) 16722 if !ok { 16723 return fmt.Errorf("expected CopyProductStatus to be of type string, got %T instead", value) 16724 } 16725 sv.CopyProductStatus = types.CopyProductStatus(jtv) 16726 } 16727 16728 case "StatusDetail": 16729 if value != nil { 16730 jtv, ok := value.(string) 16731 if !ok { 16732 return fmt.Errorf("expected StatusDetail to be of type string, got %T instead", value) 16733 } 16734 sv.StatusDetail = ptr.String(jtv) 16735 } 16736 16737 case "TargetProductId": 16738 if value != nil { 16739 jtv, ok := value.(string) 16740 if !ok { 16741 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 16742 } 16743 sv.TargetProductId = ptr.String(jtv) 16744 } 16745 16746 default: 16747 _, _ = key, value 16748 16749 } 16750 } 16751 *v = sv 16752 return nil 16753} 16754 16755func awsAwsjson11_deserializeOpDocumentDescribePortfolioOutput(v **DescribePortfolioOutput, value interface{}) error { 16756 if v == nil { 16757 return fmt.Errorf("unexpected nil of type %T", v) 16758 } 16759 if value == nil { 16760 return nil 16761 } 16762 16763 shape, ok := value.(map[string]interface{}) 16764 if !ok { 16765 return fmt.Errorf("unexpected JSON type %v", value) 16766 } 16767 16768 var sv *DescribePortfolioOutput 16769 if *v == nil { 16770 sv = &DescribePortfolioOutput{} 16771 } else { 16772 sv = *v 16773 } 16774 16775 for key, value := range shape { 16776 switch key { 16777 case "Budgets": 16778 if err := awsAwsjson11_deserializeDocumentBudgets(&sv.Budgets, value); err != nil { 16779 return err 16780 } 16781 16782 case "PortfolioDetail": 16783 if err := awsAwsjson11_deserializeDocumentPortfolioDetail(&sv.PortfolioDetail, value); err != nil { 16784 return err 16785 } 16786 16787 case "TagOptions": 16788 if err := awsAwsjson11_deserializeDocumentTagOptionDetails(&sv.TagOptions, value); err != nil { 16789 return err 16790 } 16791 16792 case "Tags": 16793 if err := awsAwsjson11_deserializeDocumentTags(&sv.Tags, value); err != nil { 16794 return err 16795 } 16796 16797 default: 16798 _, _ = key, value 16799 16800 } 16801 } 16802 *v = sv 16803 return nil 16804} 16805 16806func awsAwsjson11_deserializeOpDocumentDescribePortfolioSharesOutput(v **DescribePortfolioSharesOutput, value interface{}) error { 16807 if v == nil { 16808 return fmt.Errorf("unexpected nil of type %T", v) 16809 } 16810 if value == nil { 16811 return nil 16812 } 16813 16814 shape, ok := value.(map[string]interface{}) 16815 if !ok { 16816 return fmt.Errorf("unexpected JSON type %v", value) 16817 } 16818 16819 var sv *DescribePortfolioSharesOutput 16820 if *v == nil { 16821 sv = &DescribePortfolioSharesOutput{} 16822 } else { 16823 sv = *v 16824 } 16825 16826 for key, value := range shape { 16827 switch key { 16828 case "NextPageToken": 16829 if value != nil { 16830 jtv, ok := value.(string) 16831 if !ok { 16832 return fmt.Errorf("expected PageToken to be of type string, got %T instead", value) 16833 } 16834 sv.NextPageToken = ptr.String(jtv) 16835 } 16836 16837 case "PortfolioShareDetails": 16838 if err := awsAwsjson11_deserializeDocumentPortfolioShareDetails(&sv.PortfolioShareDetails, value); err != nil { 16839 return err 16840 } 16841 16842 default: 16843 _, _ = key, value 16844 16845 } 16846 } 16847 *v = sv 16848 return nil 16849} 16850 16851func awsAwsjson11_deserializeOpDocumentDescribePortfolioShareStatusOutput(v **DescribePortfolioShareStatusOutput, value interface{}) error { 16852 if v == nil { 16853 return fmt.Errorf("unexpected nil of type %T", v) 16854 } 16855 if value == nil { 16856 return nil 16857 } 16858 16859 shape, ok := value.(map[string]interface{}) 16860 if !ok { 16861 return fmt.Errorf("unexpected JSON type %v", value) 16862 } 16863 16864 var sv *DescribePortfolioShareStatusOutput 16865 if *v == nil { 16866 sv = &DescribePortfolioShareStatusOutput{} 16867 } else { 16868 sv = *v 16869 } 16870 16871 for key, value := range shape { 16872 switch key { 16873 case "OrganizationNodeValue": 16874 if value != nil { 16875 jtv, ok := value.(string) 16876 if !ok { 16877 return fmt.Errorf("expected OrganizationNodeValue to be of type string, got %T instead", value) 16878 } 16879 sv.OrganizationNodeValue = ptr.String(jtv) 16880 } 16881 16882 case "PortfolioId": 16883 if value != nil { 16884 jtv, ok := value.(string) 16885 if !ok { 16886 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 16887 } 16888 sv.PortfolioId = ptr.String(jtv) 16889 } 16890 16891 case "PortfolioShareToken": 16892 if value != nil { 16893 jtv, ok := value.(string) 16894 if !ok { 16895 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 16896 } 16897 sv.PortfolioShareToken = ptr.String(jtv) 16898 } 16899 16900 case "ShareDetails": 16901 if err := awsAwsjson11_deserializeDocumentShareDetails(&sv.ShareDetails, value); err != nil { 16902 return err 16903 } 16904 16905 case "Status": 16906 if value != nil { 16907 jtv, ok := value.(string) 16908 if !ok { 16909 return fmt.Errorf("expected ShareStatus to be of type string, got %T instead", value) 16910 } 16911 sv.Status = types.ShareStatus(jtv) 16912 } 16913 16914 default: 16915 _, _ = key, value 16916 16917 } 16918 } 16919 *v = sv 16920 return nil 16921} 16922 16923func awsAwsjson11_deserializeOpDocumentDescribeProductAsAdminOutput(v **DescribeProductAsAdminOutput, value interface{}) error { 16924 if v == nil { 16925 return fmt.Errorf("unexpected nil of type %T", v) 16926 } 16927 if value == nil { 16928 return nil 16929 } 16930 16931 shape, ok := value.(map[string]interface{}) 16932 if !ok { 16933 return fmt.Errorf("unexpected JSON type %v", value) 16934 } 16935 16936 var sv *DescribeProductAsAdminOutput 16937 if *v == nil { 16938 sv = &DescribeProductAsAdminOutput{} 16939 } else { 16940 sv = *v 16941 } 16942 16943 for key, value := range shape { 16944 switch key { 16945 case "Budgets": 16946 if err := awsAwsjson11_deserializeDocumentBudgets(&sv.Budgets, value); err != nil { 16947 return err 16948 } 16949 16950 case "ProductViewDetail": 16951 if err := awsAwsjson11_deserializeDocumentProductViewDetail(&sv.ProductViewDetail, value); err != nil { 16952 return err 16953 } 16954 16955 case "ProvisioningArtifactSummaries": 16956 if err := awsAwsjson11_deserializeDocumentProvisioningArtifactSummaries(&sv.ProvisioningArtifactSummaries, value); err != nil { 16957 return err 16958 } 16959 16960 case "TagOptions": 16961 if err := awsAwsjson11_deserializeDocumentTagOptionDetails(&sv.TagOptions, value); err != nil { 16962 return err 16963 } 16964 16965 case "Tags": 16966 if err := awsAwsjson11_deserializeDocumentTags(&sv.Tags, value); err != nil { 16967 return err 16968 } 16969 16970 default: 16971 _, _ = key, value 16972 16973 } 16974 } 16975 *v = sv 16976 return nil 16977} 16978 16979func awsAwsjson11_deserializeOpDocumentDescribeProductOutput(v **DescribeProductOutput, value interface{}) error { 16980 if v == nil { 16981 return fmt.Errorf("unexpected nil of type %T", v) 16982 } 16983 if value == nil { 16984 return nil 16985 } 16986 16987 shape, ok := value.(map[string]interface{}) 16988 if !ok { 16989 return fmt.Errorf("unexpected JSON type %v", value) 16990 } 16991 16992 var sv *DescribeProductOutput 16993 if *v == nil { 16994 sv = &DescribeProductOutput{} 16995 } else { 16996 sv = *v 16997 } 16998 16999 for key, value := range shape { 17000 switch key { 17001 case "Budgets": 17002 if err := awsAwsjson11_deserializeDocumentBudgets(&sv.Budgets, value); err != nil { 17003 return err 17004 } 17005 17006 case "LaunchPaths": 17007 if err := awsAwsjson11_deserializeDocumentLaunchPaths(&sv.LaunchPaths, value); err != nil { 17008 return err 17009 } 17010 17011 case "ProductViewSummary": 17012 if err := awsAwsjson11_deserializeDocumentProductViewSummary(&sv.ProductViewSummary, value); err != nil { 17013 return err 17014 } 17015 17016 case "ProvisioningArtifacts": 17017 if err := awsAwsjson11_deserializeDocumentProvisioningArtifacts(&sv.ProvisioningArtifacts, value); err != nil { 17018 return err 17019 } 17020 17021 default: 17022 _, _ = key, value 17023 17024 } 17025 } 17026 *v = sv 17027 return nil 17028} 17029 17030func awsAwsjson11_deserializeOpDocumentDescribeProductViewOutput(v **DescribeProductViewOutput, value interface{}) error { 17031 if v == nil { 17032 return fmt.Errorf("unexpected nil of type %T", v) 17033 } 17034 if value == nil { 17035 return nil 17036 } 17037 17038 shape, ok := value.(map[string]interface{}) 17039 if !ok { 17040 return fmt.Errorf("unexpected JSON type %v", value) 17041 } 17042 17043 var sv *DescribeProductViewOutput 17044 if *v == nil { 17045 sv = &DescribeProductViewOutput{} 17046 } else { 17047 sv = *v 17048 } 17049 17050 for key, value := range shape { 17051 switch key { 17052 case "ProductViewSummary": 17053 if err := awsAwsjson11_deserializeDocumentProductViewSummary(&sv.ProductViewSummary, value); err != nil { 17054 return err 17055 } 17056 17057 case "ProvisioningArtifacts": 17058 if err := awsAwsjson11_deserializeDocumentProvisioningArtifacts(&sv.ProvisioningArtifacts, value); err != nil { 17059 return err 17060 } 17061 17062 default: 17063 _, _ = key, value 17064 17065 } 17066 } 17067 *v = sv 17068 return nil 17069} 17070 17071func awsAwsjson11_deserializeOpDocumentDescribeProvisionedProductOutput(v **DescribeProvisionedProductOutput, value interface{}) error { 17072 if v == nil { 17073 return fmt.Errorf("unexpected nil of type %T", v) 17074 } 17075 if value == nil { 17076 return nil 17077 } 17078 17079 shape, ok := value.(map[string]interface{}) 17080 if !ok { 17081 return fmt.Errorf("unexpected JSON type %v", value) 17082 } 17083 17084 var sv *DescribeProvisionedProductOutput 17085 if *v == nil { 17086 sv = &DescribeProvisionedProductOutput{} 17087 } else { 17088 sv = *v 17089 } 17090 17091 for key, value := range shape { 17092 switch key { 17093 case "CloudWatchDashboards": 17094 if err := awsAwsjson11_deserializeDocumentCloudWatchDashboards(&sv.CloudWatchDashboards, value); err != nil { 17095 return err 17096 } 17097 17098 case "ProvisionedProductDetail": 17099 if err := awsAwsjson11_deserializeDocumentProvisionedProductDetail(&sv.ProvisionedProductDetail, value); err != nil { 17100 return err 17101 } 17102 17103 default: 17104 _, _ = key, value 17105 17106 } 17107 } 17108 *v = sv 17109 return nil 17110} 17111 17112func awsAwsjson11_deserializeOpDocumentDescribeProvisionedProductPlanOutput(v **DescribeProvisionedProductPlanOutput, value interface{}) error { 17113 if v == nil { 17114 return fmt.Errorf("unexpected nil of type %T", v) 17115 } 17116 if value == nil { 17117 return nil 17118 } 17119 17120 shape, ok := value.(map[string]interface{}) 17121 if !ok { 17122 return fmt.Errorf("unexpected JSON type %v", value) 17123 } 17124 17125 var sv *DescribeProvisionedProductPlanOutput 17126 if *v == nil { 17127 sv = &DescribeProvisionedProductPlanOutput{} 17128 } else { 17129 sv = *v 17130 } 17131 17132 for key, value := range shape { 17133 switch key { 17134 case "NextPageToken": 17135 if value != nil { 17136 jtv, ok := value.(string) 17137 if !ok { 17138 return fmt.Errorf("expected PageToken to be of type string, got %T instead", value) 17139 } 17140 sv.NextPageToken = ptr.String(jtv) 17141 } 17142 17143 case "ProvisionedProductPlanDetails": 17144 if err := awsAwsjson11_deserializeDocumentProvisionedProductPlanDetails(&sv.ProvisionedProductPlanDetails, value); err != nil { 17145 return err 17146 } 17147 17148 case "ResourceChanges": 17149 if err := awsAwsjson11_deserializeDocumentResourceChanges(&sv.ResourceChanges, value); err != nil { 17150 return err 17151 } 17152 17153 default: 17154 _, _ = key, value 17155 17156 } 17157 } 17158 *v = sv 17159 return nil 17160} 17161 17162func awsAwsjson11_deserializeOpDocumentDescribeProvisioningArtifactOutput(v **DescribeProvisioningArtifactOutput, value interface{}) error { 17163 if v == nil { 17164 return fmt.Errorf("unexpected nil of type %T", v) 17165 } 17166 if value == nil { 17167 return nil 17168 } 17169 17170 shape, ok := value.(map[string]interface{}) 17171 if !ok { 17172 return fmt.Errorf("unexpected JSON type %v", value) 17173 } 17174 17175 var sv *DescribeProvisioningArtifactOutput 17176 if *v == nil { 17177 sv = &DescribeProvisioningArtifactOutput{} 17178 } else { 17179 sv = *v 17180 } 17181 17182 for key, value := range shape { 17183 switch key { 17184 case "Info": 17185 if err := awsAwsjson11_deserializeDocumentProvisioningArtifactInfo(&sv.Info, value); err != nil { 17186 return err 17187 } 17188 17189 case "ProvisioningArtifactDetail": 17190 if err := awsAwsjson11_deserializeDocumentProvisioningArtifactDetail(&sv.ProvisioningArtifactDetail, value); err != nil { 17191 return err 17192 } 17193 17194 case "Status": 17195 if value != nil { 17196 jtv, ok := value.(string) 17197 if !ok { 17198 return fmt.Errorf("expected Status to be of type string, got %T instead", value) 17199 } 17200 sv.Status = types.Status(jtv) 17201 } 17202 17203 default: 17204 _, _ = key, value 17205 17206 } 17207 } 17208 *v = sv 17209 return nil 17210} 17211 17212func awsAwsjson11_deserializeOpDocumentDescribeProvisioningParametersOutput(v **DescribeProvisioningParametersOutput, value interface{}) error { 17213 if v == nil { 17214 return fmt.Errorf("unexpected nil of type %T", v) 17215 } 17216 if value == nil { 17217 return nil 17218 } 17219 17220 shape, ok := value.(map[string]interface{}) 17221 if !ok { 17222 return fmt.Errorf("unexpected JSON type %v", value) 17223 } 17224 17225 var sv *DescribeProvisioningParametersOutput 17226 if *v == nil { 17227 sv = &DescribeProvisioningParametersOutput{} 17228 } else { 17229 sv = *v 17230 } 17231 17232 for key, value := range shape { 17233 switch key { 17234 case "ConstraintSummaries": 17235 if err := awsAwsjson11_deserializeDocumentConstraintSummaries(&sv.ConstraintSummaries, value); err != nil { 17236 return err 17237 } 17238 17239 case "ProvisioningArtifactOutputs": 17240 if err := awsAwsjson11_deserializeDocumentProvisioningArtifactOutputs(&sv.ProvisioningArtifactOutputs, value); err != nil { 17241 return err 17242 } 17243 17244 case "ProvisioningArtifactParameters": 17245 if err := awsAwsjson11_deserializeDocumentProvisioningArtifactParameters(&sv.ProvisioningArtifactParameters, value); err != nil { 17246 return err 17247 } 17248 17249 case "ProvisioningArtifactPreferences": 17250 if err := awsAwsjson11_deserializeDocumentProvisioningArtifactPreferences(&sv.ProvisioningArtifactPreferences, value); err != nil { 17251 return err 17252 } 17253 17254 case "TagOptions": 17255 if err := awsAwsjson11_deserializeDocumentTagOptionSummaries(&sv.TagOptions, value); err != nil { 17256 return err 17257 } 17258 17259 case "UsageInstructions": 17260 if err := awsAwsjson11_deserializeDocumentUsageInstructions(&sv.UsageInstructions, value); err != nil { 17261 return err 17262 } 17263 17264 default: 17265 _, _ = key, value 17266 17267 } 17268 } 17269 *v = sv 17270 return nil 17271} 17272 17273func awsAwsjson11_deserializeOpDocumentDescribeRecordOutput(v **DescribeRecordOutput, value interface{}) error { 17274 if v == nil { 17275 return fmt.Errorf("unexpected nil of type %T", v) 17276 } 17277 if value == nil { 17278 return nil 17279 } 17280 17281 shape, ok := value.(map[string]interface{}) 17282 if !ok { 17283 return fmt.Errorf("unexpected JSON type %v", value) 17284 } 17285 17286 var sv *DescribeRecordOutput 17287 if *v == nil { 17288 sv = &DescribeRecordOutput{} 17289 } else { 17290 sv = *v 17291 } 17292 17293 for key, value := range shape { 17294 switch key { 17295 case "NextPageToken": 17296 if value != nil { 17297 jtv, ok := value.(string) 17298 if !ok { 17299 return fmt.Errorf("expected PageToken to be of type string, got %T instead", value) 17300 } 17301 sv.NextPageToken = ptr.String(jtv) 17302 } 17303 17304 case "RecordDetail": 17305 if err := awsAwsjson11_deserializeDocumentRecordDetail(&sv.RecordDetail, value); err != nil { 17306 return err 17307 } 17308 17309 case "RecordOutputs": 17310 if err := awsAwsjson11_deserializeDocumentRecordOutputs(&sv.RecordOutputs, value); err != nil { 17311 return err 17312 } 17313 17314 default: 17315 _, _ = key, value 17316 17317 } 17318 } 17319 *v = sv 17320 return nil 17321} 17322 17323func awsAwsjson11_deserializeOpDocumentDescribeServiceActionExecutionParametersOutput(v **DescribeServiceActionExecutionParametersOutput, value interface{}) error { 17324 if v == nil { 17325 return fmt.Errorf("unexpected nil of type %T", v) 17326 } 17327 if value == nil { 17328 return nil 17329 } 17330 17331 shape, ok := value.(map[string]interface{}) 17332 if !ok { 17333 return fmt.Errorf("unexpected JSON type %v", value) 17334 } 17335 17336 var sv *DescribeServiceActionExecutionParametersOutput 17337 if *v == nil { 17338 sv = &DescribeServiceActionExecutionParametersOutput{} 17339 } else { 17340 sv = *v 17341 } 17342 17343 for key, value := range shape { 17344 switch key { 17345 case "ServiceActionParameters": 17346 if err := awsAwsjson11_deserializeDocumentExecutionParameters(&sv.ServiceActionParameters, value); err != nil { 17347 return err 17348 } 17349 17350 default: 17351 _, _ = key, value 17352 17353 } 17354 } 17355 *v = sv 17356 return nil 17357} 17358 17359func awsAwsjson11_deserializeOpDocumentDescribeServiceActionOutput(v **DescribeServiceActionOutput, value interface{}) error { 17360 if v == nil { 17361 return fmt.Errorf("unexpected nil of type %T", v) 17362 } 17363 if value == nil { 17364 return nil 17365 } 17366 17367 shape, ok := value.(map[string]interface{}) 17368 if !ok { 17369 return fmt.Errorf("unexpected JSON type %v", value) 17370 } 17371 17372 var sv *DescribeServiceActionOutput 17373 if *v == nil { 17374 sv = &DescribeServiceActionOutput{} 17375 } else { 17376 sv = *v 17377 } 17378 17379 for key, value := range shape { 17380 switch key { 17381 case "ServiceActionDetail": 17382 if err := awsAwsjson11_deserializeDocumentServiceActionDetail(&sv.ServiceActionDetail, value); err != nil { 17383 return err 17384 } 17385 17386 default: 17387 _, _ = key, value 17388 17389 } 17390 } 17391 *v = sv 17392 return nil 17393} 17394 17395func awsAwsjson11_deserializeOpDocumentDescribeTagOptionOutput(v **DescribeTagOptionOutput, value interface{}) error { 17396 if v == nil { 17397 return fmt.Errorf("unexpected nil of type %T", v) 17398 } 17399 if value == nil { 17400 return nil 17401 } 17402 17403 shape, ok := value.(map[string]interface{}) 17404 if !ok { 17405 return fmt.Errorf("unexpected JSON type %v", value) 17406 } 17407 17408 var sv *DescribeTagOptionOutput 17409 if *v == nil { 17410 sv = &DescribeTagOptionOutput{} 17411 } else { 17412 sv = *v 17413 } 17414 17415 for key, value := range shape { 17416 switch key { 17417 case "TagOptionDetail": 17418 if err := awsAwsjson11_deserializeDocumentTagOptionDetail(&sv.TagOptionDetail, value); err != nil { 17419 return err 17420 } 17421 17422 default: 17423 _, _ = key, value 17424 17425 } 17426 } 17427 *v = sv 17428 return nil 17429} 17430 17431func awsAwsjson11_deserializeOpDocumentDisableAWSOrganizationsAccessOutput(v **DisableAWSOrganizationsAccessOutput, value interface{}) error { 17432 if v == nil { 17433 return fmt.Errorf("unexpected nil of type %T", v) 17434 } 17435 if value == nil { 17436 return nil 17437 } 17438 17439 shape, ok := value.(map[string]interface{}) 17440 if !ok { 17441 return fmt.Errorf("unexpected JSON type %v", value) 17442 } 17443 17444 var sv *DisableAWSOrganizationsAccessOutput 17445 if *v == nil { 17446 sv = &DisableAWSOrganizationsAccessOutput{} 17447 } else { 17448 sv = *v 17449 } 17450 17451 for key, value := range shape { 17452 switch key { 17453 default: 17454 _, _ = key, value 17455 17456 } 17457 } 17458 *v = sv 17459 return nil 17460} 17461 17462func awsAwsjson11_deserializeOpDocumentDisassociateBudgetFromResourceOutput(v **DisassociateBudgetFromResourceOutput, value interface{}) error { 17463 if v == nil { 17464 return fmt.Errorf("unexpected nil of type %T", v) 17465 } 17466 if value == nil { 17467 return nil 17468 } 17469 17470 shape, ok := value.(map[string]interface{}) 17471 if !ok { 17472 return fmt.Errorf("unexpected JSON type %v", value) 17473 } 17474 17475 var sv *DisassociateBudgetFromResourceOutput 17476 if *v == nil { 17477 sv = &DisassociateBudgetFromResourceOutput{} 17478 } else { 17479 sv = *v 17480 } 17481 17482 for key, value := range shape { 17483 switch key { 17484 default: 17485 _, _ = key, value 17486 17487 } 17488 } 17489 *v = sv 17490 return nil 17491} 17492 17493func awsAwsjson11_deserializeOpDocumentDisassociatePrincipalFromPortfolioOutput(v **DisassociatePrincipalFromPortfolioOutput, value interface{}) error { 17494 if v == nil { 17495 return fmt.Errorf("unexpected nil of type %T", v) 17496 } 17497 if value == nil { 17498 return nil 17499 } 17500 17501 shape, ok := value.(map[string]interface{}) 17502 if !ok { 17503 return fmt.Errorf("unexpected JSON type %v", value) 17504 } 17505 17506 var sv *DisassociatePrincipalFromPortfolioOutput 17507 if *v == nil { 17508 sv = &DisassociatePrincipalFromPortfolioOutput{} 17509 } else { 17510 sv = *v 17511 } 17512 17513 for key, value := range shape { 17514 switch key { 17515 default: 17516 _, _ = key, value 17517 17518 } 17519 } 17520 *v = sv 17521 return nil 17522} 17523 17524func awsAwsjson11_deserializeOpDocumentDisassociateProductFromPortfolioOutput(v **DisassociateProductFromPortfolioOutput, value interface{}) error { 17525 if v == nil { 17526 return fmt.Errorf("unexpected nil of type %T", v) 17527 } 17528 if value == nil { 17529 return nil 17530 } 17531 17532 shape, ok := value.(map[string]interface{}) 17533 if !ok { 17534 return fmt.Errorf("unexpected JSON type %v", value) 17535 } 17536 17537 var sv *DisassociateProductFromPortfolioOutput 17538 if *v == nil { 17539 sv = &DisassociateProductFromPortfolioOutput{} 17540 } else { 17541 sv = *v 17542 } 17543 17544 for key, value := range shape { 17545 switch key { 17546 default: 17547 _, _ = key, value 17548 17549 } 17550 } 17551 *v = sv 17552 return nil 17553} 17554 17555func awsAwsjson11_deserializeOpDocumentDisassociateServiceActionFromProvisioningArtifactOutput(v **DisassociateServiceActionFromProvisioningArtifactOutput, value interface{}) error { 17556 if v == nil { 17557 return fmt.Errorf("unexpected nil of type %T", v) 17558 } 17559 if value == nil { 17560 return nil 17561 } 17562 17563 shape, ok := value.(map[string]interface{}) 17564 if !ok { 17565 return fmt.Errorf("unexpected JSON type %v", value) 17566 } 17567 17568 var sv *DisassociateServiceActionFromProvisioningArtifactOutput 17569 if *v == nil { 17570 sv = &DisassociateServiceActionFromProvisioningArtifactOutput{} 17571 } else { 17572 sv = *v 17573 } 17574 17575 for key, value := range shape { 17576 switch key { 17577 default: 17578 _, _ = key, value 17579 17580 } 17581 } 17582 *v = sv 17583 return nil 17584} 17585 17586func awsAwsjson11_deserializeOpDocumentDisassociateTagOptionFromResourceOutput(v **DisassociateTagOptionFromResourceOutput, value interface{}) error { 17587 if v == nil { 17588 return fmt.Errorf("unexpected nil of type %T", v) 17589 } 17590 if value == nil { 17591 return nil 17592 } 17593 17594 shape, ok := value.(map[string]interface{}) 17595 if !ok { 17596 return fmt.Errorf("unexpected JSON type %v", value) 17597 } 17598 17599 var sv *DisassociateTagOptionFromResourceOutput 17600 if *v == nil { 17601 sv = &DisassociateTagOptionFromResourceOutput{} 17602 } else { 17603 sv = *v 17604 } 17605 17606 for key, value := range shape { 17607 switch key { 17608 default: 17609 _, _ = key, value 17610 17611 } 17612 } 17613 *v = sv 17614 return nil 17615} 17616 17617func awsAwsjson11_deserializeOpDocumentEnableAWSOrganizationsAccessOutput(v **EnableAWSOrganizationsAccessOutput, value interface{}) error { 17618 if v == nil { 17619 return fmt.Errorf("unexpected nil of type %T", v) 17620 } 17621 if value == nil { 17622 return nil 17623 } 17624 17625 shape, ok := value.(map[string]interface{}) 17626 if !ok { 17627 return fmt.Errorf("unexpected JSON type %v", value) 17628 } 17629 17630 var sv *EnableAWSOrganizationsAccessOutput 17631 if *v == nil { 17632 sv = &EnableAWSOrganizationsAccessOutput{} 17633 } else { 17634 sv = *v 17635 } 17636 17637 for key, value := range shape { 17638 switch key { 17639 default: 17640 _, _ = key, value 17641 17642 } 17643 } 17644 *v = sv 17645 return nil 17646} 17647 17648func awsAwsjson11_deserializeOpDocumentExecuteProvisionedProductPlanOutput(v **ExecuteProvisionedProductPlanOutput, value interface{}) error { 17649 if v == nil { 17650 return fmt.Errorf("unexpected nil of type %T", v) 17651 } 17652 if value == nil { 17653 return nil 17654 } 17655 17656 shape, ok := value.(map[string]interface{}) 17657 if !ok { 17658 return fmt.Errorf("unexpected JSON type %v", value) 17659 } 17660 17661 var sv *ExecuteProvisionedProductPlanOutput 17662 if *v == nil { 17663 sv = &ExecuteProvisionedProductPlanOutput{} 17664 } else { 17665 sv = *v 17666 } 17667 17668 for key, value := range shape { 17669 switch key { 17670 case "RecordDetail": 17671 if err := awsAwsjson11_deserializeDocumentRecordDetail(&sv.RecordDetail, value); err != nil { 17672 return err 17673 } 17674 17675 default: 17676 _, _ = key, value 17677 17678 } 17679 } 17680 *v = sv 17681 return nil 17682} 17683 17684func awsAwsjson11_deserializeOpDocumentExecuteProvisionedProductServiceActionOutput(v **ExecuteProvisionedProductServiceActionOutput, value interface{}) error { 17685 if v == nil { 17686 return fmt.Errorf("unexpected nil of type %T", v) 17687 } 17688 if value == nil { 17689 return nil 17690 } 17691 17692 shape, ok := value.(map[string]interface{}) 17693 if !ok { 17694 return fmt.Errorf("unexpected JSON type %v", value) 17695 } 17696 17697 var sv *ExecuteProvisionedProductServiceActionOutput 17698 if *v == nil { 17699 sv = &ExecuteProvisionedProductServiceActionOutput{} 17700 } else { 17701 sv = *v 17702 } 17703 17704 for key, value := range shape { 17705 switch key { 17706 case "RecordDetail": 17707 if err := awsAwsjson11_deserializeDocumentRecordDetail(&sv.RecordDetail, value); err != nil { 17708 return err 17709 } 17710 17711 default: 17712 _, _ = key, value 17713 17714 } 17715 } 17716 *v = sv 17717 return nil 17718} 17719 17720func awsAwsjson11_deserializeOpDocumentGetAWSOrganizationsAccessStatusOutput(v **GetAWSOrganizationsAccessStatusOutput, value interface{}) error { 17721 if v == nil { 17722 return fmt.Errorf("unexpected nil of type %T", v) 17723 } 17724 if value == nil { 17725 return nil 17726 } 17727 17728 shape, ok := value.(map[string]interface{}) 17729 if !ok { 17730 return fmt.Errorf("unexpected JSON type %v", value) 17731 } 17732 17733 var sv *GetAWSOrganizationsAccessStatusOutput 17734 if *v == nil { 17735 sv = &GetAWSOrganizationsAccessStatusOutput{} 17736 } else { 17737 sv = *v 17738 } 17739 17740 for key, value := range shape { 17741 switch key { 17742 case "AccessStatus": 17743 if value != nil { 17744 jtv, ok := value.(string) 17745 if !ok { 17746 return fmt.Errorf("expected AccessStatus to be of type string, got %T instead", value) 17747 } 17748 sv.AccessStatus = types.AccessStatus(jtv) 17749 } 17750 17751 default: 17752 _, _ = key, value 17753 17754 } 17755 } 17756 *v = sv 17757 return nil 17758} 17759 17760func awsAwsjson11_deserializeOpDocumentGetProvisionedProductOutputsOutput(v **GetProvisionedProductOutputsOutput, value interface{}) error { 17761 if v == nil { 17762 return fmt.Errorf("unexpected nil of type %T", v) 17763 } 17764 if value == nil { 17765 return nil 17766 } 17767 17768 shape, ok := value.(map[string]interface{}) 17769 if !ok { 17770 return fmt.Errorf("unexpected JSON type %v", value) 17771 } 17772 17773 var sv *GetProvisionedProductOutputsOutput 17774 if *v == nil { 17775 sv = &GetProvisionedProductOutputsOutput{} 17776 } else { 17777 sv = *v 17778 } 17779 17780 for key, value := range shape { 17781 switch key { 17782 case "NextPageToken": 17783 if value != nil { 17784 jtv, ok := value.(string) 17785 if !ok { 17786 return fmt.Errorf("expected PageToken to be of type string, got %T instead", value) 17787 } 17788 sv.NextPageToken = ptr.String(jtv) 17789 } 17790 17791 case "Outputs": 17792 if err := awsAwsjson11_deserializeDocumentRecordOutputs(&sv.Outputs, value); err != nil { 17793 return err 17794 } 17795 17796 default: 17797 _, _ = key, value 17798 17799 } 17800 } 17801 *v = sv 17802 return nil 17803} 17804 17805func awsAwsjson11_deserializeOpDocumentImportAsProvisionedProductOutput(v **ImportAsProvisionedProductOutput, value interface{}) error { 17806 if v == nil { 17807 return fmt.Errorf("unexpected nil of type %T", v) 17808 } 17809 if value == nil { 17810 return nil 17811 } 17812 17813 shape, ok := value.(map[string]interface{}) 17814 if !ok { 17815 return fmt.Errorf("unexpected JSON type %v", value) 17816 } 17817 17818 var sv *ImportAsProvisionedProductOutput 17819 if *v == nil { 17820 sv = &ImportAsProvisionedProductOutput{} 17821 } else { 17822 sv = *v 17823 } 17824 17825 for key, value := range shape { 17826 switch key { 17827 case "RecordDetail": 17828 if err := awsAwsjson11_deserializeDocumentRecordDetail(&sv.RecordDetail, value); err != nil { 17829 return err 17830 } 17831 17832 default: 17833 _, _ = key, value 17834 17835 } 17836 } 17837 *v = sv 17838 return nil 17839} 17840 17841func awsAwsjson11_deserializeOpDocumentListAcceptedPortfolioSharesOutput(v **ListAcceptedPortfolioSharesOutput, value interface{}) error { 17842 if v == nil { 17843 return fmt.Errorf("unexpected nil of type %T", v) 17844 } 17845 if value == nil { 17846 return nil 17847 } 17848 17849 shape, ok := value.(map[string]interface{}) 17850 if !ok { 17851 return fmt.Errorf("unexpected JSON type %v", value) 17852 } 17853 17854 var sv *ListAcceptedPortfolioSharesOutput 17855 if *v == nil { 17856 sv = &ListAcceptedPortfolioSharesOutput{} 17857 } else { 17858 sv = *v 17859 } 17860 17861 for key, value := range shape { 17862 switch key { 17863 case "NextPageToken": 17864 if value != nil { 17865 jtv, ok := value.(string) 17866 if !ok { 17867 return fmt.Errorf("expected PageToken to be of type string, got %T instead", value) 17868 } 17869 sv.NextPageToken = ptr.String(jtv) 17870 } 17871 17872 case "PortfolioDetails": 17873 if err := awsAwsjson11_deserializeDocumentPortfolioDetails(&sv.PortfolioDetails, value); err != nil { 17874 return err 17875 } 17876 17877 default: 17878 _, _ = key, value 17879 17880 } 17881 } 17882 *v = sv 17883 return nil 17884} 17885 17886func awsAwsjson11_deserializeOpDocumentListBudgetsForResourceOutput(v **ListBudgetsForResourceOutput, value interface{}) error { 17887 if v == nil { 17888 return fmt.Errorf("unexpected nil of type %T", v) 17889 } 17890 if value == nil { 17891 return nil 17892 } 17893 17894 shape, ok := value.(map[string]interface{}) 17895 if !ok { 17896 return fmt.Errorf("unexpected JSON type %v", value) 17897 } 17898 17899 var sv *ListBudgetsForResourceOutput 17900 if *v == nil { 17901 sv = &ListBudgetsForResourceOutput{} 17902 } else { 17903 sv = *v 17904 } 17905 17906 for key, value := range shape { 17907 switch key { 17908 case "Budgets": 17909 if err := awsAwsjson11_deserializeDocumentBudgets(&sv.Budgets, value); err != nil { 17910 return err 17911 } 17912 17913 case "NextPageToken": 17914 if value != nil { 17915 jtv, ok := value.(string) 17916 if !ok { 17917 return fmt.Errorf("expected PageToken to be of type string, got %T instead", value) 17918 } 17919 sv.NextPageToken = ptr.String(jtv) 17920 } 17921 17922 default: 17923 _, _ = key, value 17924 17925 } 17926 } 17927 *v = sv 17928 return nil 17929} 17930 17931func awsAwsjson11_deserializeOpDocumentListConstraintsForPortfolioOutput(v **ListConstraintsForPortfolioOutput, value interface{}) error { 17932 if v == nil { 17933 return fmt.Errorf("unexpected nil of type %T", v) 17934 } 17935 if value == nil { 17936 return nil 17937 } 17938 17939 shape, ok := value.(map[string]interface{}) 17940 if !ok { 17941 return fmt.Errorf("unexpected JSON type %v", value) 17942 } 17943 17944 var sv *ListConstraintsForPortfolioOutput 17945 if *v == nil { 17946 sv = &ListConstraintsForPortfolioOutput{} 17947 } else { 17948 sv = *v 17949 } 17950 17951 for key, value := range shape { 17952 switch key { 17953 case "ConstraintDetails": 17954 if err := awsAwsjson11_deserializeDocumentConstraintDetails(&sv.ConstraintDetails, value); err != nil { 17955 return err 17956 } 17957 17958 case "NextPageToken": 17959 if value != nil { 17960 jtv, ok := value.(string) 17961 if !ok { 17962 return fmt.Errorf("expected PageToken to be of type string, got %T instead", value) 17963 } 17964 sv.NextPageToken = ptr.String(jtv) 17965 } 17966 17967 default: 17968 _, _ = key, value 17969 17970 } 17971 } 17972 *v = sv 17973 return nil 17974} 17975 17976func awsAwsjson11_deserializeOpDocumentListLaunchPathsOutput(v **ListLaunchPathsOutput, value interface{}) error { 17977 if v == nil { 17978 return fmt.Errorf("unexpected nil of type %T", v) 17979 } 17980 if value == nil { 17981 return nil 17982 } 17983 17984 shape, ok := value.(map[string]interface{}) 17985 if !ok { 17986 return fmt.Errorf("unexpected JSON type %v", value) 17987 } 17988 17989 var sv *ListLaunchPathsOutput 17990 if *v == nil { 17991 sv = &ListLaunchPathsOutput{} 17992 } else { 17993 sv = *v 17994 } 17995 17996 for key, value := range shape { 17997 switch key { 17998 case "LaunchPathSummaries": 17999 if err := awsAwsjson11_deserializeDocumentLaunchPathSummaries(&sv.LaunchPathSummaries, value); err != nil { 18000 return err 18001 } 18002 18003 case "NextPageToken": 18004 if value != nil { 18005 jtv, ok := value.(string) 18006 if !ok { 18007 return fmt.Errorf("expected PageToken to be of type string, got %T instead", value) 18008 } 18009 sv.NextPageToken = ptr.String(jtv) 18010 } 18011 18012 default: 18013 _, _ = key, value 18014 18015 } 18016 } 18017 *v = sv 18018 return nil 18019} 18020 18021func awsAwsjson11_deserializeOpDocumentListOrganizationPortfolioAccessOutput(v **ListOrganizationPortfolioAccessOutput, value interface{}) error { 18022 if v == nil { 18023 return fmt.Errorf("unexpected nil of type %T", v) 18024 } 18025 if value == nil { 18026 return nil 18027 } 18028 18029 shape, ok := value.(map[string]interface{}) 18030 if !ok { 18031 return fmt.Errorf("unexpected JSON type %v", value) 18032 } 18033 18034 var sv *ListOrganizationPortfolioAccessOutput 18035 if *v == nil { 18036 sv = &ListOrganizationPortfolioAccessOutput{} 18037 } else { 18038 sv = *v 18039 } 18040 18041 for key, value := range shape { 18042 switch key { 18043 case "NextPageToken": 18044 if value != nil { 18045 jtv, ok := value.(string) 18046 if !ok { 18047 return fmt.Errorf("expected PageToken to be of type string, got %T instead", value) 18048 } 18049 sv.NextPageToken = ptr.String(jtv) 18050 } 18051 18052 case "OrganizationNodes": 18053 if err := awsAwsjson11_deserializeDocumentOrganizationNodes(&sv.OrganizationNodes, value); err != nil { 18054 return err 18055 } 18056 18057 default: 18058 _, _ = key, value 18059 18060 } 18061 } 18062 *v = sv 18063 return nil 18064} 18065 18066func awsAwsjson11_deserializeOpDocumentListPortfolioAccessOutput(v **ListPortfolioAccessOutput, value interface{}) error { 18067 if v == nil { 18068 return fmt.Errorf("unexpected nil of type %T", v) 18069 } 18070 if value == nil { 18071 return nil 18072 } 18073 18074 shape, ok := value.(map[string]interface{}) 18075 if !ok { 18076 return fmt.Errorf("unexpected JSON type %v", value) 18077 } 18078 18079 var sv *ListPortfolioAccessOutput 18080 if *v == nil { 18081 sv = &ListPortfolioAccessOutput{} 18082 } else { 18083 sv = *v 18084 } 18085 18086 for key, value := range shape { 18087 switch key { 18088 case "AccountIds": 18089 if err := awsAwsjson11_deserializeDocumentAccountIds(&sv.AccountIds, value); err != nil { 18090 return err 18091 } 18092 18093 case "NextPageToken": 18094 if value != nil { 18095 jtv, ok := value.(string) 18096 if !ok { 18097 return fmt.Errorf("expected PageToken to be of type string, got %T instead", value) 18098 } 18099 sv.NextPageToken = ptr.String(jtv) 18100 } 18101 18102 default: 18103 _, _ = key, value 18104 18105 } 18106 } 18107 *v = sv 18108 return nil 18109} 18110 18111func awsAwsjson11_deserializeOpDocumentListPortfoliosForProductOutput(v **ListPortfoliosForProductOutput, value interface{}) error { 18112 if v == nil { 18113 return fmt.Errorf("unexpected nil of type %T", v) 18114 } 18115 if value == nil { 18116 return nil 18117 } 18118 18119 shape, ok := value.(map[string]interface{}) 18120 if !ok { 18121 return fmt.Errorf("unexpected JSON type %v", value) 18122 } 18123 18124 var sv *ListPortfoliosForProductOutput 18125 if *v == nil { 18126 sv = &ListPortfoliosForProductOutput{} 18127 } else { 18128 sv = *v 18129 } 18130 18131 for key, value := range shape { 18132 switch key { 18133 case "NextPageToken": 18134 if value != nil { 18135 jtv, ok := value.(string) 18136 if !ok { 18137 return fmt.Errorf("expected PageToken to be of type string, got %T instead", value) 18138 } 18139 sv.NextPageToken = ptr.String(jtv) 18140 } 18141 18142 case "PortfolioDetails": 18143 if err := awsAwsjson11_deserializeDocumentPortfolioDetails(&sv.PortfolioDetails, value); err != nil { 18144 return err 18145 } 18146 18147 default: 18148 _, _ = key, value 18149 18150 } 18151 } 18152 *v = sv 18153 return nil 18154} 18155 18156func awsAwsjson11_deserializeOpDocumentListPortfoliosOutput(v **ListPortfoliosOutput, value interface{}) error { 18157 if v == nil { 18158 return fmt.Errorf("unexpected nil of type %T", v) 18159 } 18160 if value == nil { 18161 return nil 18162 } 18163 18164 shape, ok := value.(map[string]interface{}) 18165 if !ok { 18166 return fmt.Errorf("unexpected JSON type %v", value) 18167 } 18168 18169 var sv *ListPortfoliosOutput 18170 if *v == nil { 18171 sv = &ListPortfoliosOutput{} 18172 } else { 18173 sv = *v 18174 } 18175 18176 for key, value := range shape { 18177 switch key { 18178 case "NextPageToken": 18179 if value != nil { 18180 jtv, ok := value.(string) 18181 if !ok { 18182 return fmt.Errorf("expected PageToken to be of type string, got %T instead", value) 18183 } 18184 sv.NextPageToken = ptr.String(jtv) 18185 } 18186 18187 case "PortfolioDetails": 18188 if err := awsAwsjson11_deserializeDocumentPortfolioDetails(&sv.PortfolioDetails, value); err != nil { 18189 return err 18190 } 18191 18192 default: 18193 _, _ = key, value 18194 18195 } 18196 } 18197 *v = sv 18198 return nil 18199} 18200 18201func awsAwsjson11_deserializeOpDocumentListPrincipalsForPortfolioOutput(v **ListPrincipalsForPortfolioOutput, value interface{}) error { 18202 if v == nil { 18203 return fmt.Errorf("unexpected nil of type %T", v) 18204 } 18205 if value == nil { 18206 return nil 18207 } 18208 18209 shape, ok := value.(map[string]interface{}) 18210 if !ok { 18211 return fmt.Errorf("unexpected JSON type %v", value) 18212 } 18213 18214 var sv *ListPrincipalsForPortfolioOutput 18215 if *v == nil { 18216 sv = &ListPrincipalsForPortfolioOutput{} 18217 } else { 18218 sv = *v 18219 } 18220 18221 for key, value := range shape { 18222 switch key { 18223 case "NextPageToken": 18224 if value != nil { 18225 jtv, ok := value.(string) 18226 if !ok { 18227 return fmt.Errorf("expected PageToken to be of type string, got %T instead", value) 18228 } 18229 sv.NextPageToken = ptr.String(jtv) 18230 } 18231 18232 case "Principals": 18233 if err := awsAwsjson11_deserializeDocumentPrincipals(&sv.Principals, value); err != nil { 18234 return err 18235 } 18236 18237 default: 18238 _, _ = key, value 18239 18240 } 18241 } 18242 *v = sv 18243 return nil 18244} 18245 18246func awsAwsjson11_deserializeOpDocumentListProvisionedProductPlansOutput(v **ListProvisionedProductPlansOutput, value interface{}) error { 18247 if v == nil { 18248 return fmt.Errorf("unexpected nil of type %T", v) 18249 } 18250 if value == nil { 18251 return nil 18252 } 18253 18254 shape, ok := value.(map[string]interface{}) 18255 if !ok { 18256 return fmt.Errorf("unexpected JSON type %v", value) 18257 } 18258 18259 var sv *ListProvisionedProductPlansOutput 18260 if *v == nil { 18261 sv = &ListProvisionedProductPlansOutput{} 18262 } else { 18263 sv = *v 18264 } 18265 18266 for key, value := range shape { 18267 switch key { 18268 case "NextPageToken": 18269 if value != nil { 18270 jtv, ok := value.(string) 18271 if !ok { 18272 return fmt.Errorf("expected PageToken to be of type string, got %T instead", value) 18273 } 18274 sv.NextPageToken = ptr.String(jtv) 18275 } 18276 18277 case "ProvisionedProductPlans": 18278 if err := awsAwsjson11_deserializeDocumentProvisionedProductPlans(&sv.ProvisionedProductPlans, value); err != nil { 18279 return err 18280 } 18281 18282 default: 18283 _, _ = key, value 18284 18285 } 18286 } 18287 *v = sv 18288 return nil 18289} 18290 18291func awsAwsjson11_deserializeOpDocumentListProvisioningArtifactsForServiceActionOutput(v **ListProvisioningArtifactsForServiceActionOutput, value interface{}) error { 18292 if v == nil { 18293 return fmt.Errorf("unexpected nil of type %T", v) 18294 } 18295 if value == nil { 18296 return nil 18297 } 18298 18299 shape, ok := value.(map[string]interface{}) 18300 if !ok { 18301 return fmt.Errorf("unexpected JSON type %v", value) 18302 } 18303 18304 var sv *ListProvisioningArtifactsForServiceActionOutput 18305 if *v == nil { 18306 sv = &ListProvisioningArtifactsForServiceActionOutput{} 18307 } else { 18308 sv = *v 18309 } 18310 18311 for key, value := range shape { 18312 switch key { 18313 case "NextPageToken": 18314 if value != nil { 18315 jtv, ok := value.(string) 18316 if !ok { 18317 return fmt.Errorf("expected PageToken to be of type string, got %T instead", value) 18318 } 18319 sv.NextPageToken = ptr.String(jtv) 18320 } 18321 18322 case "ProvisioningArtifactViews": 18323 if err := awsAwsjson11_deserializeDocumentProvisioningArtifactViews(&sv.ProvisioningArtifactViews, value); err != nil { 18324 return err 18325 } 18326 18327 default: 18328 _, _ = key, value 18329 18330 } 18331 } 18332 *v = sv 18333 return nil 18334} 18335 18336func awsAwsjson11_deserializeOpDocumentListProvisioningArtifactsOutput(v **ListProvisioningArtifactsOutput, value interface{}) error { 18337 if v == nil { 18338 return fmt.Errorf("unexpected nil of type %T", v) 18339 } 18340 if value == nil { 18341 return nil 18342 } 18343 18344 shape, ok := value.(map[string]interface{}) 18345 if !ok { 18346 return fmt.Errorf("unexpected JSON type %v", value) 18347 } 18348 18349 var sv *ListProvisioningArtifactsOutput 18350 if *v == nil { 18351 sv = &ListProvisioningArtifactsOutput{} 18352 } else { 18353 sv = *v 18354 } 18355 18356 for key, value := range shape { 18357 switch key { 18358 case "NextPageToken": 18359 if value != nil { 18360 jtv, ok := value.(string) 18361 if !ok { 18362 return fmt.Errorf("expected PageToken to be of type string, got %T instead", value) 18363 } 18364 sv.NextPageToken = ptr.String(jtv) 18365 } 18366 18367 case "ProvisioningArtifactDetails": 18368 if err := awsAwsjson11_deserializeDocumentProvisioningArtifactDetails(&sv.ProvisioningArtifactDetails, value); err != nil { 18369 return err 18370 } 18371 18372 default: 18373 _, _ = key, value 18374 18375 } 18376 } 18377 *v = sv 18378 return nil 18379} 18380 18381func awsAwsjson11_deserializeOpDocumentListRecordHistoryOutput(v **ListRecordHistoryOutput, value interface{}) error { 18382 if v == nil { 18383 return fmt.Errorf("unexpected nil of type %T", v) 18384 } 18385 if value == nil { 18386 return nil 18387 } 18388 18389 shape, ok := value.(map[string]interface{}) 18390 if !ok { 18391 return fmt.Errorf("unexpected JSON type %v", value) 18392 } 18393 18394 var sv *ListRecordHistoryOutput 18395 if *v == nil { 18396 sv = &ListRecordHistoryOutput{} 18397 } else { 18398 sv = *v 18399 } 18400 18401 for key, value := range shape { 18402 switch key { 18403 case "NextPageToken": 18404 if value != nil { 18405 jtv, ok := value.(string) 18406 if !ok { 18407 return fmt.Errorf("expected PageToken to be of type string, got %T instead", value) 18408 } 18409 sv.NextPageToken = ptr.String(jtv) 18410 } 18411 18412 case "RecordDetails": 18413 if err := awsAwsjson11_deserializeDocumentRecordDetails(&sv.RecordDetails, value); err != nil { 18414 return err 18415 } 18416 18417 default: 18418 _, _ = key, value 18419 18420 } 18421 } 18422 *v = sv 18423 return nil 18424} 18425 18426func awsAwsjson11_deserializeOpDocumentListResourcesForTagOptionOutput(v **ListResourcesForTagOptionOutput, value interface{}) error { 18427 if v == nil { 18428 return fmt.Errorf("unexpected nil of type %T", v) 18429 } 18430 if value == nil { 18431 return nil 18432 } 18433 18434 shape, ok := value.(map[string]interface{}) 18435 if !ok { 18436 return fmt.Errorf("unexpected JSON type %v", value) 18437 } 18438 18439 var sv *ListResourcesForTagOptionOutput 18440 if *v == nil { 18441 sv = &ListResourcesForTagOptionOutput{} 18442 } else { 18443 sv = *v 18444 } 18445 18446 for key, value := range shape { 18447 switch key { 18448 case "PageToken": 18449 if value != nil { 18450 jtv, ok := value.(string) 18451 if !ok { 18452 return fmt.Errorf("expected PageToken to be of type string, got %T instead", value) 18453 } 18454 sv.PageToken = ptr.String(jtv) 18455 } 18456 18457 case "ResourceDetails": 18458 if err := awsAwsjson11_deserializeDocumentResourceDetails(&sv.ResourceDetails, value); err != nil { 18459 return err 18460 } 18461 18462 default: 18463 _, _ = key, value 18464 18465 } 18466 } 18467 *v = sv 18468 return nil 18469} 18470 18471func awsAwsjson11_deserializeOpDocumentListServiceActionsForProvisioningArtifactOutput(v **ListServiceActionsForProvisioningArtifactOutput, value interface{}) error { 18472 if v == nil { 18473 return fmt.Errorf("unexpected nil of type %T", v) 18474 } 18475 if value == nil { 18476 return nil 18477 } 18478 18479 shape, ok := value.(map[string]interface{}) 18480 if !ok { 18481 return fmt.Errorf("unexpected JSON type %v", value) 18482 } 18483 18484 var sv *ListServiceActionsForProvisioningArtifactOutput 18485 if *v == nil { 18486 sv = &ListServiceActionsForProvisioningArtifactOutput{} 18487 } else { 18488 sv = *v 18489 } 18490 18491 for key, value := range shape { 18492 switch key { 18493 case "NextPageToken": 18494 if value != nil { 18495 jtv, ok := value.(string) 18496 if !ok { 18497 return fmt.Errorf("expected PageToken to be of type string, got %T instead", value) 18498 } 18499 sv.NextPageToken = ptr.String(jtv) 18500 } 18501 18502 case "ServiceActionSummaries": 18503 if err := awsAwsjson11_deserializeDocumentServiceActionSummaries(&sv.ServiceActionSummaries, value); err != nil { 18504 return err 18505 } 18506 18507 default: 18508 _, _ = key, value 18509 18510 } 18511 } 18512 *v = sv 18513 return nil 18514} 18515 18516func awsAwsjson11_deserializeOpDocumentListServiceActionsOutput(v **ListServiceActionsOutput, value interface{}) error { 18517 if v == nil { 18518 return fmt.Errorf("unexpected nil of type %T", v) 18519 } 18520 if value == nil { 18521 return nil 18522 } 18523 18524 shape, ok := value.(map[string]interface{}) 18525 if !ok { 18526 return fmt.Errorf("unexpected JSON type %v", value) 18527 } 18528 18529 var sv *ListServiceActionsOutput 18530 if *v == nil { 18531 sv = &ListServiceActionsOutput{} 18532 } else { 18533 sv = *v 18534 } 18535 18536 for key, value := range shape { 18537 switch key { 18538 case "NextPageToken": 18539 if value != nil { 18540 jtv, ok := value.(string) 18541 if !ok { 18542 return fmt.Errorf("expected PageToken to be of type string, got %T instead", value) 18543 } 18544 sv.NextPageToken = ptr.String(jtv) 18545 } 18546 18547 case "ServiceActionSummaries": 18548 if err := awsAwsjson11_deserializeDocumentServiceActionSummaries(&sv.ServiceActionSummaries, value); err != nil { 18549 return err 18550 } 18551 18552 default: 18553 _, _ = key, value 18554 18555 } 18556 } 18557 *v = sv 18558 return nil 18559} 18560 18561func awsAwsjson11_deserializeOpDocumentListStackInstancesForProvisionedProductOutput(v **ListStackInstancesForProvisionedProductOutput, value interface{}) error { 18562 if v == nil { 18563 return fmt.Errorf("unexpected nil of type %T", v) 18564 } 18565 if value == nil { 18566 return nil 18567 } 18568 18569 shape, ok := value.(map[string]interface{}) 18570 if !ok { 18571 return fmt.Errorf("unexpected JSON type %v", value) 18572 } 18573 18574 var sv *ListStackInstancesForProvisionedProductOutput 18575 if *v == nil { 18576 sv = &ListStackInstancesForProvisionedProductOutput{} 18577 } else { 18578 sv = *v 18579 } 18580 18581 for key, value := range shape { 18582 switch key { 18583 case "NextPageToken": 18584 if value != nil { 18585 jtv, ok := value.(string) 18586 if !ok { 18587 return fmt.Errorf("expected PageToken to be of type string, got %T instead", value) 18588 } 18589 sv.NextPageToken = ptr.String(jtv) 18590 } 18591 18592 case "StackInstances": 18593 if err := awsAwsjson11_deserializeDocumentStackInstances(&sv.StackInstances, value); err != nil { 18594 return err 18595 } 18596 18597 default: 18598 _, _ = key, value 18599 18600 } 18601 } 18602 *v = sv 18603 return nil 18604} 18605 18606func awsAwsjson11_deserializeOpDocumentListTagOptionsOutput(v **ListTagOptionsOutput, value interface{}) error { 18607 if v == nil { 18608 return fmt.Errorf("unexpected nil of type %T", v) 18609 } 18610 if value == nil { 18611 return nil 18612 } 18613 18614 shape, ok := value.(map[string]interface{}) 18615 if !ok { 18616 return fmt.Errorf("unexpected JSON type %v", value) 18617 } 18618 18619 var sv *ListTagOptionsOutput 18620 if *v == nil { 18621 sv = &ListTagOptionsOutput{} 18622 } else { 18623 sv = *v 18624 } 18625 18626 for key, value := range shape { 18627 switch key { 18628 case "PageToken": 18629 if value != nil { 18630 jtv, ok := value.(string) 18631 if !ok { 18632 return fmt.Errorf("expected PageToken to be of type string, got %T instead", value) 18633 } 18634 sv.PageToken = ptr.String(jtv) 18635 } 18636 18637 case "TagOptionDetails": 18638 if err := awsAwsjson11_deserializeDocumentTagOptionDetails(&sv.TagOptionDetails, value); err != nil { 18639 return err 18640 } 18641 18642 default: 18643 _, _ = key, value 18644 18645 } 18646 } 18647 *v = sv 18648 return nil 18649} 18650 18651func awsAwsjson11_deserializeOpDocumentProvisionProductOutput(v **ProvisionProductOutput, value interface{}) error { 18652 if v == nil { 18653 return fmt.Errorf("unexpected nil of type %T", v) 18654 } 18655 if value == nil { 18656 return nil 18657 } 18658 18659 shape, ok := value.(map[string]interface{}) 18660 if !ok { 18661 return fmt.Errorf("unexpected JSON type %v", value) 18662 } 18663 18664 var sv *ProvisionProductOutput 18665 if *v == nil { 18666 sv = &ProvisionProductOutput{} 18667 } else { 18668 sv = *v 18669 } 18670 18671 for key, value := range shape { 18672 switch key { 18673 case "RecordDetail": 18674 if err := awsAwsjson11_deserializeDocumentRecordDetail(&sv.RecordDetail, value); err != nil { 18675 return err 18676 } 18677 18678 default: 18679 _, _ = key, value 18680 18681 } 18682 } 18683 *v = sv 18684 return nil 18685} 18686 18687func awsAwsjson11_deserializeOpDocumentRejectPortfolioShareOutput(v **RejectPortfolioShareOutput, value interface{}) error { 18688 if v == nil { 18689 return fmt.Errorf("unexpected nil of type %T", v) 18690 } 18691 if value == nil { 18692 return nil 18693 } 18694 18695 shape, ok := value.(map[string]interface{}) 18696 if !ok { 18697 return fmt.Errorf("unexpected JSON type %v", value) 18698 } 18699 18700 var sv *RejectPortfolioShareOutput 18701 if *v == nil { 18702 sv = &RejectPortfolioShareOutput{} 18703 } else { 18704 sv = *v 18705 } 18706 18707 for key, value := range shape { 18708 switch key { 18709 default: 18710 _, _ = key, value 18711 18712 } 18713 } 18714 *v = sv 18715 return nil 18716} 18717 18718func awsAwsjson11_deserializeOpDocumentScanProvisionedProductsOutput(v **ScanProvisionedProductsOutput, value interface{}) error { 18719 if v == nil { 18720 return fmt.Errorf("unexpected nil of type %T", v) 18721 } 18722 if value == nil { 18723 return nil 18724 } 18725 18726 shape, ok := value.(map[string]interface{}) 18727 if !ok { 18728 return fmt.Errorf("unexpected JSON type %v", value) 18729 } 18730 18731 var sv *ScanProvisionedProductsOutput 18732 if *v == nil { 18733 sv = &ScanProvisionedProductsOutput{} 18734 } else { 18735 sv = *v 18736 } 18737 18738 for key, value := range shape { 18739 switch key { 18740 case "NextPageToken": 18741 if value != nil { 18742 jtv, ok := value.(string) 18743 if !ok { 18744 return fmt.Errorf("expected PageToken to be of type string, got %T instead", value) 18745 } 18746 sv.NextPageToken = ptr.String(jtv) 18747 } 18748 18749 case "ProvisionedProducts": 18750 if err := awsAwsjson11_deserializeDocumentProvisionedProductDetails(&sv.ProvisionedProducts, value); err != nil { 18751 return err 18752 } 18753 18754 default: 18755 _, _ = key, value 18756 18757 } 18758 } 18759 *v = sv 18760 return nil 18761} 18762 18763func awsAwsjson11_deserializeOpDocumentSearchProductsAsAdminOutput(v **SearchProductsAsAdminOutput, value interface{}) error { 18764 if v == nil { 18765 return fmt.Errorf("unexpected nil of type %T", v) 18766 } 18767 if value == nil { 18768 return nil 18769 } 18770 18771 shape, ok := value.(map[string]interface{}) 18772 if !ok { 18773 return fmt.Errorf("unexpected JSON type %v", value) 18774 } 18775 18776 var sv *SearchProductsAsAdminOutput 18777 if *v == nil { 18778 sv = &SearchProductsAsAdminOutput{} 18779 } else { 18780 sv = *v 18781 } 18782 18783 for key, value := range shape { 18784 switch key { 18785 case "NextPageToken": 18786 if value != nil { 18787 jtv, ok := value.(string) 18788 if !ok { 18789 return fmt.Errorf("expected PageToken to be of type string, got %T instead", value) 18790 } 18791 sv.NextPageToken = ptr.String(jtv) 18792 } 18793 18794 case "ProductViewDetails": 18795 if err := awsAwsjson11_deserializeDocumentProductViewDetails(&sv.ProductViewDetails, value); err != nil { 18796 return err 18797 } 18798 18799 default: 18800 _, _ = key, value 18801 18802 } 18803 } 18804 *v = sv 18805 return nil 18806} 18807 18808func awsAwsjson11_deserializeOpDocumentSearchProductsOutput(v **SearchProductsOutput, value interface{}) error { 18809 if v == nil { 18810 return fmt.Errorf("unexpected nil of type %T", v) 18811 } 18812 if value == nil { 18813 return nil 18814 } 18815 18816 shape, ok := value.(map[string]interface{}) 18817 if !ok { 18818 return fmt.Errorf("unexpected JSON type %v", value) 18819 } 18820 18821 var sv *SearchProductsOutput 18822 if *v == nil { 18823 sv = &SearchProductsOutput{} 18824 } else { 18825 sv = *v 18826 } 18827 18828 for key, value := range shape { 18829 switch key { 18830 case "NextPageToken": 18831 if value != nil { 18832 jtv, ok := value.(string) 18833 if !ok { 18834 return fmt.Errorf("expected PageToken to be of type string, got %T instead", value) 18835 } 18836 sv.NextPageToken = ptr.String(jtv) 18837 } 18838 18839 case "ProductViewAggregations": 18840 if err := awsAwsjson11_deserializeDocumentProductViewAggregations(&sv.ProductViewAggregations, value); err != nil { 18841 return err 18842 } 18843 18844 case "ProductViewSummaries": 18845 if err := awsAwsjson11_deserializeDocumentProductViewSummaries(&sv.ProductViewSummaries, value); err != nil { 18846 return err 18847 } 18848 18849 default: 18850 _, _ = key, value 18851 18852 } 18853 } 18854 *v = sv 18855 return nil 18856} 18857 18858func awsAwsjson11_deserializeOpDocumentSearchProvisionedProductsOutput(v **SearchProvisionedProductsOutput, value interface{}) error { 18859 if v == nil { 18860 return fmt.Errorf("unexpected nil of type %T", v) 18861 } 18862 if value == nil { 18863 return nil 18864 } 18865 18866 shape, ok := value.(map[string]interface{}) 18867 if !ok { 18868 return fmt.Errorf("unexpected JSON type %v", value) 18869 } 18870 18871 var sv *SearchProvisionedProductsOutput 18872 if *v == nil { 18873 sv = &SearchProvisionedProductsOutput{} 18874 } else { 18875 sv = *v 18876 } 18877 18878 for key, value := range shape { 18879 switch key { 18880 case "NextPageToken": 18881 if value != nil { 18882 jtv, ok := value.(string) 18883 if !ok { 18884 return fmt.Errorf("expected PageToken to be of type string, got %T instead", value) 18885 } 18886 sv.NextPageToken = ptr.String(jtv) 18887 } 18888 18889 case "ProvisionedProducts": 18890 if err := awsAwsjson11_deserializeDocumentProvisionedProductAttributes(&sv.ProvisionedProducts, value); err != nil { 18891 return err 18892 } 18893 18894 case "TotalResultsCount": 18895 if value != nil { 18896 jtv, ok := value.(json.Number) 18897 if !ok { 18898 return fmt.Errorf("expected TotalResultsCount to be json.Number, got %T instead", value) 18899 } 18900 i64, err := jtv.Int64() 18901 if err != nil { 18902 return err 18903 } 18904 sv.TotalResultsCount = int32(i64) 18905 } 18906 18907 default: 18908 _, _ = key, value 18909 18910 } 18911 } 18912 *v = sv 18913 return nil 18914} 18915 18916func awsAwsjson11_deserializeOpDocumentTerminateProvisionedProductOutput(v **TerminateProvisionedProductOutput, value interface{}) error { 18917 if v == nil { 18918 return fmt.Errorf("unexpected nil of type %T", v) 18919 } 18920 if value == nil { 18921 return nil 18922 } 18923 18924 shape, ok := value.(map[string]interface{}) 18925 if !ok { 18926 return fmt.Errorf("unexpected JSON type %v", value) 18927 } 18928 18929 var sv *TerminateProvisionedProductOutput 18930 if *v == nil { 18931 sv = &TerminateProvisionedProductOutput{} 18932 } else { 18933 sv = *v 18934 } 18935 18936 for key, value := range shape { 18937 switch key { 18938 case "RecordDetail": 18939 if err := awsAwsjson11_deserializeDocumentRecordDetail(&sv.RecordDetail, value); err != nil { 18940 return err 18941 } 18942 18943 default: 18944 _, _ = key, value 18945 18946 } 18947 } 18948 *v = sv 18949 return nil 18950} 18951 18952func awsAwsjson11_deserializeOpDocumentUpdateConstraintOutput(v **UpdateConstraintOutput, value interface{}) error { 18953 if v == nil { 18954 return fmt.Errorf("unexpected nil of type %T", v) 18955 } 18956 if value == nil { 18957 return nil 18958 } 18959 18960 shape, ok := value.(map[string]interface{}) 18961 if !ok { 18962 return fmt.Errorf("unexpected JSON type %v", value) 18963 } 18964 18965 var sv *UpdateConstraintOutput 18966 if *v == nil { 18967 sv = &UpdateConstraintOutput{} 18968 } else { 18969 sv = *v 18970 } 18971 18972 for key, value := range shape { 18973 switch key { 18974 case "ConstraintDetail": 18975 if err := awsAwsjson11_deserializeDocumentConstraintDetail(&sv.ConstraintDetail, value); err != nil { 18976 return err 18977 } 18978 18979 case "ConstraintParameters": 18980 if value != nil { 18981 jtv, ok := value.(string) 18982 if !ok { 18983 return fmt.Errorf("expected ConstraintParameters to be of type string, got %T instead", value) 18984 } 18985 sv.ConstraintParameters = ptr.String(jtv) 18986 } 18987 18988 case "Status": 18989 if value != nil { 18990 jtv, ok := value.(string) 18991 if !ok { 18992 return fmt.Errorf("expected Status to be of type string, got %T instead", value) 18993 } 18994 sv.Status = types.Status(jtv) 18995 } 18996 18997 default: 18998 _, _ = key, value 18999 19000 } 19001 } 19002 *v = sv 19003 return nil 19004} 19005 19006func awsAwsjson11_deserializeOpDocumentUpdatePortfolioOutput(v **UpdatePortfolioOutput, value interface{}) error { 19007 if v == nil { 19008 return fmt.Errorf("unexpected nil of type %T", v) 19009 } 19010 if value == nil { 19011 return nil 19012 } 19013 19014 shape, ok := value.(map[string]interface{}) 19015 if !ok { 19016 return fmt.Errorf("unexpected JSON type %v", value) 19017 } 19018 19019 var sv *UpdatePortfolioOutput 19020 if *v == nil { 19021 sv = &UpdatePortfolioOutput{} 19022 } else { 19023 sv = *v 19024 } 19025 19026 for key, value := range shape { 19027 switch key { 19028 case "PortfolioDetail": 19029 if err := awsAwsjson11_deserializeDocumentPortfolioDetail(&sv.PortfolioDetail, value); err != nil { 19030 return err 19031 } 19032 19033 case "Tags": 19034 if err := awsAwsjson11_deserializeDocumentTags(&sv.Tags, value); err != nil { 19035 return err 19036 } 19037 19038 default: 19039 _, _ = key, value 19040 19041 } 19042 } 19043 *v = sv 19044 return nil 19045} 19046 19047func awsAwsjson11_deserializeOpDocumentUpdatePortfolioShareOutput(v **UpdatePortfolioShareOutput, value interface{}) error { 19048 if v == nil { 19049 return fmt.Errorf("unexpected nil of type %T", v) 19050 } 19051 if value == nil { 19052 return nil 19053 } 19054 19055 shape, ok := value.(map[string]interface{}) 19056 if !ok { 19057 return fmt.Errorf("unexpected JSON type %v", value) 19058 } 19059 19060 var sv *UpdatePortfolioShareOutput 19061 if *v == nil { 19062 sv = &UpdatePortfolioShareOutput{} 19063 } else { 19064 sv = *v 19065 } 19066 19067 for key, value := range shape { 19068 switch key { 19069 case "PortfolioShareToken": 19070 if value != nil { 19071 jtv, ok := value.(string) 19072 if !ok { 19073 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 19074 } 19075 sv.PortfolioShareToken = ptr.String(jtv) 19076 } 19077 19078 case "Status": 19079 if value != nil { 19080 jtv, ok := value.(string) 19081 if !ok { 19082 return fmt.Errorf("expected ShareStatus to be of type string, got %T instead", value) 19083 } 19084 sv.Status = types.ShareStatus(jtv) 19085 } 19086 19087 default: 19088 _, _ = key, value 19089 19090 } 19091 } 19092 *v = sv 19093 return nil 19094} 19095 19096func awsAwsjson11_deserializeOpDocumentUpdateProductOutput(v **UpdateProductOutput, value interface{}) error { 19097 if v == nil { 19098 return fmt.Errorf("unexpected nil of type %T", v) 19099 } 19100 if value == nil { 19101 return nil 19102 } 19103 19104 shape, ok := value.(map[string]interface{}) 19105 if !ok { 19106 return fmt.Errorf("unexpected JSON type %v", value) 19107 } 19108 19109 var sv *UpdateProductOutput 19110 if *v == nil { 19111 sv = &UpdateProductOutput{} 19112 } else { 19113 sv = *v 19114 } 19115 19116 for key, value := range shape { 19117 switch key { 19118 case "ProductViewDetail": 19119 if err := awsAwsjson11_deserializeDocumentProductViewDetail(&sv.ProductViewDetail, value); err != nil { 19120 return err 19121 } 19122 19123 case "Tags": 19124 if err := awsAwsjson11_deserializeDocumentTags(&sv.Tags, value); err != nil { 19125 return err 19126 } 19127 19128 default: 19129 _, _ = key, value 19130 19131 } 19132 } 19133 *v = sv 19134 return nil 19135} 19136 19137func awsAwsjson11_deserializeOpDocumentUpdateProvisionedProductOutput(v **UpdateProvisionedProductOutput, value interface{}) error { 19138 if v == nil { 19139 return fmt.Errorf("unexpected nil of type %T", v) 19140 } 19141 if value == nil { 19142 return nil 19143 } 19144 19145 shape, ok := value.(map[string]interface{}) 19146 if !ok { 19147 return fmt.Errorf("unexpected JSON type %v", value) 19148 } 19149 19150 var sv *UpdateProvisionedProductOutput 19151 if *v == nil { 19152 sv = &UpdateProvisionedProductOutput{} 19153 } else { 19154 sv = *v 19155 } 19156 19157 for key, value := range shape { 19158 switch key { 19159 case "RecordDetail": 19160 if err := awsAwsjson11_deserializeDocumentRecordDetail(&sv.RecordDetail, value); err != nil { 19161 return err 19162 } 19163 19164 default: 19165 _, _ = key, value 19166 19167 } 19168 } 19169 *v = sv 19170 return nil 19171} 19172 19173func awsAwsjson11_deserializeOpDocumentUpdateProvisionedProductPropertiesOutput(v **UpdateProvisionedProductPropertiesOutput, value interface{}) error { 19174 if v == nil { 19175 return fmt.Errorf("unexpected nil of type %T", v) 19176 } 19177 if value == nil { 19178 return nil 19179 } 19180 19181 shape, ok := value.(map[string]interface{}) 19182 if !ok { 19183 return fmt.Errorf("unexpected JSON type %v", value) 19184 } 19185 19186 var sv *UpdateProvisionedProductPropertiesOutput 19187 if *v == nil { 19188 sv = &UpdateProvisionedProductPropertiesOutput{} 19189 } else { 19190 sv = *v 19191 } 19192 19193 for key, value := range shape { 19194 switch key { 19195 case "ProvisionedProductId": 19196 if value != nil { 19197 jtv, ok := value.(string) 19198 if !ok { 19199 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 19200 } 19201 sv.ProvisionedProductId = ptr.String(jtv) 19202 } 19203 19204 case "ProvisionedProductProperties": 19205 if err := awsAwsjson11_deserializeDocumentProvisionedProductProperties(&sv.ProvisionedProductProperties, value); err != nil { 19206 return err 19207 } 19208 19209 case "RecordId": 19210 if value != nil { 19211 jtv, ok := value.(string) 19212 if !ok { 19213 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 19214 } 19215 sv.RecordId = ptr.String(jtv) 19216 } 19217 19218 case "Status": 19219 if value != nil { 19220 jtv, ok := value.(string) 19221 if !ok { 19222 return fmt.Errorf("expected RecordStatus to be of type string, got %T instead", value) 19223 } 19224 sv.Status = types.RecordStatus(jtv) 19225 } 19226 19227 default: 19228 _, _ = key, value 19229 19230 } 19231 } 19232 *v = sv 19233 return nil 19234} 19235 19236func awsAwsjson11_deserializeOpDocumentUpdateProvisioningArtifactOutput(v **UpdateProvisioningArtifactOutput, value interface{}) error { 19237 if v == nil { 19238 return fmt.Errorf("unexpected nil of type %T", v) 19239 } 19240 if value == nil { 19241 return nil 19242 } 19243 19244 shape, ok := value.(map[string]interface{}) 19245 if !ok { 19246 return fmt.Errorf("unexpected JSON type %v", value) 19247 } 19248 19249 var sv *UpdateProvisioningArtifactOutput 19250 if *v == nil { 19251 sv = &UpdateProvisioningArtifactOutput{} 19252 } else { 19253 sv = *v 19254 } 19255 19256 for key, value := range shape { 19257 switch key { 19258 case "Info": 19259 if err := awsAwsjson11_deserializeDocumentProvisioningArtifactInfo(&sv.Info, value); err != nil { 19260 return err 19261 } 19262 19263 case "ProvisioningArtifactDetail": 19264 if err := awsAwsjson11_deserializeDocumentProvisioningArtifactDetail(&sv.ProvisioningArtifactDetail, value); err != nil { 19265 return err 19266 } 19267 19268 case "Status": 19269 if value != nil { 19270 jtv, ok := value.(string) 19271 if !ok { 19272 return fmt.Errorf("expected Status to be of type string, got %T instead", value) 19273 } 19274 sv.Status = types.Status(jtv) 19275 } 19276 19277 default: 19278 _, _ = key, value 19279 19280 } 19281 } 19282 *v = sv 19283 return nil 19284} 19285 19286func awsAwsjson11_deserializeOpDocumentUpdateServiceActionOutput(v **UpdateServiceActionOutput, value interface{}) error { 19287 if v == nil { 19288 return fmt.Errorf("unexpected nil of type %T", v) 19289 } 19290 if value == nil { 19291 return nil 19292 } 19293 19294 shape, ok := value.(map[string]interface{}) 19295 if !ok { 19296 return fmt.Errorf("unexpected JSON type %v", value) 19297 } 19298 19299 var sv *UpdateServiceActionOutput 19300 if *v == nil { 19301 sv = &UpdateServiceActionOutput{} 19302 } else { 19303 sv = *v 19304 } 19305 19306 for key, value := range shape { 19307 switch key { 19308 case "ServiceActionDetail": 19309 if err := awsAwsjson11_deserializeDocumentServiceActionDetail(&sv.ServiceActionDetail, value); err != nil { 19310 return err 19311 } 19312 19313 default: 19314 _, _ = key, value 19315 19316 } 19317 } 19318 *v = sv 19319 return nil 19320} 19321 19322func awsAwsjson11_deserializeOpDocumentUpdateTagOptionOutput(v **UpdateTagOptionOutput, value interface{}) error { 19323 if v == nil { 19324 return fmt.Errorf("unexpected nil of type %T", v) 19325 } 19326 if value == nil { 19327 return nil 19328 } 19329 19330 shape, ok := value.(map[string]interface{}) 19331 if !ok { 19332 return fmt.Errorf("unexpected JSON type %v", value) 19333 } 19334 19335 var sv *UpdateTagOptionOutput 19336 if *v == nil { 19337 sv = &UpdateTagOptionOutput{} 19338 } else { 19339 sv = *v 19340 } 19341 19342 for key, value := range shape { 19343 switch key { 19344 case "TagOptionDetail": 19345 if err := awsAwsjson11_deserializeDocumentTagOptionDetail(&sv.TagOptionDetail, value); err != nil { 19346 return err 19347 } 19348 19349 default: 19350 _, _ = key, value 19351 19352 } 19353 } 19354 *v = sv 19355 return nil 19356} 19357