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 AllowedValue 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 "AllowedValues": 11520 if err := awsAwsjson11_deserializeDocumentAllowedValues(&sv.AllowedValues, value); err != nil { 11521 return err 11522 } 11523 11524 default: 11525 _, _ = key, value 11526 11527 } 11528 } 11529 *v = sv 11530 return nil 11531} 11532 11533func awsAwsjson11_deserializeDocumentPortfolioDetail(v **types.PortfolioDetail, value interface{}) error { 11534 if v == nil { 11535 return fmt.Errorf("unexpected nil of type %T", v) 11536 } 11537 if value == nil { 11538 return nil 11539 } 11540 11541 shape, ok := value.(map[string]interface{}) 11542 if !ok { 11543 return fmt.Errorf("unexpected JSON type %v", value) 11544 } 11545 11546 var sv *types.PortfolioDetail 11547 if *v == nil { 11548 sv = &types.PortfolioDetail{} 11549 } else { 11550 sv = *v 11551 } 11552 11553 for key, value := range shape { 11554 switch key { 11555 case "ARN": 11556 if value != nil { 11557 jtv, ok := value.(string) 11558 if !ok { 11559 return fmt.Errorf("expected ResourceARN to be of type string, got %T instead", value) 11560 } 11561 sv.ARN = ptr.String(jtv) 11562 } 11563 11564 case "CreatedTime": 11565 if value != nil { 11566 jtv, ok := value.(json.Number) 11567 if !ok { 11568 return fmt.Errorf("expected CreationTime to be json.Number, got %T instead", value) 11569 } 11570 f64, err := jtv.Float64() 11571 if err != nil { 11572 return err 11573 } 11574 sv.CreatedTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 11575 } 11576 11577 case "Description": 11578 if value != nil { 11579 jtv, ok := value.(string) 11580 if !ok { 11581 return fmt.Errorf("expected PortfolioDescription to be of type string, got %T instead", value) 11582 } 11583 sv.Description = ptr.String(jtv) 11584 } 11585 11586 case "DisplayName": 11587 if value != nil { 11588 jtv, ok := value.(string) 11589 if !ok { 11590 return fmt.Errorf("expected PortfolioDisplayName to be of type string, got %T instead", value) 11591 } 11592 sv.DisplayName = ptr.String(jtv) 11593 } 11594 11595 case "Id": 11596 if value != nil { 11597 jtv, ok := value.(string) 11598 if !ok { 11599 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 11600 } 11601 sv.Id = ptr.String(jtv) 11602 } 11603 11604 case "ProviderName": 11605 if value != nil { 11606 jtv, ok := value.(string) 11607 if !ok { 11608 return fmt.Errorf("expected ProviderName to be of type string, got %T instead", value) 11609 } 11610 sv.ProviderName = ptr.String(jtv) 11611 } 11612 11613 default: 11614 _, _ = key, value 11615 11616 } 11617 } 11618 *v = sv 11619 return nil 11620} 11621 11622func awsAwsjson11_deserializeDocumentPortfolioDetails(v *[]types.PortfolioDetail, value interface{}) error { 11623 if v == nil { 11624 return fmt.Errorf("unexpected nil of type %T", v) 11625 } 11626 if value == nil { 11627 return nil 11628 } 11629 11630 shape, ok := value.([]interface{}) 11631 if !ok { 11632 return fmt.Errorf("unexpected JSON type %v", value) 11633 } 11634 11635 var cv []types.PortfolioDetail 11636 if *v == nil { 11637 cv = []types.PortfolioDetail{} 11638 } else { 11639 cv = *v 11640 } 11641 11642 for _, value := range shape { 11643 var col types.PortfolioDetail 11644 destAddr := &col 11645 if err := awsAwsjson11_deserializeDocumentPortfolioDetail(&destAddr, value); err != nil { 11646 return err 11647 } 11648 col = *destAddr 11649 cv = append(cv, col) 11650 11651 } 11652 *v = cv 11653 return nil 11654} 11655 11656func awsAwsjson11_deserializeDocumentPortfolioShareDetail(v **types.PortfolioShareDetail, value interface{}) error { 11657 if v == nil { 11658 return fmt.Errorf("unexpected nil of type %T", v) 11659 } 11660 if value == nil { 11661 return nil 11662 } 11663 11664 shape, ok := value.(map[string]interface{}) 11665 if !ok { 11666 return fmt.Errorf("unexpected JSON type %v", value) 11667 } 11668 11669 var sv *types.PortfolioShareDetail 11670 if *v == nil { 11671 sv = &types.PortfolioShareDetail{} 11672 } else { 11673 sv = *v 11674 } 11675 11676 for key, value := range shape { 11677 switch key { 11678 case "Accepted": 11679 if value != nil { 11680 jtv, ok := value.(bool) 11681 if !ok { 11682 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 11683 } 11684 sv.Accepted = jtv 11685 } 11686 11687 case "PrincipalId": 11688 if value != nil { 11689 jtv, ok := value.(string) 11690 if !ok { 11691 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 11692 } 11693 sv.PrincipalId = ptr.String(jtv) 11694 } 11695 11696 case "ShareTagOptions": 11697 if value != nil { 11698 jtv, ok := value.(bool) 11699 if !ok { 11700 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 11701 } 11702 sv.ShareTagOptions = jtv 11703 } 11704 11705 case "Type": 11706 if value != nil { 11707 jtv, ok := value.(string) 11708 if !ok { 11709 return fmt.Errorf("expected DescribePortfolioShareType to be of type string, got %T instead", value) 11710 } 11711 sv.Type = types.DescribePortfolioShareType(jtv) 11712 } 11713 11714 default: 11715 _, _ = key, value 11716 11717 } 11718 } 11719 *v = sv 11720 return nil 11721} 11722 11723func awsAwsjson11_deserializeDocumentPortfolioShareDetails(v *[]types.PortfolioShareDetail, value interface{}) error { 11724 if v == nil { 11725 return fmt.Errorf("unexpected nil of type %T", v) 11726 } 11727 if value == nil { 11728 return nil 11729 } 11730 11731 shape, ok := value.([]interface{}) 11732 if !ok { 11733 return fmt.Errorf("unexpected JSON type %v", value) 11734 } 11735 11736 var cv []types.PortfolioShareDetail 11737 if *v == nil { 11738 cv = []types.PortfolioShareDetail{} 11739 } else { 11740 cv = *v 11741 } 11742 11743 for _, value := range shape { 11744 var col types.PortfolioShareDetail 11745 destAddr := &col 11746 if err := awsAwsjson11_deserializeDocumentPortfolioShareDetail(&destAddr, value); err != nil { 11747 return err 11748 } 11749 col = *destAddr 11750 cv = append(cv, col) 11751 11752 } 11753 *v = cv 11754 return nil 11755} 11756 11757func awsAwsjson11_deserializeDocumentPrincipal(v **types.Principal, value interface{}) error { 11758 if v == nil { 11759 return fmt.Errorf("unexpected nil of type %T", v) 11760 } 11761 if value == nil { 11762 return nil 11763 } 11764 11765 shape, ok := value.(map[string]interface{}) 11766 if !ok { 11767 return fmt.Errorf("unexpected JSON type %v", value) 11768 } 11769 11770 var sv *types.Principal 11771 if *v == nil { 11772 sv = &types.Principal{} 11773 } else { 11774 sv = *v 11775 } 11776 11777 for key, value := range shape { 11778 switch key { 11779 case "PrincipalARN": 11780 if value != nil { 11781 jtv, ok := value.(string) 11782 if !ok { 11783 return fmt.Errorf("expected PrincipalARN to be of type string, got %T instead", value) 11784 } 11785 sv.PrincipalARN = ptr.String(jtv) 11786 } 11787 11788 case "PrincipalType": 11789 if value != nil { 11790 jtv, ok := value.(string) 11791 if !ok { 11792 return fmt.Errorf("expected PrincipalType to be of type string, got %T instead", value) 11793 } 11794 sv.PrincipalType = types.PrincipalType(jtv) 11795 } 11796 11797 default: 11798 _, _ = key, value 11799 11800 } 11801 } 11802 *v = sv 11803 return nil 11804} 11805 11806func awsAwsjson11_deserializeDocumentPrincipals(v *[]types.Principal, value interface{}) error { 11807 if v == nil { 11808 return fmt.Errorf("unexpected nil of type %T", v) 11809 } 11810 if value == nil { 11811 return nil 11812 } 11813 11814 shape, ok := value.([]interface{}) 11815 if !ok { 11816 return fmt.Errorf("unexpected JSON type %v", value) 11817 } 11818 11819 var cv []types.Principal 11820 if *v == nil { 11821 cv = []types.Principal{} 11822 } else { 11823 cv = *v 11824 } 11825 11826 for _, value := range shape { 11827 var col types.Principal 11828 destAddr := &col 11829 if err := awsAwsjson11_deserializeDocumentPrincipal(&destAddr, value); err != nil { 11830 return err 11831 } 11832 col = *destAddr 11833 cv = append(cv, col) 11834 11835 } 11836 *v = cv 11837 return nil 11838} 11839 11840func awsAwsjson11_deserializeDocumentProductViewAggregations(v *map[string][]types.ProductViewAggregationValue, value interface{}) error { 11841 if v == nil { 11842 return fmt.Errorf("unexpected nil of type %T", v) 11843 } 11844 if value == nil { 11845 return nil 11846 } 11847 11848 shape, ok := value.(map[string]interface{}) 11849 if !ok { 11850 return fmt.Errorf("unexpected JSON type %v", value) 11851 } 11852 11853 var mv map[string][]types.ProductViewAggregationValue 11854 if *v == nil { 11855 mv = map[string][]types.ProductViewAggregationValue{} 11856 } else { 11857 mv = *v 11858 } 11859 11860 for key, value := range shape { 11861 var parsedVal []types.ProductViewAggregationValue 11862 mapVar := parsedVal 11863 if err := awsAwsjson11_deserializeDocumentProductViewAggregationValues(&mapVar, value); err != nil { 11864 return err 11865 } 11866 parsedVal = mapVar 11867 mv[key] = parsedVal 11868 11869 } 11870 *v = mv 11871 return nil 11872} 11873 11874func awsAwsjson11_deserializeDocumentProductViewAggregationValue(v **types.ProductViewAggregationValue, value interface{}) error { 11875 if v == nil { 11876 return fmt.Errorf("unexpected nil of type %T", v) 11877 } 11878 if value == nil { 11879 return nil 11880 } 11881 11882 shape, ok := value.(map[string]interface{}) 11883 if !ok { 11884 return fmt.Errorf("unexpected JSON type %v", value) 11885 } 11886 11887 var sv *types.ProductViewAggregationValue 11888 if *v == nil { 11889 sv = &types.ProductViewAggregationValue{} 11890 } else { 11891 sv = *v 11892 } 11893 11894 for key, value := range shape { 11895 switch key { 11896 case "ApproximateCount": 11897 if value != nil { 11898 jtv, ok := value.(json.Number) 11899 if !ok { 11900 return fmt.Errorf("expected ApproximateCount to be json.Number, got %T instead", value) 11901 } 11902 i64, err := jtv.Int64() 11903 if err != nil { 11904 return err 11905 } 11906 sv.ApproximateCount = int32(i64) 11907 } 11908 11909 case "Value": 11910 if value != nil { 11911 jtv, ok := value.(string) 11912 if !ok { 11913 return fmt.Errorf("expected AttributeValue to be of type string, got %T instead", value) 11914 } 11915 sv.Value = ptr.String(jtv) 11916 } 11917 11918 default: 11919 _, _ = key, value 11920 11921 } 11922 } 11923 *v = sv 11924 return nil 11925} 11926 11927func awsAwsjson11_deserializeDocumentProductViewAggregationValues(v *[]types.ProductViewAggregationValue, value interface{}) error { 11928 if v == nil { 11929 return fmt.Errorf("unexpected nil of type %T", v) 11930 } 11931 if value == nil { 11932 return nil 11933 } 11934 11935 shape, ok := value.([]interface{}) 11936 if !ok { 11937 return fmt.Errorf("unexpected JSON type %v", value) 11938 } 11939 11940 var cv []types.ProductViewAggregationValue 11941 if *v == nil { 11942 cv = []types.ProductViewAggregationValue{} 11943 } else { 11944 cv = *v 11945 } 11946 11947 for _, value := range shape { 11948 var col types.ProductViewAggregationValue 11949 destAddr := &col 11950 if err := awsAwsjson11_deserializeDocumentProductViewAggregationValue(&destAddr, value); err != nil { 11951 return err 11952 } 11953 col = *destAddr 11954 cv = append(cv, col) 11955 11956 } 11957 *v = cv 11958 return nil 11959} 11960 11961func awsAwsjson11_deserializeDocumentProductViewDetail(v **types.ProductViewDetail, value interface{}) error { 11962 if v == nil { 11963 return fmt.Errorf("unexpected nil of type %T", v) 11964 } 11965 if value == nil { 11966 return nil 11967 } 11968 11969 shape, ok := value.(map[string]interface{}) 11970 if !ok { 11971 return fmt.Errorf("unexpected JSON type %v", value) 11972 } 11973 11974 var sv *types.ProductViewDetail 11975 if *v == nil { 11976 sv = &types.ProductViewDetail{} 11977 } else { 11978 sv = *v 11979 } 11980 11981 for key, value := range shape { 11982 switch key { 11983 case "CreatedTime": 11984 if value != nil { 11985 jtv, ok := value.(json.Number) 11986 if !ok { 11987 return fmt.Errorf("expected CreatedTime to be json.Number, got %T instead", value) 11988 } 11989 f64, err := jtv.Float64() 11990 if err != nil { 11991 return err 11992 } 11993 sv.CreatedTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 11994 } 11995 11996 case "ProductARN": 11997 if value != nil { 11998 jtv, ok := value.(string) 11999 if !ok { 12000 return fmt.Errorf("expected ResourceARN to be of type string, got %T instead", value) 12001 } 12002 sv.ProductARN = ptr.String(jtv) 12003 } 12004 12005 case "ProductViewSummary": 12006 if err := awsAwsjson11_deserializeDocumentProductViewSummary(&sv.ProductViewSummary, value); err != nil { 12007 return err 12008 } 12009 12010 case "Status": 12011 if value != nil { 12012 jtv, ok := value.(string) 12013 if !ok { 12014 return fmt.Errorf("expected Status to be of type string, got %T instead", value) 12015 } 12016 sv.Status = types.Status(jtv) 12017 } 12018 12019 default: 12020 _, _ = key, value 12021 12022 } 12023 } 12024 *v = sv 12025 return nil 12026} 12027 12028func awsAwsjson11_deserializeDocumentProductViewDetails(v *[]types.ProductViewDetail, value interface{}) error { 12029 if v == nil { 12030 return fmt.Errorf("unexpected nil of type %T", v) 12031 } 12032 if value == nil { 12033 return nil 12034 } 12035 12036 shape, ok := value.([]interface{}) 12037 if !ok { 12038 return fmt.Errorf("unexpected JSON type %v", value) 12039 } 12040 12041 var cv []types.ProductViewDetail 12042 if *v == nil { 12043 cv = []types.ProductViewDetail{} 12044 } else { 12045 cv = *v 12046 } 12047 12048 for _, value := range shape { 12049 var col types.ProductViewDetail 12050 destAddr := &col 12051 if err := awsAwsjson11_deserializeDocumentProductViewDetail(&destAddr, value); err != nil { 12052 return err 12053 } 12054 col = *destAddr 12055 cv = append(cv, col) 12056 12057 } 12058 *v = cv 12059 return nil 12060} 12061 12062func awsAwsjson11_deserializeDocumentProductViewSummaries(v *[]types.ProductViewSummary, value interface{}) error { 12063 if v == nil { 12064 return fmt.Errorf("unexpected nil of type %T", v) 12065 } 12066 if value == nil { 12067 return nil 12068 } 12069 12070 shape, ok := value.([]interface{}) 12071 if !ok { 12072 return fmt.Errorf("unexpected JSON type %v", value) 12073 } 12074 12075 var cv []types.ProductViewSummary 12076 if *v == nil { 12077 cv = []types.ProductViewSummary{} 12078 } else { 12079 cv = *v 12080 } 12081 12082 for _, value := range shape { 12083 var col types.ProductViewSummary 12084 destAddr := &col 12085 if err := awsAwsjson11_deserializeDocumentProductViewSummary(&destAddr, value); err != nil { 12086 return err 12087 } 12088 col = *destAddr 12089 cv = append(cv, col) 12090 12091 } 12092 *v = cv 12093 return nil 12094} 12095 12096func awsAwsjson11_deserializeDocumentProductViewSummary(v **types.ProductViewSummary, value interface{}) error { 12097 if v == nil { 12098 return fmt.Errorf("unexpected nil of type %T", v) 12099 } 12100 if value == nil { 12101 return nil 12102 } 12103 12104 shape, ok := value.(map[string]interface{}) 12105 if !ok { 12106 return fmt.Errorf("unexpected JSON type %v", value) 12107 } 12108 12109 var sv *types.ProductViewSummary 12110 if *v == nil { 12111 sv = &types.ProductViewSummary{} 12112 } else { 12113 sv = *v 12114 } 12115 12116 for key, value := range shape { 12117 switch key { 12118 case "Distributor": 12119 if value != nil { 12120 jtv, ok := value.(string) 12121 if !ok { 12122 return fmt.Errorf("expected ProductViewDistributor to be of type string, got %T instead", value) 12123 } 12124 sv.Distributor = ptr.String(jtv) 12125 } 12126 12127 case "HasDefaultPath": 12128 if value != nil { 12129 jtv, ok := value.(bool) 12130 if !ok { 12131 return fmt.Errorf("expected HasDefaultPath to be of type *bool, got %T instead", value) 12132 } 12133 sv.HasDefaultPath = jtv 12134 } 12135 12136 case "Id": 12137 if value != nil { 12138 jtv, ok := value.(string) 12139 if !ok { 12140 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 12141 } 12142 sv.Id = ptr.String(jtv) 12143 } 12144 12145 case "Name": 12146 if value != nil { 12147 jtv, ok := value.(string) 12148 if !ok { 12149 return fmt.Errorf("expected ProductViewName to be of type string, got %T instead", value) 12150 } 12151 sv.Name = ptr.String(jtv) 12152 } 12153 12154 case "Owner": 12155 if value != nil { 12156 jtv, ok := value.(string) 12157 if !ok { 12158 return fmt.Errorf("expected ProductViewOwner to be of type string, got %T instead", value) 12159 } 12160 sv.Owner = ptr.String(jtv) 12161 } 12162 12163 case "ProductId": 12164 if value != nil { 12165 jtv, ok := value.(string) 12166 if !ok { 12167 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 12168 } 12169 sv.ProductId = ptr.String(jtv) 12170 } 12171 12172 case "ShortDescription": 12173 if value != nil { 12174 jtv, ok := value.(string) 12175 if !ok { 12176 return fmt.Errorf("expected ProductViewShortDescription to be of type string, got %T instead", value) 12177 } 12178 sv.ShortDescription = ptr.String(jtv) 12179 } 12180 12181 case "SupportDescription": 12182 if value != nil { 12183 jtv, ok := value.(string) 12184 if !ok { 12185 return fmt.Errorf("expected SupportDescription to be of type string, got %T instead", value) 12186 } 12187 sv.SupportDescription = ptr.String(jtv) 12188 } 12189 12190 case "SupportEmail": 12191 if value != nil { 12192 jtv, ok := value.(string) 12193 if !ok { 12194 return fmt.Errorf("expected SupportEmail to be of type string, got %T instead", value) 12195 } 12196 sv.SupportEmail = ptr.String(jtv) 12197 } 12198 12199 case "SupportUrl": 12200 if value != nil { 12201 jtv, ok := value.(string) 12202 if !ok { 12203 return fmt.Errorf("expected SupportUrl to be of type string, got %T instead", value) 12204 } 12205 sv.SupportUrl = ptr.String(jtv) 12206 } 12207 12208 case "Type": 12209 if value != nil { 12210 jtv, ok := value.(string) 12211 if !ok { 12212 return fmt.Errorf("expected ProductType to be of type string, got %T instead", value) 12213 } 12214 sv.Type = types.ProductType(jtv) 12215 } 12216 12217 default: 12218 _, _ = key, value 12219 12220 } 12221 } 12222 *v = sv 12223 return nil 12224} 12225 12226func awsAwsjson11_deserializeDocumentProvisionedProductAttribute(v **types.ProvisionedProductAttribute, value interface{}) error { 12227 if v == nil { 12228 return fmt.Errorf("unexpected nil of type %T", v) 12229 } 12230 if value == nil { 12231 return nil 12232 } 12233 12234 shape, ok := value.(map[string]interface{}) 12235 if !ok { 12236 return fmt.Errorf("unexpected JSON type %v", value) 12237 } 12238 12239 var sv *types.ProvisionedProductAttribute 12240 if *v == nil { 12241 sv = &types.ProvisionedProductAttribute{} 12242 } else { 12243 sv = *v 12244 } 12245 12246 for key, value := range shape { 12247 switch key { 12248 case "Arn": 12249 if value != nil { 12250 jtv, ok := value.(string) 12251 if !ok { 12252 return fmt.Errorf("expected ProvisionedProductNameOrArn to be of type string, got %T instead", value) 12253 } 12254 sv.Arn = ptr.String(jtv) 12255 } 12256 12257 case "CreatedTime": 12258 if value != nil { 12259 jtv, ok := value.(json.Number) 12260 if !ok { 12261 return fmt.Errorf("expected CreatedTime to be json.Number, got %T instead", value) 12262 } 12263 f64, err := jtv.Float64() 12264 if err != nil { 12265 return err 12266 } 12267 sv.CreatedTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 12268 } 12269 12270 case "Id": 12271 if value != nil { 12272 jtv, ok := value.(string) 12273 if !ok { 12274 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 12275 } 12276 sv.Id = ptr.String(jtv) 12277 } 12278 12279 case "IdempotencyToken": 12280 if value != nil { 12281 jtv, ok := value.(string) 12282 if !ok { 12283 return fmt.Errorf("expected IdempotencyToken to be of type string, got %T instead", value) 12284 } 12285 sv.IdempotencyToken = ptr.String(jtv) 12286 } 12287 12288 case "LastProvisioningRecordId": 12289 if value != nil { 12290 jtv, ok := value.(string) 12291 if !ok { 12292 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 12293 } 12294 sv.LastProvisioningRecordId = ptr.String(jtv) 12295 } 12296 12297 case "LastRecordId": 12298 if value != nil { 12299 jtv, ok := value.(string) 12300 if !ok { 12301 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 12302 } 12303 sv.LastRecordId = ptr.String(jtv) 12304 } 12305 12306 case "LastSuccessfulProvisioningRecordId": 12307 if value != nil { 12308 jtv, ok := value.(string) 12309 if !ok { 12310 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 12311 } 12312 sv.LastSuccessfulProvisioningRecordId = ptr.String(jtv) 12313 } 12314 12315 case "Name": 12316 if value != nil { 12317 jtv, ok := value.(string) 12318 if !ok { 12319 return fmt.Errorf("expected ProvisionedProductNameOrArn to be of type string, got %T instead", value) 12320 } 12321 sv.Name = ptr.String(jtv) 12322 } 12323 12324 case "PhysicalId": 12325 if value != nil { 12326 jtv, ok := value.(string) 12327 if !ok { 12328 return fmt.Errorf("expected PhysicalId to be of type string, got %T instead", value) 12329 } 12330 sv.PhysicalId = ptr.String(jtv) 12331 } 12332 12333 case "ProductId": 12334 if value != nil { 12335 jtv, ok := value.(string) 12336 if !ok { 12337 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 12338 } 12339 sv.ProductId = ptr.String(jtv) 12340 } 12341 12342 case "ProductName": 12343 if value != nil { 12344 jtv, ok := value.(string) 12345 if !ok { 12346 return fmt.Errorf("expected ProductViewName to be of type string, got %T instead", value) 12347 } 12348 sv.ProductName = ptr.String(jtv) 12349 } 12350 12351 case "ProvisioningArtifactId": 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.ProvisioningArtifactId = ptr.String(jtv) 12358 } 12359 12360 case "ProvisioningArtifactName": 12361 if value != nil { 12362 jtv, ok := value.(string) 12363 if !ok { 12364 return fmt.Errorf("expected ProvisioningArtifactName to be of type string, got %T instead", value) 12365 } 12366 sv.ProvisioningArtifactName = ptr.String(jtv) 12367 } 12368 12369 case "Status": 12370 if value != nil { 12371 jtv, ok := value.(string) 12372 if !ok { 12373 return fmt.Errorf("expected ProvisionedProductStatus to be of type string, got %T instead", value) 12374 } 12375 sv.Status = types.ProvisionedProductStatus(jtv) 12376 } 12377 12378 case "StatusMessage": 12379 if value != nil { 12380 jtv, ok := value.(string) 12381 if !ok { 12382 return fmt.Errorf("expected ProvisionedProductStatusMessage to be of type string, got %T instead", value) 12383 } 12384 sv.StatusMessage = ptr.String(jtv) 12385 } 12386 12387 case "Tags": 12388 if err := awsAwsjson11_deserializeDocumentTags(&sv.Tags, value); err != nil { 12389 return err 12390 } 12391 12392 case "Type": 12393 if value != nil { 12394 jtv, ok := value.(string) 12395 if !ok { 12396 return fmt.Errorf("expected ProvisionedProductType to be of type string, got %T instead", value) 12397 } 12398 sv.Type = ptr.String(jtv) 12399 } 12400 12401 case "UserArn": 12402 if value != nil { 12403 jtv, ok := value.(string) 12404 if !ok { 12405 return fmt.Errorf("expected UserArn to be of type string, got %T instead", value) 12406 } 12407 sv.UserArn = ptr.String(jtv) 12408 } 12409 12410 case "UserArnSession": 12411 if value != nil { 12412 jtv, ok := value.(string) 12413 if !ok { 12414 return fmt.Errorf("expected UserArnSession to be of type string, got %T instead", value) 12415 } 12416 sv.UserArnSession = ptr.String(jtv) 12417 } 12418 12419 default: 12420 _, _ = key, value 12421 12422 } 12423 } 12424 *v = sv 12425 return nil 12426} 12427 12428func awsAwsjson11_deserializeDocumentProvisionedProductAttributes(v *[]types.ProvisionedProductAttribute, value interface{}) error { 12429 if v == nil { 12430 return fmt.Errorf("unexpected nil of type %T", v) 12431 } 12432 if value == nil { 12433 return nil 12434 } 12435 12436 shape, ok := value.([]interface{}) 12437 if !ok { 12438 return fmt.Errorf("unexpected JSON type %v", value) 12439 } 12440 12441 var cv []types.ProvisionedProductAttribute 12442 if *v == nil { 12443 cv = []types.ProvisionedProductAttribute{} 12444 } else { 12445 cv = *v 12446 } 12447 12448 for _, value := range shape { 12449 var col types.ProvisionedProductAttribute 12450 destAddr := &col 12451 if err := awsAwsjson11_deserializeDocumentProvisionedProductAttribute(&destAddr, value); err != nil { 12452 return err 12453 } 12454 col = *destAddr 12455 cv = append(cv, col) 12456 12457 } 12458 *v = cv 12459 return nil 12460} 12461 12462func awsAwsjson11_deserializeDocumentProvisionedProductDetail(v **types.ProvisionedProductDetail, value interface{}) error { 12463 if v == nil { 12464 return fmt.Errorf("unexpected nil of type %T", v) 12465 } 12466 if value == nil { 12467 return nil 12468 } 12469 12470 shape, ok := value.(map[string]interface{}) 12471 if !ok { 12472 return fmt.Errorf("unexpected JSON type %v", value) 12473 } 12474 12475 var sv *types.ProvisionedProductDetail 12476 if *v == nil { 12477 sv = &types.ProvisionedProductDetail{} 12478 } else { 12479 sv = *v 12480 } 12481 12482 for key, value := range shape { 12483 switch key { 12484 case "Arn": 12485 if value != nil { 12486 jtv, ok := value.(string) 12487 if !ok { 12488 return fmt.Errorf("expected ProvisionedProductNameOrArn to be of type string, got %T instead", value) 12489 } 12490 sv.Arn = ptr.String(jtv) 12491 } 12492 12493 case "CreatedTime": 12494 if value != nil { 12495 jtv, ok := value.(json.Number) 12496 if !ok { 12497 return fmt.Errorf("expected CreatedTime to be json.Number, got %T instead", value) 12498 } 12499 f64, err := jtv.Float64() 12500 if err != nil { 12501 return err 12502 } 12503 sv.CreatedTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 12504 } 12505 12506 case "Id": 12507 if value != nil { 12508 jtv, ok := value.(string) 12509 if !ok { 12510 return fmt.Errorf("expected ProvisionedProductId to be of type string, got %T instead", value) 12511 } 12512 sv.Id = ptr.String(jtv) 12513 } 12514 12515 case "IdempotencyToken": 12516 if value != nil { 12517 jtv, ok := value.(string) 12518 if !ok { 12519 return fmt.Errorf("expected IdempotencyToken to be of type string, got %T instead", value) 12520 } 12521 sv.IdempotencyToken = ptr.String(jtv) 12522 } 12523 12524 case "LastProvisioningRecordId": 12525 if value != nil { 12526 jtv, ok := value.(string) 12527 if !ok { 12528 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 12529 } 12530 sv.LastProvisioningRecordId = ptr.String(jtv) 12531 } 12532 12533 case "LastRecordId": 12534 if value != nil { 12535 jtv, ok := value.(string) 12536 if !ok { 12537 return fmt.Errorf("expected LastRequestId to be of type string, got %T instead", value) 12538 } 12539 sv.LastRecordId = ptr.String(jtv) 12540 } 12541 12542 case "LastSuccessfulProvisioningRecordId": 12543 if value != nil { 12544 jtv, ok := value.(string) 12545 if !ok { 12546 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 12547 } 12548 sv.LastSuccessfulProvisioningRecordId = ptr.String(jtv) 12549 } 12550 12551 case "LaunchRoleArn": 12552 if value != nil { 12553 jtv, ok := value.(string) 12554 if !ok { 12555 return fmt.Errorf("expected RoleArn to be of type string, got %T instead", value) 12556 } 12557 sv.LaunchRoleArn = ptr.String(jtv) 12558 } 12559 12560 case "Name": 12561 if value != nil { 12562 jtv, ok := value.(string) 12563 if !ok { 12564 return fmt.Errorf("expected ProvisionedProductNameOrArn to be of type string, got %T instead", value) 12565 } 12566 sv.Name = ptr.String(jtv) 12567 } 12568 12569 case "ProductId": 12570 if value != nil { 12571 jtv, ok := value.(string) 12572 if !ok { 12573 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 12574 } 12575 sv.ProductId = ptr.String(jtv) 12576 } 12577 12578 case "ProvisioningArtifactId": 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.ProvisioningArtifactId = ptr.String(jtv) 12585 } 12586 12587 case "Status": 12588 if value != nil { 12589 jtv, ok := value.(string) 12590 if !ok { 12591 return fmt.Errorf("expected ProvisionedProductStatus to be of type string, got %T instead", value) 12592 } 12593 sv.Status = types.ProvisionedProductStatus(jtv) 12594 } 12595 12596 case "StatusMessage": 12597 if value != nil { 12598 jtv, ok := value.(string) 12599 if !ok { 12600 return fmt.Errorf("expected ProvisionedProductStatusMessage to be of type string, got %T instead", value) 12601 } 12602 sv.StatusMessage = ptr.String(jtv) 12603 } 12604 12605 case "Type": 12606 if value != nil { 12607 jtv, ok := value.(string) 12608 if !ok { 12609 return fmt.Errorf("expected ProvisionedProductType to be of type string, got %T instead", value) 12610 } 12611 sv.Type = ptr.String(jtv) 12612 } 12613 12614 default: 12615 _, _ = key, value 12616 12617 } 12618 } 12619 *v = sv 12620 return nil 12621} 12622 12623func awsAwsjson11_deserializeDocumentProvisionedProductDetails(v *[]types.ProvisionedProductDetail, value interface{}) error { 12624 if v == nil { 12625 return fmt.Errorf("unexpected nil of type %T", v) 12626 } 12627 if value == nil { 12628 return nil 12629 } 12630 12631 shape, ok := value.([]interface{}) 12632 if !ok { 12633 return fmt.Errorf("unexpected JSON type %v", value) 12634 } 12635 12636 var cv []types.ProvisionedProductDetail 12637 if *v == nil { 12638 cv = []types.ProvisionedProductDetail{} 12639 } else { 12640 cv = *v 12641 } 12642 12643 for _, value := range shape { 12644 var col types.ProvisionedProductDetail 12645 destAddr := &col 12646 if err := awsAwsjson11_deserializeDocumentProvisionedProductDetail(&destAddr, value); err != nil { 12647 return err 12648 } 12649 col = *destAddr 12650 cv = append(cv, col) 12651 12652 } 12653 *v = cv 12654 return nil 12655} 12656 12657func awsAwsjson11_deserializeDocumentProvisionedProductPlanDetails(v **types.ProvisionedProductPlanDetails, value interface{}) error { 12658 if v == nil { 12659 return fmt.Errorf("unexpected nil of type %T", v) 12660 } 12661 if value == nil { 12662 return nil 12663 } 12664 12665 shape, ok := value.(map[string]interface{}) 12666 if !ok { 12667 return fmt.Errorf("unexpected JSON type %v", value) 12668 } 12669 12670 var sv *types.ProvisionedProductPlanDetails 12671 if *v == nil { 12672 sv = &types.ProvisionedProductPlanDetails{} 12673 } else { 12674 sv = *v 12675 } 12676 12677 for key, value := range shape { 12678 switch key { 12679 case "CreatedTime": 12680 if value != nil { 12681 jtv, ok := value.(json.Number) 12682 if !ok { 12683 return fmt.Errorf("expected CreatedTime to be json.Number, got %T instead", value) 12684 } 12685 f64, err := jtv.Float64() 12686 if err != nil { 12687 return err 12688 } 12689 sv.CreatedTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 12690 } 12691 12692 case "NotificationArns": 12693 if err := awsAwsjson11_deserializeDocumentNotificationArns(&sv.NotificationArns, value); err != nil { 12694 return err 12695 } 12696 12697 case "PathId": 12698 if value != nil { 12699 jtv, ok := value.(string) 12700 if !ok { 12701 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 12702 } 12703 sv.PathId = ptr.String(jtv) 12704 } 12705 12706 case "PlanId": 12707 if value != nil { 12708 jtv, ok := value.(string) 12709 if !ok { 12710 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 12711 } 12712 sv.PlanId = ptr.String(jtv) 12713 } 12714 12715 case "PlanName": 12716 if value != nil { 12717 jtv, ok := value.(string) 12718 if !ok { 12719 return fmt.Errorf("expected ProvisionedProductPlanName to be of type string, got %T instead", value) 12720 } 12721 sv.PlanName = ptr.String(jtv) 12722 } 12723 12724 case "PlanType": 12725 if value != nil { 12726 jtv, ok := value.(string) 12727 if !ok { 12728 return fmt.Errorf("expected ProvisionedProductPlanType to be of type string, got %T instead", value) 12729 } 12730 sv.PlanType = types.ProvisionedProductPlanType(jtv) 12731 } 12732 12733 case "ProductId": 12734 if value != nil { 12735 jtv, ok := value.(string) 12736 if !ok { 12737 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 12738 } 12739 sv.ProductId = ptr.String(jtv) 12740 } 12741 12742 case "ProvisioningArtifactId": 12743 if value != nil { 12744 jtv, ok := value.(string) 12745 if !ok { 12746 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 12747 } 12748 sv.ProvisioningArtifactId = ptr.String(jtv) 12749 } 12750 12751 case "ProvisioningParameters": 12752 if err := awsAwsjson11_deserializeDocumentUpdateProvisioningParameters(&sv.ProvisioningParameters, value); err != nil { 12753 return err 12754 } 12755 12756 case "ProvisionProductId": 12757 if value != nil { 12758 jtv, ok := value.(string) 12759 if !ok { 12760 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 12761 } 12762 sv.ProvisionProductId = ptr.String(jtv) 12763 } 12764 12765 case "ProvisionProductName": 12766 if value != nil { 12767 jtv, ok := value.(string) 12768 if !ok { 12769 return fmt.Errorf("expected ProvisionedProductName to be of type string, got %T instead", value) 12770 } 12771 sv.ProvisionProductName = ptr.String(jtv) 12772 } 12773 12774 case "Status": 12775 if value != nil { 12776 jtv, ok := value.(string) 12777 if !ok { 12778 return fmt.Errorf("expected ProvisionedProductPlanStatus to be of type string, got %T instead", value) 12779 } 12780 sv.Status = types.ProvisionedProductPlanStatus(jtv) 12781 } 12782 12783 case "StatusMessage": 12784 if value != nil { 12785 jtv, ok := value.(string) 12786 if !ok { 12787 return fmt.Errorf("expected StatusMessage to be of type string, got %T instead", value) 12788 } 12789 sv.StatusMessage = ptr.String(jtv) 12790 } 12791 12792 case "Tags": 12793 if err := awsAwsjson11_deserializeDocumentTags(&sv.Tags, value); err != nil { 12794 return err 12795 } 12796 12797 case "UpdatedTime": 12798 if value != nil { 12799 jtv, ok := value.(json.Number) 12800 if !ok { 12801 return fmt.Errorf("expected UpdatedTime to be json.Number, got %T instead", value) 12802 } 12803 f64, err := jtv.Float64() 12804 if err != nil { 12805 return err 12806 } 12807 sv.UpdatedTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 12808 } 12809 12810 default: 12811 _, _ = key, value 12812 12813 } 12814 } 12815 *v = sv 12816 return nil 12817} 12818 12819func awsAwsjson11_deserializeDocumentProvisionedProductPlans(v *[]types.ProvisionedProductPlanSummary, value interface{}) error { 12820 if v == nil { 12821 return fmt.Errorf("unexpected nil of type %T", v) 12822 } 12823 if value == nil { 12824 return nil 12825 } 12826 12827 shape, ok := value.([]interface{}) 12828 if !ok { 12829 return fmt.Errorf("unexpected JSON type %v", value) 12830 } 12831 12832 var cv []types.ProvisionedProductPlanSummary 12833 if *v == nil { 12834 cv = []types.ProvisionedProductPlanSummary{} 12835 } else { 12836 cv = *v 12837 } 12838 12839 for _, value := range shape { 12840 var col types.ProvisionedProductPlanSummary 12841 destAddr := &col 12842 if err := awsAwsjson11_deserializeDocumentProvisionedProductPlanSummary(&destAddr, value); err != nil { 12843 return err 12844 } 12845 col = *destAddr 12846 cv = append(cv, col) 12847 12848 } 12849 *v = cv 12850 return nil 12851} 12852 12853func awsAwsjson11_deserializeDocumentProvisionedProductPlanSummary(v **types.ProvisionedProductPlanSummary, value interface{}) error { 12854 if v == nil { 12855 return fmt.Errorf("unexpected nil of type %T", v) 12856 } 12857 if value == nil { 12858 return nil 12859 } 12860 12861 shape, ok := value.(map[string]interface{}) 12862 if !ok { 12863 return fmt.Errorf("unexpected JSON type %v", value) 12864 } 12865 12866 var sv *types.ProvisionedProductPlanSummary 12867 if *v == nil { 12868 sv = &types.ProvisionedProductPlanSummary{} 12869 } else { 12870 sv = *v 12871 } 12872 12873 for key, value := range shape { 12874 switch key { 12875 case "PlanId": 12876 if value != nil { 12877 jtv, ok := value.(string) 12878 if !ok { 12879 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 12880 } 12881 sv.PlanId = ptr.String(jtv) 12882 } 12883 12884 case "PlanName": 12885 if value != nil { 12886 jtv, ok := value.(string) 12887 if !ok { 12888 return fmt.Errorf("expected ProvisionedProductPlanName to be of type string, got %T instead", value) 12889 } 12890 sv.PlanName = ptr.String(jtv) 12891 } 12892 12893 case "PlanType": 12894 if value != nil { 12895 jtv, ok := value.(string) 12896 if !ok { 12897 return fmt.Errorf("expected ProvisionedProductPlanType to be of type string, got %T instead", value) 12898 } 12899 sv.PlanType = types.ProvisionedProductPlanType(jtv) 12900 } 12901 12902 case "ProvisioningArtifactId": 12903 if value != nil { 12904 jtv, ok := value.(string) 12905 if !ok { 12906 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 12907 } 12908 sv.ProvisioningArtifactId = ptr.String(jtv) 12909 } 12910 12911 case "ProvisionProductId": 12912 if value != nil { 12913 jtv, ok := value.(string) 12914 if !ok { 12915 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 12916 } 12917 sv.ProvisionProductId = ptr.String(jtv) 12918 } 12919 12920 case "ProvisionProductName": 12921 if value != nil { 12922 jtv, ok := value.(string) 12923 if !ok { 12924 return fmt.Errorf("expected ProvisionedProductName to be of type string, got %T instead", value) 12925 } 12926 sv.ProvisionProductName = ptr.String(jtv) 12927 } 12928 12929 default: 12930 _, _ = key, value 12931 12932 } 12933 } 12934 *v = sv 12935 return nil 12936} 12937 12938func awsAwsjson11_deserializeDocumentProvisionedProductProperties(v *map[string]string, value interface{}) error { 12939 if v == nil { 12940 return fmt.Errorf("unexpected nil of type %T", v) 12941 } 12942 if value == nil { 12943 return nil 12944 } 12945 12946 shape, ok := value.(map[string]interface{}) 12947 if !ok { 12948 return fmt.Errorf("unexpected JSON type %v", value) 12949 } 12950 12951 var mv map[string]string 12952 if *v == nil { 12953 mv = map[string]string{} 12954 } else { 12955 mv = *v 12956 } 12957 12958 for key, value := range shape { 12959 var parsedVal string 12960 if value != nil { 12961 jtv, ok := value.(string) 12962 if !ok { 12963 return fmt.Errorf("expected PropertyValue to be of type string, got %T instead", value) 12964 } 12965 parsedVal = jtv 12966 } 12967 mv[key] = parsedVal 12968 12969 } 12970 *v = mv 12971 return nil 12972} 12973 12974func awsAwsjson11_deserializeDocumentProvisioningArtifact(v **types.ProvisioningArtifact, value interface{}) error { 12975 if v == nil { 12976 return fmt.Errorf("unexpected nil of type %T", v) 12977 } 12978 if value == nil { 12979 return nil 12980 } 12981 12982 shape, ok := value.(map[string]interface{}) 12983 if !ok { 12984 return fmt.Errorf("unexpected JSON type %v", value) 12985 } 12986 12987 var sv *types.ProvisioningArtifact 12988 if *v == nil { 12989 sv = &types.ProvisioningArtifact{} 12990 } else { 12991 sv = *v 12992 } 12993 12994 for key, value := range shape { 12995 switch key { 12996 case "CreatedTime": 12997 if value != nil { 12998 jtv, ok := value.(json.Number) 12999 if !ok { 13000 return fmt.Errorf("expected ProvisioningArtifactCreatedTime to be json.Number, got %T instead", value) 13001 } 13002 f64, err := jtv.Float64() 13003 if err != nil { 13004 return err 13005 } 13006 sv.CreatedTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 13007 } 13008 13009 case "Description": 13010 if value != nil { 13011 jtv, ok := value.(string) 13012 if !ok { 13013 return fmt.Errorf("expected ProvisioningArtifactDescription to be of type string, got %T instead", value) 13014 } 13015 sv.Description = ptr.String(jtv) 13016 } 13017 13018 case "Guidance": 13019 if value != nil { 13020 jtv, ok := value.(string) 13021 if !ok { 13022 return fmt.Errorf("expected ProvisioningArtifactGuidance to be of type string, got %T instead", value) 13023 } 13024 sv.Guidance = types.ProvisioningArtifactGuidance(jtv) 13025 } 13026 13027 case "Id": 13028 if value != nil { 13029 jtv, ok := value.(string) 13030 if !ok { 13031 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 13032 } 13033 sv.Id = ptr.String(jtv) 13034 } 13035 13036 case "Name": 13037 if value != nil { 13038 jtv, ok := value.(string) 13039 if !ok { 13040 return fmt.Errorf("expected ProvisioningArtifactName to be of type string, got %T instead", value) 13041 } 13042 sv.Name = ptr.String(jtv) 13043 } 13044 13045 default: 13046 _, _ = key, value 13047 13048 } 13049 } 13050 *v = sv 13051 return nil 13052} 13053 13054func awsAwsjson11_deserializeDocumentProvisioningArtifactDetail(v **types.ProvisioningArtifactDetail, value interface{}) error { 13055 if v == nil { 13056 return fmt.Errorf("unexpected nil of type %T", v) 13057 } 13058 if value == nil { 13059 return nil 13060 } 13061 13062 shape, ok := value.(map[string]interface{}) 13063 if !ok { 13064 return fmt.Errorf("unexpected JSON type %v", value) 13065 } 13066 13067 var sv *types.ProvisioningArtifactDetail 13068 if *v == nil { 13069 sv = &types.ProvisioningArtifactDetail{} 13070 } else { 13071 sv = *v 13072 } 13073 13074 for key, value := range shape { 13075 switch key { 13076 case "Active": 13077 if value != nil { 13078 jtv, ok := value.(bool) 13079 if !ok { 13080 return fmt.Errorf("expected ProvisioningArtifactActive to be of type *bool, got %T instead", value) 13081 } 13082 sv.Active = ptr.Bool(jtv) 13083 } 13084 13085 case "CreatedTime": 13086 if value != nil { 13087 jtv, ok := value.(json.Number) 13088 if !ok { 13089 return fmt.Errorf("expected CreationTime to be json.Number, got %T instead", value) 13090 } 13091 f64, err := jtv.Float64() 13092 if err != nil { 13093 return err 13094 } 13095 sv.CreatedTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 13096 } 13097 13098 case "Description": 13099 if value != nil { 13100 jtv, ok := value.(string) 13101 if !ok { 13102 return fmt.Errorf("expected ProvisioningArtifactName to be of type string, got %T instead", value) 13103 } 13104 sv.Description = ptr.String(jtv) 13105 } 13106 13107 case "Guidance": 13108 if value != nil { 13109 jtv, ok := value.(string) 13110 if !ok { 13111 return fmt.Errorf("expected ProvisioningArtifactGuidance to be of type string, got %T instead", value) 13112 } 13113 sv.Guidance = types.ProvisioningArtifactGuidance(jtv) 13114 } 13115 13116 case "Id": 13117 if value != nil { 13118 jtv, ok := value.(string) 13119 if !ok { 13120 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 13121 } 13122 sv.Id = ptr.String(jtv) 13123 } 13124 13125 case "Name": 13126 if value != nil { 13127 jtv, ok := value.(string) 13128 if !ok { 13129 return fmt.Errorf("expected ProvisioningArtifactName to be of type string, got %T instead", value) 13130 } 13131 sv.Name = ptr.String(jtv) 13132 } 13133 13134 case "Type": 13135 if value != nil { 13136 jtv, ok := value.(string) 13137 if !ok { 13138 return fmt.Errorf("expected ProvisioningArtifactType to be of type string, got %T instead", value) 13139 } 13140 sv.Type = types.ProvisioningArtifactType(jtv) 13141 } 13142 13143 default: 13144 _, _ = key, value 13145 13146 } 13147 } 13148 *v = sv 13149 return nil 13150} 13151 13152func awsAwsjson11_deserializeDocumentProvisioningArtifactDetails(v *[]types.ProvisioningArtifactDetail, value interface{}) error { 13153 if v == nil { 13154 return fmt.Errorf("unexpected nil of type %T", v) 13155 } 13156 if value == nil { 13157 return nil 13158 } 13159 13160 shape, ok := value.([]interface{}) 13161 if !ok { 13162 return fmt.Errorf("unexpected JSON type %v", value) 13163 } 13164 13165 var cv []types.ProvisioningArtifactDetail 13166 if *v == nil { 13167 cv = []types.ProvisioningArtifactDetail{} 13168 } else { 13169 cv = *v 13170 } 13171 13172 for _, value := range shape { 13173 var col types.ProvisioningArtifactDetail 13174 destAddr := &col 13175 if err := awsAwsjson11_deserializeDocumentProvisioningArtifactDetail(&destAddr, value); err != nil { 13176 return err 13177 } 13178 col = *destAddr 13179 cv = append(cv, col) 13180 13181 } 13182 *v = cv 13183 return nil 13184} 13185 13186func awsAwsjson11_deserializeDocumentProvisioningArtifactInfo(v *map[string]string, value interface{}) error { 13187 if v == nil { 13188 return fmt.Errorf("unexpected nil of type %T", v) 13189 } 13190 if value == nil { 13191 return nil 13192 } 13193 13194 shape, ok := value.(map[string]interface{}) 13195 if !ok { 13196 return fmt.Errorf("unexpected JSON type %v", value) 13197 } 13198 13199 var mv map[string]string 13200 if *v == nil { 13201 mv = map[string]string{} 13202 } else { 13203 mv = *v 13204 } 13205 13206 for key, value := range shape { 13207 var parsedVal string 13208 if value != nil { 13209 jtv, ok := value.(string) 13210 if !ok { 13211 return fmt.Errorf("expected ProvisioningArtifactInfoValue to be of type string, got %T instead", value) 13212 } 13213 parsedVal = jtv 13214 } 13215 mv[key] = parsedVal 13216 13217 } 13218 *v = mv 13219 return nil 13220} 13221 13222func awsAwsjson11_deserializeDocumentProvisioningArtifactOutput(v **types.ProvisioningArtifactOutput, value interface{}) error { 13223 if v == nil { 13224 return fmt.Errorf("unexpected nil of type %T", v) 13225 } 13226 if value == nil { 13227 return nil 13228 } 13229 13230 shape, ok := value.(map[string]interface{}) 13231 if !ok { 13232 return fmt.Errorf("unexpected JSON type %v", value) 13233 } 13234 13235 var sv *types.ProvisioningArtifactOutput 13236 if *v == nil { 13237 sv = &types.ProvisioningArtifactOutput{} 13238 } else { 13239 sv = *v 13240 } 13241 13242 for key, value := range shape { 13243 switch key { 13244 case "Description": 13245 if value != nil { 13246 jtv, ok := value.(string) 13247 if !ok { 13248 return fmt.Errorf("expected OutputDescription to be of type string, got %T instead", value) 13249 } 13250 sv.Description = ptr.String(jtv) 13251 } 13252 13253 case "Key": 13254 if value != nil { 13255 jtv, ok := value.(string) 13256 if !ok { 13257 return fmt.Errorf("expected ProvisioningArtifactOutputKey to be of type string, got %T instead", value) 13258 } 13259 sv.Key = ptr.String(jtv) 13260 } 13261 13262 default: 13263 _, _ = key, value 13264 13265 } 13266 } 13267 *v = sv 13268 return nil 13269} 13270 13271func awsAwsjson11_deserializeDocumentProvisioningArtifactOutputs(v *[]types.ProvisioningArtifactOutput, value interface{}) error { 13272 if v == nil { 13273 return fmt.Errorf("unexpected nil of type %T", v) 13274 } 13275 if value == nil { 13276 return nil 13277 } 13278 13279 shape, ok := value.([]interface{}) 13280 if !ok { 13281 return fmt.Errorf("unexpected JSON type %v", value) 13282 } 13283 13284 var cv []types.ProvisioningArtifactOutput 13285 if *v == nil { 13286 cv = []types.ProvisioningArtifactOutput{} 13287 } else { 13288 cv = *v 13289 } 13290 13291 for _, value := range shape { 13292 var col types.ProvisioningArtifactOutput 13293 destAddr := &col 13294 if err := awsAwsjson11_deserializeDocumentProvisioningArtifactOutput(&destAddr, value); err != nil { 13295 return err 13296 } 13297 col = *destAddr 13298 cv = append(cv, col) 13299 13300 } 13301 *v = cv 13302 return nil 13303} 13304 13305func awsAwsjson11_deserializeDocumentProvisioningArtifactParameter(v **types.ProvisioningArtifactParameter, value interface{}) error { 13306 if v == nil { 13307 return fmt.Errorf("unexpected nil of type %T", v) 13308 } 13309 if value == nil { 13310 return nil 13311 } 13312 13313 shape, ok := value.(map[string]interface{}) 13314 if !ok { 13315 return fmt.Errorf("unexpected JSON type %v", value) 13316 } 13317 13318 var sv *types.ProvisioningArtifactParameter 13319 if *v == nil { 13320 sv = &types.ProvisioningArtifactParameter{} 13321 } else { 13322 sv = *v 13323 } 13324 13325 for key, value := range shape { 13326 switch key { 13327 case "DefaultValue": 13328 if value != nil { 13329 jtv, ok := value.(string) 13330 if !ok { 13331 return fmt.Errorf("expected DefaultValue to be of type string, got %T instead", value) 13332 } 13333 sv.DefaultValue = ptr.String(jtv) 13334 } 13335 13336 case "Description": 13337 if value != nil { 13338 jtv, ok := value.(string) 13339 if !ok { 13340 return fmt.Errorf("expected Description to be of type string, got %T instead", value) 13341 } 13342 sv.Description = ptr.String(jtv) 13343 } 13344 13345 case "IsNoEcho": 13346 if value != nil { 13347 jtv, ok := value.(bool) 13348 if !ok { 13349 return fmt.Errorf("expected NoEcho to be of type *bool, got %T instead", value) 13350 } 13351 sv.IsNoEcho = jtv 13352 } 13353 13354 case "ParameterConstraints": 13355 if err := awsAwsjson11_deserializeDocumentParameterConstraints(&sv.ParameterConstraints, value); err != nil { 13356 return err 13357 } 13358 13359 case "ParameterKey": 13360 if value != nil { 13361 jtv, ok := value.(string) 13362 if !ok { 13363 return fmt.Errorf("expected ParameterKey to be of type string, got %T instead", value) 13364 } 13365 sv.ParameterKey = ptr.String(jtv) 13366 } 13367 13368 case "ParameterType": 13369 if value != nil { 13370 jtv, ok := value.(string) 13371 if !ok { 13372 return fmt.Errorf("expected ParameterType to be of type string, got %T instead", value) 13373 } 13374 sv.ParameterType = ptr.String(jtv) 13375 } 13376 13377 default: 13378 _, _ = key, value 13379 13380 } 13381 } 13382 *v = sv 13383 return nil 13384} 13385 13386func awsAwsjson11_deserializeDocumentProvisioningArtifactParameters(v *[]types.ProvisioningArtifactParameter, value interface{}) error { 13387 if v == nil { 13388 return fmt.Errorf("unexpected nil of type %T", v) 13389 } 13390 if value == nil { 13391 return nil 13392 } 13393 13394 shape, ok := value.([]interface{}) 13395 if !ok { 13396 return fmt.Errorf("unexpected JSON type %v", value) 13397 } 13398 13399 var cv []types.ProvisioningArtifactParameter 13400 if *v == nil { 13401 cv = []types.ProvisioningArtifactParameter{} 13402 } else { 13403 cv = *v 13404 } 13405 13406 for _, value := range shape { 13407 var col types.ProvisioningArtifactParameter 13408 destAddr := &col 13409 if err := awsAwsjson11_deserializeDocumentProvisioningArtifactParameter(&destAddr, value); err != nil { 13410 return err 13411 } 13412 col = *destAddr 13413 cv = append(cv, col) 13414 13415 } 13416 *v = cv 13417 return nil 13418} 13419 13420func awsAwsjson11_deserializeDocumentProvisioningArtifactPreferences(v **types.ProvisioningArtifactPreferences, value interface{}) error { 13421 if v == nil { 13422 return fmt.Errorf("unexpected nil of type %T", v) 13423 } 13424 if value == nil { 13425 return nil 13426 } 13427 13428 shape, ok := value.(map[string]interface{}) 13429 if !ok { 13430 return fmt.Errorf("unexpected JSON type %v", value) 13431 } 13432 13433 var sv *types.ProvisioningArtifactPreferences 13434 if *v == nil { 13435 sv = &types.ProvisioningArtifactPreferences{} 13436 } else { 13437 sv = *v 13438 } 13439 13440 for key, value := range shape { 13441 switch key { 13442 case "StackSetAccounts": 13443 if err := awsAwsjson11_deserializeDocumentStackSetAccounts(&sv.StackSetAccounts, value); err != nil { 13444 return err 13445 } 13446 13447 case "StackSetRegions": 13448 if err := awsAwsjson11_deserializeDocumentStackSetRegions(&sv.StackSetRegions, value); err != nil { 13449 return err 13450 } 13451 13452 default: 13453 _, _ = key, value 13454 13455 } 13456 } 13457 *v = sv 13458 return nil 13459} 13460 13461func awsAwsjson11_deserializeDocumentProvisioningArtifacts(v *[]types.ProvisioningArtifact, value interface{}) error { 13462 if v == nil { 13463 return fmt.Errorf("unexpected nil of type %T", v) 13464 } 13465 if value == nil { 13466 return nil 13467 } 13468 13469 shape, ok := value.([]interface{}) 13470 if !ok { 13471 return fmt.Errorf("unexpected JSON type %v", value) 13472 } 13473 13474 var cv []types.ProvisioningArtifact 13475 if *v == nil { 13476 cv = []types.ProvisioningArtifact{} 13477 } else { 13478 cv = *v 13479 } 13480 13481 for _, value := range shape { 13482 var col types.ProvisioningArtifact 13483 destAddr := &col 13484 if err := awsAwsjson11_deserializeDocumentProvisioningArtifact(&destAddr, value); err != nil { 13485 return err 13486 } 13487 col = *destAddr 13488 cv = append(cv, col) 13489 13490 } 13491 *v = cv 13492 return nil 13493} 13494 13495func awsAwsjson11_deserializeDocumentProvisioningArtifactSummaries(v *[]types.ProvisioningArtifactSummary, value interface{}) error { 13496 if v == nil { 13497 return fmt.Errorf("unexpected nil of type %T", v) 13498 } 13499 if value == nil { 13500 return nil 13501 } 13502 13503 shape, ok := value.([]interface{}) 13504 if !ok { 13505 return fmt.Errorf("unexpected JSON type %v", value) 13506 } 13507 13508 var cv []types.ProvisioningArtifactSummary 13509 if *v == nil { 13510 cv = []types.ProvisioningArtifactSummary{} 13511 } else { 13512 cv = *v 13513 } 13514 13515 for _, value := range shape { 13516 var col types.ProvisioningArtifactSummary 13517 destAddr := &col 13518 if err := awsAwsjson11_deserializeDocumentProvisioningArtifactSummary(&destAddr, value); err != nil { 13519 return err 13520 } 13521 col = *destAddr 13522 cv = append(cv, col) 13523 13524 } 13525 *v = cv 13526 return nil 13527} 13528 13529func awsAwsjson11_deserializeDocumentProvisioningArtifactSummary(v **types.ProvisioningArtifactSummary, value interface{}) error { 13530 if v == nil { 13531 return fmt.Errorf("unexpected nil of type %T", v) 13532 } 13533 if value == nil { 13534 return nil 13535 } 13536 13537 shape, ok := value.(map[string]interface{}) 13538 if !ok { 13539 return fmt.Errorf("unexpected JSON type %v", value) 13540 } 13541 13542 var sv *types.ProvisioningArtifactSummary 13543 if *v == nil { 13544 sv = &types.ProvisioningArtifactSummary{} 13545 } else { 13546 sv = *v 13547 } 13548 13549 for key, value := range shape { 13550 switch key { 13551 case "CreatedTime": 13552 if value != nil { 13553 jtv, ok := value.(json.Number) 13554 if !ok { 13555 return fmt.Errorf("expected ProvisioningArtifactCreatedTime to be json.Number, got %T instead", value) 13556 } 13557 f64, err := jtv.Float64() 13558 if err != nil { 13559 return err 13560 } 13561 sv.CreatedTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 13562 } 13563 13564 case "Description": 13565 if value != nil { 13566 jtv, ok := value.(string) 13567 if !ok { 13568 return fmt.Errorf("expected ProvisioningArtifactDescription to be of type string, got %T instead", value) 13569 } 13570 sv.Description = ptr.String(jtv) 13571 } 13572 13573 case "Id": 13574 if value != nil { 13575 jtv, ok := value.(string) 13576 if !ok { 13577 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 13578 } 13579 sv.Id = ptr.String(jtv) 13580 } 13581 13582 case "Name": 13583 if value != nil { 13584 jtv, ok := value.(string) 13585 if !ok { 13586 return fmt.Errorf("expected ProvisioningArtifactName to be of type string, got %T instead", value) 13587 } 13588 sv.Name = ptr.String(jtv) 13589 } 13590 13591 case "ProvisioningArtifactMetadata": 13592 if err := awsAwsjson11_deserializeDocumentProvisioningArtifactInfo(&sv.ProvisioningArtifactMetadata, value); err != nil { 13593 return err 13594 } 13595 13596 default: 13597 _, _ = key, value 13598 13599 } 13600 } 13601 *v = sv 13602 return nil 13603} 13604 13605func awsAwsjson11_deserializeDocumentProvisioningArtifactView(v **types.ProvisioningArtifactView, value interface{}) error { 13606 if v == nil { 13607 return fmt.Errorf("unexpected nil of type %T", v) 13608 } 13609 if value == nil { 13610 return nil 13611 } 13612 13613 shape, ok := value.(map[string]interface{}) 13614 if !ok { 13615 return fmt.Errorf("unexpected JSON type %v", value) 13616 } 13617 13618 var sv *types.ProvisioningArtifactView 13619 if *v == nil { 13620 sv = &types.ProvisioningArtifactView{} 13621 } else { 13622 sv = *v 13623 } 13624 13625 for key, value := range shape { 13626 switch key { 13627 case "ProductViewSummary": 13628 if err := awsAwsjson11_deserializeDocumentProductViewSummary(&sv.ProductViewSummary, value); err != nil { 13629 return err 13630 } 13631 13632 case "ProvisioningArtifact": 13633 if err := awsAwsjson11_deserializeDocumentProvisioningArtifact(&sv.ProvisioningArtifact, value); err != nil { 13634 return err 13635 } 13636 13637 default: 13638 _, _ = key, value 13639 13640 } 13641 } 13642 *v = sv 13643 return nil 13644} 13645 13646func awsAwsjson11_deserializeDocumentProvisioningArtifactViews(v *[]types.ProvisioningArtifactView, value interface{}) error { 13647 if v == nil { 13648 return fmt.Errorf("unexpected nil of type %T", v) 13649 } 13650 if value == nil { 13651 return nil 13652 } 13653 13654 shape, ok := value.([]interface{}) 13655 if !ok { 13656 return fmt.Errorf("unexpected JSON type %v", value) 13657 } 13658 13659 var cv []types.ProvisioningArtifactView 13660 if *v == nil { 13661 cv = []types.ProvisioningArtifactView{} 13662 } else { 13663 cv = *v 13664 } 13665 13666 for _, value := range shape { 13667 var col types.ProvisioningArtifactView 13668 destAddr := &col 13669 if err := awsAwsjson11_deserializeDocumentProvisioningArtifactView(&destAddr, value); err != nil { 13670 return err 13671 } 13672 col = *destAddr 13673 cv = append(cv, col) 13674 13675 } 13676 *v = cv 13677 return nil 13678} 13679 13680func awsAwsjson11_deserializeDocumentRecordDetail(v **types.RecordDetail, value interface{}) error { 13681 if v == nil { 13682 return fmt.Errorf("unexpected nil of type %T", v) 13683 } 13684 if value == nil { 13685 return nil 13686 } 13687 13688 shape, ok := value.(map[string]interface{}) 13689 if !ok { 13690 return fmt.Errorf("unexpected JSON type %v", value) 13691 } 13692 13693 var sv *types.RecordDetail 13694 if *v == nil { 13695 sv = &types.RecordDetail{} 13696 } else { 13697 sv = *v 13698 } 13699 13700 for key, value := range shape { 13701 switch key { 13702 case "CreatedTime": 13703 if value != nil { 13704 jtv, ok := value.(json.Number) 13705 if !ok { 13706 return fmt.Errorf("expected CreatedTime to be json.Number, got %T instead", value) 13707 } 13708 f64, err := jtv.Float64() 13709 if err != nil { 13710 return err 13711 } 13712 sv.CreatedTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 13713 } 13714 13715 case "LaunchRoleArn": 13716 if value != nil { 13717 jtv, ok := value.(string) 13718 if !ok { 13719 return fmt.Errorf("expected RoleArn to be of type string, got %T instead", value) 13720 } 13721 sv.LaunchRoleArn = ptr.String(jtv) 13722 } 13723 13724 case "PathId": 13725 if value != nil { 13726 jtv, ok := value.(string) 13727 if !ok { 13728 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 13729 } 13730 sv.PathId = ptr.String(jtv) 13731 } 13732 13733 case "ProductId": 13734 if value != nil { 13735 jtv, ok := value.(string) 13736 if !ok { 13737 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 13738 } 13739 sv.ProductId = ptr.String(jtv) 13740 } 13741 13742 case "ProvisionedProductId": 13743 if value != nil { 13744 jtv, ok := value.(string) 13745 if !ok { 13746 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 13747 } 13748 sv.ProvisionedProductId = ptr.String(jtv) 13749 } 13750 13751 case "ProvisionedProductName": 13752 if value != nil { 13753 jtv, ok := value.(string) 13754 if !ok { 13755 return fmt.Errorf("expected ProvisionedProductName to be of type string, got %T instead", value) 13756 } 13757 sv.ProvisionedProductName = ptr.String(jtv) 13758 } 13759 13760 case "ProvisionedProductType": 13761 if value != nil { 13762 jtv, ok := value.(string) 13763 if !ok { 13764 return fmt.Errorf("expected ProvisionedProductType to be of type string, got %T instead", value) 13765 } 13766 sv.ProvisionedProductType = ptr.String(jtv) 13767 } 13768 13769 case "ProvisioningArtifactId": 13770 if value != nil { 13771 jtv, ok := value.(string) 13772 if !ok { 13773 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 13774 } 13775 sv.ProvisioningArtifactId = ptr.String(jtv) 13776 } 13777 13778 case "RecordErrors": 13779 if err := awsAwsjson11_deserializeDocumentRecordErrors(&sv.RecordErrors, value); err != nil { 13780 return err 13781 } 13782 13783 case "RecordId": 13784 if value != nil { 13785 jtv, ok := value.(string) 13786 if !ok { 13787 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 13788 } 13789 sv.RecordId = ptr.String(jtv) 13790 } 13791 13792 case "RecordTags": 13793 if err := awsAwsjson11_deserializeDocumentRecordTags(&sv.RecordTags, value); err != nil { 13794 return err 13795 } 13796 13797 case "RecordType": 13798 if value != nil { 13799 jtv, ok := value.(string) 13800 if !ok { 13801 return fmt.Errorf("expected RecordType to be of type string, got %T instead", value) 13802 } 13803 sv.RecordType = ptr.String(jtv) 13804 } 13805 13806 case "Status": 13807 if value != nil { 13808 jtv, ok := value.(string) 13809 if !ok { 13810 return fmt.Errorf("expected RecordStatus to be of type string, got %T instead", value) 13811 } 13812 sv.Status = types.RecordStatus(jtv) 13813 } 13814 13815 case "UpdatedTime": 13816 if value != nil { 13817 jtv, ok := value.(json.Number) 13818 if !ok { 13819 return fmt.Errorf("expected UpdatedTime to be json.Number, got %T instead", value) 13820 } 13821 f64, err := jtv.Float64() 13822 if err != nil { 13823 return err 13824 } 13825 sv.UpdatedTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 13826 } 13827 13828 default: 13829 _, _ = key, value 13830 13831 } 13832 } 13833 *v = sv 13834 return nil 13835} 13836 13837func awsAwsjson11_deserializeDocumentRecordDetails(v *[]types.RecordDetail, value interface{}) error { 13838 if v == nil { 13839 return fmt.Errorf("unexpected nil of type %T", v) 13840 } 13841 if value == nil { 13842 return nil 13843 } 13844 13845 shape, ok := value.([]interface{}) 13846 if !ok { 13847 return fmt.Errorf("unexpected JSON type %v", value) 13848 } 13849 13850 var cv []types.RecordDetail 13851 if *v == nil { 13852 cv = []types.RecordDetail{} 13853 } else { 13854 cv = *v 13855 } 13856 13857 for _, value := range shape { 13858 var col types.RecordDetail 13859 destAddr := &col 13860 if err := awsAwsjson11_deserializeDocumentRecordDetail(&destAddr, value); err != nil { 13861 return err 13862 } 13863 col = *destAddr 13864 cv = append(cv, col) 13865 13866 } 13867 *v = cv 13868 return nil 13869} 13870 13871func awsAwsjson11_deserializeDocumentRecordError(v **types.RecordError, value interface{}) error { 13872 if v == nil { 13873 return fmt.Errorf("unexpected nil of type %T", v) 13874 } 13875 if value == nil { 13876 return nil 13877 } 13878 13879 shape, ok := value.(map[string]interface{}) 13880 if !ok { 13881 return fmt.Errorf("unexpected JSON type %v", value) 13882 } 13883 13884 var sv *types.RecordError 13885 if *v == nil { 13886 sv = &types.RecordError{} 13887 } else { 13888 sv = *v 13889 } 13890 13891 for key, value := range shape { 13892 switch key { 13893 case "Code": 13894 if value != nil { 13895 jtv, ok := value.(string) 13896 if !ok { 13897 return fmt.Errorf("expected ErrorCode to be of type string, got %T instead", value) 13898 } 13899 sv.Code = ptr.String(jtv) 13900 } 13901 13902 case "Description": 13903 if value != nil { 13904 jtv, ok := value.(string) 13905 if !ok { 13906 return fmt.Errorf("expected ErrorDescription to be of type string, got %T instead", value) 13907 } 13908 sv.Description = ptr.String(jtv) 13909 } 13910 13911 default: 13912 _, _ = key, value 13913 13914 } 13915 } 13916 *v = sv 13917 return nil 13918} 13919 13920func awsAwsjson11_deserializeDocumentRecordErrors(v *[]types.RecordError, value interface{}) error { 13921 if v == nil { 13922 return fmt.Errorf("unexpected nil of type %T", v) 13923 } 13924 if value == nil { 13925 return nil 13926 } 13927 13928 shape, ok := value.([]interface{}) 13929 if !ok { 13930 return fmt.Errorf("unexpected JSON type %v", value) 13931 } 13932 13933 var cv []types.RecordError 13934 if *v == nil { 13935 cv = []types.RecordError{} 13936 } else { 13937 cv = *v 13938 } 13939 13940 for _, value := range shape { 13941 var col types.RecordError 13942 destAddr := &col 13943 if err := awsAwsjson11_deserializeDocumentRecordError(&destAddr, value); err != nil { 13944 return err 13945 } 13946 col = *destAddr 13947 cv = append(cv, col) 13948 13949 } 13950 *v = cv 13951 return nil 13952} 13953 13954func awsAwsjson11_deserializeDocumentRecordOutput(v **types.RecordOutput, value interface{}) error { 13955 if v == nil { 13956 return fmt.Errorf("unexpected nil of type %T", v) 13957 } 13958 if value == nil { 13959 return nil 13960 } 13961 13962 shape, ok := value.(map[string]interface{}) 13963 if !ok { 13964 return fmt.Errorf("unexpected JSON type %v", value) 13965 } 13966 13967 var sv *types.RecordOutput 13968 if *v == nil { 13969 sv = &types.RecordOutput{} 13970 } else { 13971 sv = *v 13972 } 13973 13974 for key, value := range shape { 13975 switch key { 13976 case "Description": 13977 if value != nil { 13978 jtv, ok := value.(string) 13979 if !ok { 13980 return fmt.Errorf("expected Description to be of type string, got %T instead", value) 13981 } 13982 sv.Description = ptr.String(jtv) 13983 } 13984 13985 case "OutputKey": 13986 if value != nil { 13987 jtv, ok := value.(string) 13988 if !ok { 13989 return fmt.Errorf("expected OutputKey to be of type string, got %T instead", value) 13990 } 13991 sv.OutputKey = ptr.String(jtv) 13992 } 13993 13994 case "OutputValue": 13995 if value != nil { 13996 jtv, ok := value.(string) 13997 if !ok { 13998 return fmt.Errorf("expected OutputValue to be of type string, got %T instead", value) 13999 } 14000 sv.OutputValue = ptr.String(jtv) 14001 } 14002 14003 default: 14004 _, _ = key, value 14005 14006 } 14007 } 14008 *v = sv 14009 return nil 14010} 14011 14012func awsAwsjson11_deserializeDocumentRecordOutputs(v *[]types.RecordOutput, value interface{}) error { 14013 if v == nil { 14014 return fmt.Errorf("unexpected nil of type %T", v) 14015 } 14016 if value == nil { 14017 return nil 14018 } 14019 14020 shape, ok := value.([]interface{}) 14021 if !ok { 14022 return fmt.Errorf("unexpected JSON type %v", value) 14023 } 14024 14025 var cv []types.RecordOutput 14026 if *v == nil { 14027 cv = []types.RecordOutput{} 14028 } else { 14029 cv = *v 14030 } 14031 14032 for _, value := range shape { 14033 var col types.RecordOutput 14034 destAddr := &col 14035 if err := awsAwsjson11_deserializeDocumentRecordOutput(&destAddr, value); err != nil { 14036 return err 14037 } 14038 col = *destAddr 14039 cv = append(cv, col) 14040 14041 } 14042 *v = cv 14043 return nil 14044} 14045 14046func awsAwsjson11_deserializeDocumentRecordTag(v **types.RecordTag, value interface{}) error { 14047 if v == nil { 14048 return fmt.Errorf("unexpected nil of type %T", v) 14049 } 14050 if value == nil { 14051 return nil 14052 } 14053 14054 shape, ok := value.(map[string]interface{}) 14055 if !ok { 14056 return fmt.Errorf("unexpected JSON type %v", value) 14057 } 14058 14059 var sv *types.RecordTag 14060 if *v == nil { 14061 sv = &types.RecordTag{} 14062 } else { 14063 sv = *v 14064 } 14065 14066 for key, value := range shape { 14067 switch key { 14068 case "Key": 14069 if value != nil { 14070 jtv, ok := value.(string) 14071 if !ok { 14072 return fmt.Errorf("expected RecordTagKey to be of type string, got %T instead", value) 14073 } 14074 sv.Key = ptr.String(jtv) 14075 } 14076 14077 case "Value": 14078 if value != nil { 14079 jtv, ok := value.(string) 14080 if !ok { 14081 return fmt.Errorf("expected RecordTagValue to be of type string, got %T instead", value) 14082 } 14083 sv.Value = ptr.String(jtv) 14084 } 14085 14086 default: 14087 _, _ = key, value 14088 14089 } 14090 } 14091 *v = sv 14092 return nil 14093} 14094 14095func awsAwsjson11_deserializeDocumentRecordTags(v *[]types.RecordTag, value interface{}) error { 14096 if v == nil { 14097 return fmt.Errorf("unexpected nil of type %T", v) 14098 } 14099 if value == nil { 14100 return nil 14101 } 14102 14103 shape, ok := value.([]interface{}) 14104 if !ok { 14105 return fmt.Errorf("unexpected JSON type %v", value) 14106 } 14107 14108 var cv []types.RecordTag 14109 if *v == nil { 14110 cv = []types.RecordTag{} 14111 } else { 14112 cv = *v 14113 } 14114 14115 for _, value := range shape { 14116 var col types.RecordTag 14117 destAddr := &col 14118 if err := awsAwsjson11_deserializeDocumentRecordTag(&destAddr, value); err != nil { 14119 return err 14120 } 14121 col = *destAddr 14122 cv = append(cv, col) 14123 14124 } 14125 *v = cv 14126 return nil 14127} 14128 14129func awsAwsjson11_deserializeDocumentResourceChange(v **types.ResourceChange, value interface{}) error { 14130 if v == nil { 14131 return fmt.Errorf("unexpected nil of type %T", v) 14132 } 14133 if value == nil { 14134 return nil 14135 } 14136 14137 shape, ok := value.(map[string]interface{}) 14138 if !ok { 14139 return fmt.Errorf("unexpected JSON type %v", value) 14140 } 14141 14142 var sv *types.ResourceChange 14143 if *v == nil { 14144 sv = &types.ResourceChange{} 14145 } else { 14146 sv = *v 14147 } 14148 14149 for key, value := range shape { 14150 switch key { 14151 case "Action": 14152 if value != nil { 14153 jtv, ok := value.(string) 14154 if !ok { 14155 return fmt.Errorf("expected ChangeAction to be of type string, got %T instead", value) 14156 } 14157 sv.Action = types.ChangeAction(jtv) 14158 } 14159 14160 case "Details": 14161 if err := awsAwsjson11_deserializeDocumentResourceChangeDetails(&sv.Details, value); err != nil { 14162 return err 14163 } 14164 14165 case "LogicalResourceId": 14166 if value != nil { 14167 jtv, ok := value.(string) 14168 if !ok { 14169 return fmt.Errorf("expected LogicalResourceId to be of type string, got %T instead", value) 14170 } 14171 sv.LogicalResourceId = ptr.String(jtv) 14172 } 14173 14174 case "PhysicalResourceId": 14175 if value != nil { 14176 jtv, ok := value.(string) 14177 if !ok { 14178 return fmt.Errorf("expected PhysicalResourceId to be of type string, got %T instead", value) 14179 } 14180 sv.PhysicalResourceId = ptr.String(jtv) 14181 } 14182 14183 case "Replacement": 14184 if value != nil { 14185 jtv, ok := value.(string) 14186 if !ok { 14187 return fmt.Errorf("expected Replacement to be of type string, got %T instead", value) 14188 } 14189 sv.Replacement = types.Replacement(jtv) 14190 } 14191 14192 case "ResourceType": 14193 if value != nil { 14194 jtv, ok := value.(string) 14195 if !ok { 14196 return fmt.Errorf("expected PlanResourceType to be of type string, got %T instead", value) 14197 } 14198 sv.ResourceType = ptr.String(jtv) 14199 } 14200 14201 case "Scope": 14202 if err := awsAwsjson11_deserializeDocumentScope(&sv.Scope, value); err != nil { 14203 return err 14204 } 14205 14206 default: 14207 _, _ = key, value 14208 14209 } 14210 } 14211 *v = sv 14212 return nil 14213} 14214 14215func awsAwsjson11_deserializeDocumentResourceChangeDetail(v **types.ResourceChangeDetail, value interface{}) error { 14216 if v == nil { 14217 return fmt.Errorf("unexpected nil of type %T", v) 14218 } 14219 if value == nil { 14220 return nil 14221 } 14222 14223 shape, ok := value.(map[string]interface{}) 14224 if !ok { 14225 return fmt.Errorf("unexpected JSON type %v", value) 14226 } 14227 14228 var sv *types.ResourceChangeDetail 14229 if *v == nil { 14230 sv = &types.ResourceChangeDetail{} 14231 } else { 14232 sv = *v 14233 } 14234 14235 for key, value := range shape { 14236 switch key { 14237 case "CausingEntity": 14238 if value != nil { 14239 jtv, ok := value.(string) 14240 if !ok { 14241 return fmt.Errorf("expected CausingEntity to be of type string, got %T instead", value) 14242 } 14243 sv.CausingEntity = ptr.String(jtv) 14244 } 14245 14246 case "Evaluation": 14247 if value != nil { 14248 jtv, ok := value.(string) 14249 if !ok { 14250 return fmt.Errorf("expected EvaluationType to be of type string, got %T instead", value) 14251 } 14252 sv.Evaluation = types.EvaluationType(jtv) 14253 } 14254 14255 case "Target": 14256 if err := awsAwsjson11_deserializeDocumentResourceTargetDefinition(&sv.Target, 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_deserializeDocumentResourceChangeDetails(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.([]interface{}) 14278 if !ok { 14279 return fmt.Errorf("unexpected JSON type %v", value) 14280 } 14281 14282 var cv []types.ResourceChangeDetail 14283 if *v == nil { 14284 cv = []types.ResourceChangeDetail{} 14285 } else { 14286 cv = *v 14287 } 14288 14289 for _, value := range shape { 14290 var col types.ResourceChangeDetail 14291 destAddr := &col 14292 if err := awsAwsjson11_deserializeDocumentResourceChangeDetail(&destAddr, value); err != nil { 14293 return err 14294 } 14295 col = *destAddr 14296 cv = append(cv, col) 14297 14298 } 14299 *v = cv 14300 return nil 14301} 14302 14303func awsAwsjson11_deserializeDocumentResourceChanges(v *[]types.ResourceChange, value interface{}) error { 14304 if v == nil { 14305 return fmt.Errorf("unexpected nil of type %T", v) 14306 } 14307 if value == nil { 14308 return nil 14309 } 14310 14311 shape, ok := value.([]interface{}) 14312 if !ok { 14313 return fmt.Errorf("unexpected JSON type %v", value) 14314 } 14315 14316 var cv []types.ResourceChange 14317 if *v == nil { 14318 cv = []types.ResourceChange{} 14319 } else { 14320 cv = *v 14321 } 14322 14323 for _, value := range shape { 14324 var col types.ResourceChange 14325 destAddr := &col 14326 if err := awsAwsjson11_deserializeDocumentResourceChange(&destAddr, value); err != nil { 14327 return err 14328 } 14329 col = *destAddr 14330 cv = append(cv, col) 14331 14332 } 14333 *v = cv 14334 return nil 14335} 14336 14337func awsAwsjson11_deserializeDocumentResourceDetail(v **types.ResourceDetail, value interface{}) error { 14338 if v == nil { 14339 return fmt.Errorf("unexpected nil of type %T", v) 14340 } 14341 if value == nil { 14342 return nil 14343 } 14344 14345 shape, ok := value.(map[string]interface{}) 14346 if !ok { 14347 return fmt.Errorf("unexpected JSON type %v", value) 14348 } 14349 14350 var sv *types.ResourceDetail 14351 if *v == nil { 14352 sv = &types.ResourceDetail{} 14353 } else { 14354 sv = *v 14355 } 14356 14357 for key, value := range shape { 14358 switch key { 14359 case "ARN": 14360 if value != nil { 14361 jtv, ok := value.(string) 14362 if !ok { 14363 return fmt.Errorf("expected ResourceDetailARN to be of type string, got %T instead", value) 14364 } 14365 sv.ARN = ptr.String(jtv) 14366 } 14367 14368 case "CreatedTime": 14369 if value != nil { 14370 jtv, ok := value.(json.Number) 14371 if !ok { 14372 return fmt.Errorf("expected ResourceDetailCreatedTime to be json.Number, got %T instead", value) 14373 } 14374 f64, err := jtv.Float64() 14375 if err != nil { 14376 return err 14377 } 14378 sv.CreatedTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 14379 } 14380 14381 case "Description": 14382 if value != nil { 14383 jtv, ok := value.(string) 14384 if !ok { 14385 return fmt.Errorf("expected ResourceDetailDescription to be of type string, got %T instead", value) 14386 } 14387 sv.Description = ptr.String(jtv) 14388 } 14389 14390 case "Id": 14391 if value != nil { 14392 jtv, ok := value.(string) 14393 if !ok { 14394 return fmt.Errorf("expected ResourceDetailId to be of type string, got %T instead", value) 14395 } 14396 sv.Id = ptr.String(jtv) 14397 } 14398 14399 case "Name": 14400 if value != nil { 14401 jtv, ok := value.(string) 14402 if !ok { 14403 return fmt.Errorf("expected ResourceDetailName to be of type string, got %T instead", value) 14404 } 14405 sv.Name = ptr.String(jtv) 14406 } 14407 14408 default: 14409 _, _ = key, value 14410 14411 } 14412 } 14413 *v = sv 14414 return nil 14415} 14416 14417func awsAwsjson11_deserializeDocumentResourceDetails(v *[]types.ResourceDetail, value interface{}) error { 14418 if v == nil { 14419 return fmt.Errorf("unexpected nil of type %T", v) 14420 } 14421 if value == nil { 14422 return nil 14423 } 14424 14425 shape, ok := value.([]interface{}) 14426 if !ok { 14427 return fmt.Errorf("unexpected JSON type %v", value) 14428 } 14429 14430 var cv []types.ResourceDetail 14431 if *v == nil { 14432 cv = []types.ResourceDetail{} 14433 } else { 14434 cv = *v 14435 } 14436 14437 for _, value := range shape { 14438 var col types.ResourceDetail 14439 destAddr := &col 14440 if err := awsAwsjson11_deserializeDocumentResourceDetail(&destAddr, value); err != nil { 14441 return err 14442 } 14443 col = *destAddr 14444 cv = append(cv, col) 14445 14446 } 14447 *v = cv 14448 return nil 14449} 14450 14451func awsAwsjson11_deserializeDocumentResourceInUseException(v **types.ResourceInUseException, value interface{}) error { 14452 if v == nil { 14453 return fmt.Errorf("unexpected nil of type %T", v) 14454 } 14455 if value == nil { 14456 return nil 14457 } 14458 14459 shape, ok := value.(map[string]interface{}) 14460 if !ok { 14461 return fmt.Errorf("unexpected JSON type %v", value) 14462 } 14463 14464 var sv *types.ResourceInUseException 14465 if *v == nil { 14466 sv = &types.ResourceInUseException{} 14467 } else { 14468 sv = *v 14469 } 14470 14471 for key, value := range shape { 14472 switch key { 14473 case "Message": 14474 if value != nil { 14475 jtv, ok := value.(string) 14476 if !ok { 14477 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 14478 } 14479 sv.Message = ptr.String(jtv) 14480 } 14481 14482 default: 14483 _, _ = key, value 14484 14485 } 14486 } 14487 *v = sv 14488 return nil 14489} 14490 14491func awsAwsjson11_deserializeDocumentResourceNotFoundException(v **types.ResourceNotFoundException, value interface{}) error { 14492 if v == nil { 14493 return fmt.Errorf("unexpected nil of type %T", v) 14494 } 14495 if value == nil { 14496 return nil 14497 } 14498 14499 shape, ok := value.(map[string]interface{}) 14500 if !ok { 14501 return fmt.Errorf("unexpected JSON type %v", value) 14502 } 14503 14504 var sv *types.ResourceNotFoundException 14505 if *v == nil { 14506 sv = &types.ResourceNotFoundException{} 14507 } else { 14508 sv = *v 14509 } 14510 14511 for key, value := range shape { 14512 switch key { 14513 case "Message": 14514 if value != nil { 14515 jtv, ok := value.(string) 14516 if !ok { 14517 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 14518 } 14519 sv.Message = ptr.String(jtv) 14520 } 14521 14522 default: 14523 _, _ = key, value 14524 14525 } 14526 } 14527 *v = sv 14528 return nil 14529} 14530 14531func awsAwsjson11_deserializeDocumentResourceTargetDefinition(v **types.ResourceTargetDefinition, value interface{}) error { 14532 if v == nil { 14533 return fmt.Errorf("unexpected nil of type %T", v) 14534 } 14535 if value == nil { 14536 return nil 14537 } 14538 14539 shape, ok := value.(map[string]interface{}) 14540 if !ok { 14541 return fmt.Errorf("unexpected JSON type %v", value) 14542 } 14543 14544 var sv *types.ResourceTargetDefinition 14545 if *v == nil { 14546 sv = &types.ResourceTargetDefinition{} 14547 } else { 14548 sv = *v 14549 } 14550 14551 for key, value := range shape { 14552 switch key { 14553 case "Attribute": 14554 if value != nil { 14555 jtv, ok := value.(string) 14556 if !ok { 14557 return fmt.Errorf("expected ResourceAttribute to be of type string, got %T instead", value) 14558 } 14559 sv.Attribute = types.ResourceAttribute(jtv) 14560 } 14561 14562 case "Name": 14563 if value != nil { 14564 jtv, ok := value.(string) 14565 if !ok { 14566 return fmt.Errorf("expected PropertyName to be of type string, got %T instead", value) 14567 } 14568 sv.Name = ptr.String(jtv) 14569 } 14570 14571 case "RequiresRecreation": 14572 if value != nil { 14573 jtv, ok := value.(string) 14574 if !ok { 14575 return fmt.Errorf("expected RequiresRecreation to be of type string, got %T instead", value) 14576 } 14577 sv.RequiresRecreation = types.RequiresRecreation(jtv) 14578 } 14579 14580 default: 14581 _, _ = key, value 14582 14583 } 14584 } 14585 *v = sv 14586 return nil 14587} 14588 14589func awsAwsjson11_deserializeDocumentScope(v *[]types.ResourceAttribute, value interface{}) error { 14590 if v == nil { 14591 return fmt.Errorf("unexpected nil of type %T", v) 14592 } 14593 if value == nil { 14594 return nil 14595 } 14596 14597 shape, ok := value.([]interface{}) 14598 if !ok { 14599 return fmt.Errorf("unexpected JSON type %v", value) 14600 } 14601 14602 var cv []types.ResourceAttribute 14603 if *v == nil { 14604 cv = []types.ResourceAttribute{} 14605 } else { 14606 cv = *v 14607 } 14608 14609 for _, value := range shape { 14610 var col types.ResourceAttribute 14611 if value != nil { 14612 jtv, ok := value.(string) 14613 if !ok { 14614 return fmt.Errorf("expected ResourceAttribute to be of type string, got %T instead", value) 14615 } 14616 col = types.ResourceAttribute(jtv) 14617 } 14618 cv = append(cv, col) 14619 14620 } 14621 *v = cv 14622 return nil 14623} 14624 14625func awsAwsjson11_deserializeDocumentServiceActionDefinitionMap(v *map[string]string, value interface{}) error { 14626 if v == nil { 14627 return fmt.Errorf("unexpected nil of type %T", v) 14628 } 14629 if value == nil { 14630 return nil 14631 } 14632 14633 shape, ok := value.(map[string]interface{}) 14634 if !ok { 14635 return fmt.Errorf("unexpected JSON type %v", value) 14636 } 14637 14638 var mv map[string]string 14639 if *v == nil { 14640 mv = map[string]string{} 14641 } else { 14642 mv = *v 14643 } 14644 14645 for key, value := range shape { 14646 var parsedVal string 14647 if value != nil { 14648 jtv, ok := value.(string) 14649 if !ok { 14650 return fmt.Errorf("expected ServiceActionDefinitionValue to be of type string, got %T instead", value) 14651 } 14652 parsedVal = jtv 14653 } 14654 mv[key] = parsedVal 14655 14656 } 14657 *v = mv 14658 return nil 14659} 14660 14661func awsAwsjson11_deserializeDocumentServiceActionDetail(v **types.ServiceActionDetail, value interface{}) error { 14662 if v == nil { 14663 return fmt.Errorf("unexpected nil of type %T", v) 14664 } 14665 if value == nil { 14666 return nil 14667 } 14668 14669 shape, ok := value.(map[string]interface{}) 14670 if !ok { 14671 return fmt.Errorf("unexpected JSON type %v", value) 14672 } 14673 14674 var sv *types.ServiceActionDetail 14675 if *v == nil { 14676 sv = &types.ServiceActionDetail{} 14677 } else { 14678 sv = *v 14679 } 14680 14681 for key, value := range shape { 14682 switch key { 14683 case "Definition": 14684 if err := awsAwsjson11_deserializeDocumentServiceActionDefinitionMap(&sv.Definition, value); err != nil { 14685 return err 14686 } 14687 14688 case "ServiceActionSummary": 14689 if err := awsAwsjson11_deserializeDocumentServiceActionSummary(&sv.ServiceActionSummary, value); err != nil { 14690 return err 14691 } 14692 14693 default: 14694 _, _ = key, value 14695 14696 } 14697 } 14698 *v = sv 14699 return nil 14700} 14701 14702func awsAwsjson11_deserializeDocumentServiceActionSummaries(v *[]types.ServiceActionSummary, value interface{}) error { 14703 if v == nil { 14704 return fmt.Errorf("unexpected nil of type %T", v) 14705 } 14706 if value == nil { 14707 return nil 14708 } 14709 14710 shape, ok := value.([]interface{}) 14711 if !ok { 14712 return fmt.Errorf("unexpected JSON type %v", value) 14713 } 14714 14715 var cv []types.ServiceActionSummary 14716 if *v == nil { 14717 cv = []types.ServiceActionSummary{} 14718 } else { 14719 cv = *v 14720 } 14721 14722 for _, value := range shape { 14723 var col types.ServiceActionSummary 14724 destAddr := &col 14725 if err := awsAwsjson11_deserializeDocumentServiceActionSummary(&destAddr, value); err != nil { 14726 return err 14727 } 14728 col = *destAddr 14729 cv = append(cv, col) 14730 14731 } 14732 *v = cv 14733 return nil 14734} 14735 14736func awsAwsjson11_deserializeDocumentServiceActionSummary(v **types.ServiceActionSummary, value interface{}) error { 14737 if v == nil { 14738 return fmt.Errorf("unexpected nil of type %T", v) 14739 } 14740 if value == nil { 14741 return nil 14742 } 14743 14744 shape, ok := value.(map[string]interface{}) 14745 if !ok { 14746 return fmt.Errorf("unexpected JSON type %v", value) 14747 } 14748 14749 var sv *types.ServiceActionSummary 14750 if *v == nil { 14751 sv = &types.ServiceActionSummary{} 14752 } else { 14753 sv = *v 14754 } 14755 14756 for key, value := range shape { 14757 switch key { 14758 case "DefinitionType": 14759 if value != nil { 14760 jtv, ok := value.(string) 14761 if !ok { 14762 return fmt.Errorf("expected ServiceActionDefinitionType to be of type string, got %T instead", value) 14763 } 14764 sv.DefinitionType = types.ServiceActionDefinitionType(jtv) 14765 } 14766 14767 case "Description": 14768 if value != nil { 14769 jtv, ok := value.(string) 14770 if !ok { 14771 return fmt.Errorf("expected ServiceActionDescription to be of type string, got %T instead", value) 14772 } 14773 sv.Description = ptr.String(jtv) 14774 } 14775 14776 case "Id": 14777 if value != nil { 14778 jtv, ok := value.(string) 14779 if !ok { 14780 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 14781 } 14782 sv.Id = ptr.String(jtv) 14783 } 14784 14785 case "Name": 14786 if value != nil { 14787 jtv, ok := value.(string) 14788 if !ok { 14789 return fmt.Errorf("expected ServiceActionName to be of type string, got %T instead", value) 14790 } 14791 sv.Name = ptr.String(jtv) 14792 } 14793 14794 default: 14795 _, _ = key, value 14796 14797 } 14798 } 14799 *v = sv 14800 return nil 14801} 14802 14803func awsAwsjson11_deserializeDocumentShareDetails(v **types.ShareDetails, value interface{}) error { 14804 if v == nil { 14805 return fmt.Errorf("unexpected nil of type %T", v) 14806 } 14807 if value == nil { 14808 return nil 14809 } 14810 14811 shape, ok := value.(map[string]interface{}) 14812 if !ok { 14813 return fmt.Errorf("unexpected JSON type %v", value) 14814 } 14815 14816 var sv *types.ShareDetails 14817 if *v == nil { 14818 sv = &types.ShareDetails{} 14819 } else { 14820 sv = *v 14821 } 14822 14823 for key, value := range shape { 14824 switch key { 14825 case "ShareErrors": 14826 if err := awsAwsjson11_deserializeDocumentShareErrors(&sv.ShareErrors, value); err != nil { 14827 return err 14828 } 14829 14830 case "SuccessfulShares": 14831 if err := awsAwsjson11_deserializeDocumentSuccessfulShares(&sv.SuccessfulShares, value); err != nil { 14832 return err 14833 } 14834 14835 default: 14836 _, _ = key, value 14837 14838 } 14839 } 14840 *v = sv 14841 return nil 14842} 14843 14844func awsAwsjson11_deserializeDocumentShareError(v **types.ShareError, value interface{}) error { 14845 if v == nil { 14846 return fmt.Errorf("unexpected nil of type %T", v) 14847 } 14848 if value == nil { 14849 return nil 14850 } 14851 14852 shape, ok := value.(map[string]interface{}) 14853 if !ok { 14854 return fmt.Errorf("unexpected JSON type %v", value) 14855 } 14856 14857 var sv *types.ShareError 14858 if *v == nil { 14859 sv = &types.ShareError{} 14860 } else { 14861 sv = *v 14862 } 14863 14864 for key, value := range shape { 14865 switch key { 14866 case "Accounts": 14867 if err := awsAwsjson11_deserializeDocumentNamespaces(&sv.Accounts, value); err != nil { 14868 return err 14869 } 14870 14871 case "Error": 14872 if value != nil { 14873 jtv, ok := value.(string) 14874 if !ok { 14875 return fmt.Errorf("expected Error to be of type string, got %T instead", value) 14876 } 14877 sv.Error = ptr.String(jtv) 14878 } 14879 14880 case "Message": 14881 if value != nil { 14882 jtv, ok := value.(string) 14883 if !ok { 14884 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 14885 } 14886 sv.Message = ptr.String(jtv) 14887 } 14888 14889 default: 14890 _, _ = key, value 14891 14892 } 14893 } 14894 *v = sv 14895 return nil 14896} 14897 14898func awsAwsjson11_deserializeDocumentShareErrors(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.([]interface{}) 14907 if !ok { 14908 return fmt.Errorf("unexpected JSON type %v", value) 14909 } 14910 14911 var cv []types.ShareError 14912 if *v == nil { 14913 cv = []types.ShareError{} 14914 } else { 14915 cv = *v 14916 } 14917 14918 for _, value := range shape { 14919 var col types.ShareError 14920 destAddr := &col 14921 if err := awsAwsjson11_deserializeDocumentShareError(&destAddr, value); err != nil { 14922 return err 14923 } 14924 col = *destAddr 14925 cv = append(cv, col) 14926 14927 } 14928 *v = cv 14929 return nil 14930} 14931 14932func awsAwsjson11_deserializeDocumentStackInstance(v **types.StackInstance, value interface{}) error { 14933 if v == nil { 14934 return fmt.Errorf("unexpected nil of type %T", v) 14935 } 14936 if value == nil { 14937 return nil 14938 } 14939 14940 shape, ok := value.(map[string]interface{}) 14941 if !ok { 14942 return fmt.Errorf("unexpected JSON type %v", value) 14943 } 14944 14945 var sv *types.StackInstance 14946 if *v == nil { 14947 sv = &types.StackInstance{} 14948 } else { 14949 sv = *v 14950 } 14951 14952 for key, value := range shape { 14953 switch key { 14954 case "Account": 14955 if value != nil { 14956 jtv, ok := value.(string) 14957 if !ok { 14958 return fmt.Errorf("expected AccountId to be of type string, got %T instead", value) 14959 } 14960 sv.Account = ptr.String(jtv) 14961 } 14962 14963 case "Region": 14964 if value != nil { 14965 jtv, ok := value.(string) 14966 if !ok { 14967 return fmt.Errorf("expected Region to be of type string, got %T instead", value) 14968 } 14969 sv.Region = ptr.String(jtv) 14970 } 14971 14972 case "StackInstanceStatus": 14973 if value != nil { 14974 jtv, ok := value.(string) 14975 if !ok { 14976 return fmt.Errorf("expected StackInstanceStatus to be of type string, got %T instead", value) 14977 } 14978 sv.StackInstanceStatus = types.StackInstanceStatus(jtv) 14979 } 14980 14981 default: 14982 _, _ = key, value 14983 14984 } 14985 } 14986 *v = sv 14987 return nil 14988} 14989 14990func awsAwsjson11_deserializeDocumentStackInstances(v *[]types.StackInstance, value interface{}) error { 14991 if v == nil { 14992 return fmt.Errorf("unexpected nil of type %T", v) 14993 } 14994 if value == nil { 14995 return nil 14996 } 14997 14998 shape, ok := value.([]interface{}) 14999 if !ok { 15000 return fmt.Errorf("unexpected JSON type %v", value) 15001 } 15002 15003 var cv []types.StackInstance 15004 if *v == nil { 15005 cv = []types.StackInstance{} 15006 } else { 15007 cv = *v 15008 } 15009 15010 for _, value := range shape { 15011 var col types.StackInstance 15012 destAddr := &col 15013 if err := awsAwsjson11_deserializeDocumentStackInstance(&destAddr, value); err != nil { 15014 return err 15015 } 15016 col = *destAddr 15017 cv = append(cv, col) 15018 15019 } 15020 *v = cv 15021 return nil 15022} 15023 15024func awsAwsjson11_deserializeDocumentStackSetAccounts(v *[]string, value interface{}) error { 15025 if v == nil { 15026 return fmt.Errorf("unexpected nil of type %T", v) 15027 } 15028 if value == nil { 15029 return nil 15030 } 15031 15032 shape, ok := value.([]interface{}) 15033 if !ok { 15034 return fmt.Errorf("unexpected JSON type %v", value) 15035 } 15036 15037 var cv []string 15038 if *v == nil { 15039 cv = []string{} 15040 } else { 15041 cv = *v 15042 } 15043 15044 for _, value := range shape { 15045 var col string 15046 if value != nil { 15047 jtv, ok := value.(string) 15048 if !ok { 15049 return fmt.Errorf("expected AccountId to be of type string, got %T instead", value) 15050 } 15051 col = jtv 15052 } 15053 cv = append(cv, col) 15054 15055 } 15056 *v = cv 15057 return nil 15058} 15059 15060func awsAwsjson11_deserializeDocumentStackSetRegions(v *[]string, value interface{}) error { 15061 if v == nil { 15062 return fmt.Errorf("unexpected nil of type %T", v) 15063 } 15064 if value == nil { 15065 return nil 15066 } 15067 15068 shape, ok := value.([]interface{}) 15069 if !ok { 15070 return fmt.Errorf("unexpected JSON type %v", value) 15071 } 15072 15073 var cv []string 15074 if *v == nil { 15075 cv = []string{} 15076 } else { 15077 cv = *v 15078 } 15079 15080 for _, value := range shape { 15081 var col string 15082 if value != nil { 15083 jtv, ok := value.(string) 15084 if !ok { 15085 return fmt.Errorf("expected Region to be of type string, got %T instead", value) 15086 } 15087 col = jtv 15088 } 15089 cv = append(cv, col) 15090 15091 } 15092 *v = cv 15093 return nil 15094} 15095 15096func awsAwsjson11_deserializeDocumentSuccessfulShares(v *[]string, value interface{}) error { 15097 if v == nil { 15098 return fmt.Errorf("unexpected nil of type %T", v) 15099 } 15100 if value == nil { 15101 return nil 15102 } 15103 15104 shape, ok := value.([]interface{}) 15105 if !ok { 15106 return fmt.Errorf("unexpected JSON type %v", value) 15107 } 15108 15109 var cv []string 15110 if *v == nil { 15111 cv = []string{} 15112 } else { 15113 cv = *v 15114 } 15115 15116 for _, value := range shape { 15117 var col string 15118 if value != nil { 15119 jtv, ok := value.(string) 15120 if !ok { 15121 return fmt.Errorf("expected AccountId to be of type string, got %T instead", value) 15122 } 15123 col = jtv 15124 } 15125 cv = append(cv, col) 15126 15127 } 15128 *v = cv 15129 return nil 15130} 15131 15132func awsAwsjson11_deserializeDocumentTag(v **types.Tag, value interface{}) error { 15133 if v == nil { 15134 return fmt.Errorf("unexpected nil of type %T", v) 15135 } 15136 if value == nil { 15137 return nil 15138 } 15139 15140 shape, ok := value.(map[string]interface{}) 15141 if !ok { 15142 return fmt.Errorf("unexpected JSON type %v", value) 15143 } 15144 15145 var sv *types.Tag 15146 if *v == nil { 15147 sv = &types.Tag{} 15148 } else { 15149 sv = *v 15150 } 15151 15152 for key, value := range shape { 15153 switch key { 15154 case "Key": 15155 if value != nil { 15156 jtv, ok := value.(string) 15157 if !ok { 15158 return fmt.Errorf("expected TagKey to be of type string, got %T instead", value) 15159 } 15160 sv.Key = ptr.String(jtv) 15161 } 15162 15163 case "Value": 15164 if value != nil { 15165 jtv, ok := value.(string) 15166 if !ok { 15167 return fmt.Errorf("expected TagValue to be of type string, got %T instead", value) 15168 } 15169 sv.Value = ptr.String(jtv) 15170 } 15171 15172 default: 15173 _, _ = key, value 15174 15175 } 15176 } 15177 *v = sv 15178 return nil 15179} 15180 15181func awsAwsjson11_deserializeDocumentTagOptionDetail(v **types.TagOptionDetail, value interface{}) error { 15182 if v == nil { 15183 return fmt.Errorf("unexpected nil of type %T", v) 15184 } 15185 if value == nil { 15186 return nil 15187 } 15188 15189 shape, ok := value.(map[string]interface{}) 15190 if !ok { 15191 return fmt.Errorf("unexpected JSON type %v", value) 15192 } 15193 15194 var sv *types.TagOptionDetail 15195 if *v == nil { 15196 sv = &types.TagOptionDetail{} 15197 } else { 15198 sv = *v 15199 } 15200 15201 for key, value := range shape { 15202 switch key { 15203 case "Active": 15204 if value != nil { 15205 jtv, ok := value.(bool) 15206 if !ok { 15207 return fmt.Errorf("expected TagOptionActive to be of type *bool, got %T instead", value) 15208 } 15209 sv.Active = ptr.Bool(jtv) 15210 } 15211 15212 case "Id": 15213 if value != nil { 15214 jtv, ok := value.(string) 15215 if !ok { 15216 return fmt.Errorf("expected TagOptionId to be of type string, got %T instead", value) 15217 } 15218 sv.Id = ptr.String(jtv) 15219 } 15220 15221 case "Key": 15222 if value != nil { 15223 jtv, ok := value.(string) 15224 if !ok { 15225 return fmt.Errorf("expected TagOptionKey to be of type string, got %T instead", value) 15226 } 15227 sv.Key = ptr.String(jtv) 15228 } 15229 15230 case "Owner": 15231 if value != nil { 15232 jtv, ok := value.(string) 15233 if !ok { 15234 return fmt.Errorf("expected Owner to be of type string, got %T instead", value) 15235 } 15236 sv.Owner = ptr.String(jtv) 15237 } 15238 15239 case "Value": 15240 if value != nil { 15241 jtv, ok := value.(string) 15242 if !ok { 15243 return fmt.Errorf("expected TagOptionValue to be of type string, got %T instead", value) 15244 } 15245 sv.Value = ptr.String(jtv) 15246 } 15247 15248 default: 15249 _, _ = key, value 15250 15251 } 15252 } 15253 *v = sv 15254 return nil 15255} 15256 15257func awsAwsjson11_deserializeDocumentTagOptionDetails(v *[]types.TagOptionDetail, value interface{}) error { 15258 if v == nil { 15259 return fmt.Errorf("unexpected nil of type %T", v) 15260 } 15261 if value == nil { 15262 return nil 15263 } 15264 15265 shape, ok := value.([]interface{}) 15266 if !ok { 15267 return fmt.Errorf("unexpected JSON type %v", value) 15268 } 15269 15270 var cv []types.TagOptionDetail 15271 if *v == nil { 15272 cv = []types.TagOptionDetail{} 15273 } else { 15274 cv = *v 15275 } 15276 15277 for _, value := range shape { 15278 var col types.TagOptionDetail 15279 destAddr := &col 15280 if err := awsAwsjson11_deserializeDocumentTagOptionDetail(&destAddr, value); err != nil { 15281 return err 15282 } 15283 col = *destAddr 15284 cv = append(cv, col) 15285 15286 } 15287 *v = cv 15288 return nil 15289} 15290 15291func awsAwsjson11_deserializeDocumentTagOptionNotMigratedException(v **types.TagOptionNotMigratedException, value interface{}) error { 15292 if v == nil { 15293 return fmt.Errorf("unexpected nil of type %T", v) 15294 } 15295 if value == nil { 15296 return nil 15297 } 15298 15299 shape, ok := value.(map[string]interface{}) 15300 if !ok { 15301 return fmt.Errorf("unexpected JSON type %v", value) 15302 } 15303 15304 var sv *types.TagOptionNotMigratedException 15305 if *v == nil { 15306 sv = &types.TagOptionNotMigratedException{} 15307 } else { 15308 sv = *v 15309 } 15310 15311 for key, value := range shape { 15312 switch key { 15313 case "Message": 15314 if value != nil { 15315 jtv, ok := value.(string) 15316 if !ok { 15317 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 15318 } 15319 sv.Message = ptr.String(jtv) 15320 } 15321 15322 default: 15323 _, _ = key, value 15324 15325 } 15326 } 15327 *v = sv 15328 return nil 15329} 15330 15331func awsAwsjson11_deserializeDocumentTagOptionSummaries(v *[]types.TagOptionSummary, value interface{}) error { 15332 if v == nil { 15333 return fmt.Errorf("unexpected nil of type %T", v) 15334 } 15335 if value == nil { 15336 return nil 15337 } 15338 15339 shape, ok := value.([]interface{}) 15340 if !ok { 15341 return fmt.Errorf("unexpected JSON type %v", value) 15342 } 15343 15344 var cv []types.TagOptionSummary 15345 if *v == nil { 15346 cv = []types.TagOptionSummary{} 15347 } else { 15348 cv = *v 15349 } 15350 15351 for _, value := range shape { 15352 var col types.TagOptionSummary 15353 destAddr := &col 15354 if err := awsAwsjson11_deserializeDocumentTagOptionSummary(&destAddr, value); err != nil { 15355 return err 15356 } 15357 col = *destAddr 15358 cv = append(cv, col) 15359 15360 } 15361 *v = cv 15362 return nil 15363} 15364 15365func awsAwsjson11_deserializeDocumentTagOptionSummary(v **types.TagOptionSummary, value interface{}) error { 15366 if v == nil { 15367 return fmt.Errorf("unexpected nil of type %T", v) 15368 } 15369 if value == nil { 15370 return nil 15371 } 15372 15373 shape, ok := value.(map[string]interface{}) 15374 if !ok { 15375 return fmt.Errorf("unexpected JSON type %v", value) 15376 } 15377 15378 var sv *types.TagOptionSummary 15379 if *v == nil { 15380 sv = &types.TagOptionSummary{} 15381 } else { 15382 sv = *v 15383 } 15384 15385 for key, value := range shape { 15386 switch key { 15387 case "Key": 15388 if value != nil { 15389 jtv, ok := value.(string) 15390 if !ok { 15391 return fmt.Errorf("expected TagOptionKey to be of type string, got %T instead", value) 15392 } 15393 sv.Key = ptr.String(jtv) 15394 } 15395 15396 case "Values": 15397 if err := awsAwsjson11_deserializeDocumentTagOptionValues(&sv.Values, value); err != nil { 15398 return err 15399 } 15400 15401 default: 15402 _, _ = key, value 15403 15404 } 15405 } 15406 *v = sv 15407 return nil 15408} 15409 15410func awsAwsjson11_deserializeDocumentTagOptionValues(v *[]string, value interface{}) error { 15411 if v == nil { 15412 return fmt.Errorf("unexpected nil of type %T", v) 15413 } 15414 if value == nil { 15415 return nil 15416 } 15417 15418 shape, ok := value.([]interface{}) 15419 if !ok { 15420 return fmt.Errorf("unexpected JSON type %v", value) 15421 } 15422 15423 var cv []string 15424 if *v == nil { 15425 cv = []string{} 15426 } else { 15427 cv = *v 15428 } 15429 15430 for _, value := range shape { 15431 var col string 15432 if value != nil { 15433 jtv, ok := value.(string) 15434 if !ok { 15435 return fmt.Errorf("expected TagOptionValue to be of type string, got %T instead", value) 15436 } 15437 col = jtv 15438 } 15439 cv = append(cv, col) 15440 15441 } 15442 *v = cv 15443 return nil 15444} 15445 15446func awsAwsjson11_deserializeDocumentTags(v *[]types.Tag, value interface{}) error { 15447 if v == nil { 15448 return fmt.Errorf("unexpected nil of type %T", v) 15449 } 15450 if value == nil { 15451 return nil 15452 } 15453 15454 shape, ok := value.([]interface{}) 15455 if !ok { 15456 return fmt.Errorf("unexpected JSON type %v", value) 15457 } 15458 15459 var cv []types.Tag 15460 if *v == nil { 15461 cv = []types.Tag{} 15462 } else { 15463 cv = *v 15464 } 15465 15466 for _, value := range shape { 15467 var col types.Tag 15468 destAddr := &col 15469 if err := awsAwsjson11_deserializeDocumentTag(&destAddr, value); err != nil { 15470 return err 15471 } 15472 col = *destAddr 15473 cv = append(cv, col) 15474 15475 } 15476 *v = cv 15477 return nil 15478} 15479 15480func awsAwsjson11_deserializeDocumentUpdateProvisioningParameter(v **types.UpdateProvisioningParameter, value interface{}) error { 15481 if v == nil { 15482 return fmt.Errorf("unexpected nil of type %T", v) 15483 } 15484 if value == nil { 15485 return nil 15486 } 15487 15488 shape, ok := value.(map[string]interface{}) 15489 if !ok { 15490 return fmt.Errorf("unexpected JSON type %v", value) 15491 } 15492 15493 var sv *types.UpdateProvisioningParameter 15494 if *v == nil { 15495 sv = &types.UpdateProvisioningParameter{} 15496 } else { 15497 sv = *v 15498 } 15499 15500 for key, value := range shape { 15501 switch key { 15502 case "Key": 15503 if value != nil { 15504 jtv, ok := value.(string) 15505 if !ok { 15506 return fmt.Errorf("expected ParameterKey to be of type string, got %T instead", value) 15507 } 15508 sv.Key = ptr.String(jtv) 15509 } 15510 15511 case "UsePreviousValue": 15512 if value != nil { 15513 jtv, ok := value.(bool) 15514 if !ok { 15515 return fmt.Errorf("expected UsePreviousValue to be of type *bool, got %T instead", value) 15516 } 15517 sv.UsePreviousValue = jtv 15518 } 15519 15520 case "Value": 15521 if value != nil { 15522 jtv, ok := value.(string) 15523 if !ok { 15524 return fmt.Errorf("expected ParameterValue to be of type string, got %T instead", value) 15525 } 15526 sv.Value = ptr.String(jtv) 15527 } 15528 15529 default: 15530 _, _ = key, value 15531 15532 } 15533 } 15534 *v = sv 15535 return nil 15536} 15537 15538func awsAwsjson11_deserializeDocumentUpdateProvisioningParameters(v *[]types.UpdateProvisioningParameter, value interface{}) error { 15539 if v == nil { 15540 return fmt.Errorf("unexpected nil of type %T", v) 15541 } 15542 if value == nil { 15543 return nil 15544 } 15545 15546 shape, ok := value.([]interface{}) 15547 if !ok { 15548 return fmt.Errorf("unexpected JSON type %v", value) 15549 } 15550 15551 var cv []types.UpdateProvisioningParameter 15552 if *v == nil { 15553 cv = []types.UpdateProvisioningParameter{} 15554 } else { 15555 cv = *v 15556 } 15557 15558 for _, value := range shape { 15559 var col types.UpdateProvisioningParameter 15560 destAddr := &col 15561 if err := awsAwsjson11_deserializeDocumentUpdateProvisioningParameter(&destAddr, value); err != nil { 15562 return err 15563 } 15564 col = *destAddr 15565 cv = append(cv, col) 15566 15567 } 15568 *v = cv 15569 return nil 15570} 15571 15572func awsAwsjson11_deserializeDocumentUsageInstruction(v **types.UsageInstruction, value interface{}) error { 15573 if v == nil { 15574 return fmt.Errorf("unexpected nil of type %T", v) 15575 } 15576 if value == nil { 15577 return nil 15578 } 15579 15580 shape, ok := value.(map[string]interface{}) 15581 if !ok { 15582 return fmt.Errorf("unexpected JSON type %v", value) 15583 } 15584 15585 var sv *types.UsageInstruction 15586 if *v == nil { 15587 sv = &types.UsageInstruction{} 15588 } else { 15589 sv = *v 15590 } 15591 15592 for key, value := range shape { 15593 switch key { 15594 case "Type": 15595 if value != nil { 15596 jtv, ok := value.(string) 15597 if !ok { 15598 return fmt.Errorf("expected InstructionType to be of type string, got %T instead", value) 15599 } 15600 sv.Type = ptr.String(jtv) 15601 } 15602 15603 case "Value": 15604 if value != nil { 15605 jtv, ok := value.(string) 15606 if !ok { 15607 return fmt.Errorf("expected InstructionValue to be of type string, got %T instead", value) 15608 } 15609 sv.Value = ptr.String(jtv) 15610 } 15611 15612 default: 15613 _, _ = key, value 15614 15615 } 15616 } 15617 *v = sv 15618 return nil 15619} 15620 15621func awsAwsjson11_deserializeDocumentUsageInstructions(v *[]types.UsageInstruction, value interface{}) error { 15622 if v == nil { 15623 return fmt.Errorf("unexpected nil of type %T", v) 15624 } 15625 if value == nil { 15626 return nil 15627 } 15628 15629 shape, ok := value.([]interface{}) 15630 if !ok { 15631 return fmt.Errorf("unexpected JSON type %v", value) 15632 } 15633 15634 var cv []types.UsageInstruction 15635 if *v == nil { 15636 cv = []types.UsageInstruction{} 15637 } else { 15638 cv = *v 15639 } 15640 15641 for _, value := range shape { 15642 var col types.UsageInstruction 15643 destAddr := &col 15644 if err := awsAwsjson11_deserializeDocumentUsageInstruction(&destAddr, value); err != nil { 15645 return err 15646 } 15647 col = *destAddr 15648 cv = append(cv, col) 15649 15650 } 15651 *v = cv 15652 return nil 15653} 15654 15655func awsAwsjson11_deserializeOpDocumentAcceptPortfolioShareOutput(v **AcceptPortfolioShareOutput, value interface{}) error { 15656 if v == nil { 15657 return fmt.Errorf("unexpected nil of type %T", v) 15658 } 15659 if value == nil { 15660 return nil 15661 } 15662 15663 shape, ok := value.(map[string]interface{}) 15664 if !ok { 15665 return fmt.Errorf("unexpected JSON type %v", value) 15666 } 15667 15668 var sv *AcceptPortfolioShareOutput 15669 if *v == nil { 15670 sv = &AcceptPortfolioShareOutput{} 15671 } else { 15672 sv = *v 15673 } 15674 15675 for key, value := range shape { 15676 switch key { 15677 default: 15678 _, _ = key, value 15679 15680 } 15681 } 15682 *v = sv 15683 return nil 15684} 15685 15686func awsAwsjson11_deserializeOpDocumentAssociateBudgetWithResourceOutput(v **AssociateBudgetWithResourceOutput, value interface{}) error { 15687 if v == nil { 15688 return fmt.Errorf("unexpected nil of type %T", v) 15689 } 15690 if value == nil { 15691 return nil 15692 } 15693 15694 shape, ok := value.(map[string]interface{}) 15695 if !ok { 15696 return fmt.Errorf("unexpected JSON type %v", value) 15697 } 15698 15699 var sv *AssociateBudgetWithResourceOutput 15700 if *v == nil { 15701 sv = &AssociateBudgetWithResourceOutput{} 15702 } else { 15703 sv = *v 15704 } 15705 15706 for key, value := range shape { 15707 switch key { 15708 default: 15709 _, _ = key, value 15710 15711 } 15712 } 15713 *v = sv 15714 return nil 15715} 15716 15717func awsAwsjson11_deserializeOpDocumentAssociatePrincipalWithPortfolioOutput(v **AssociatePrincipalWithPortfolioOutput, value interface{}) error { 15718 if v == nil { 15719 return fmt.Errorf("unexpected nil of type %T", v) 15720 } 15721 if value == nil { 15722 return nil 15723 } 15724 15725 shape, ok := value.(map[string]interface{}) 15726 if !ok { 15727 return fmt.Errorf("unexpected JSON type %v", value) 15728 } 15729 15730 var sv *AssociatePrincipalWithPortfolioOutput 15731 if *v == nil { 15732 sv = &AssociatePrincipalWithPortfolioOutput{} 15733 } else { 15734 sv = *v 15735 } 15736 15737 for key, value := range shape { 15738 switch key { 15739 default: 15740 _, _ = key, value 15741 15742 } 15743 } 15744 *v = sv 15745 return nil 15746} 15747 15748func awsAwsjson11_deserializeOpDocumentAssociateProductWithPortfolioOutput(v **AssociateProductWithPortfolioOutput, value interface{}) error { 15749 if v == nil { 15750 return fmt.Errorf("unexpected nil of type %T", v) 15751 } 15752 if value == nil { 15753 return nil 15754 } 15755 15756 shape, ok := value.(map[string]interface{}) 15757 if !ok { 15758 return fmt.Errorf("unexpected JSON type %v", value) 15759 } 15760 15761 var sv *AssociateProductWithPortfolioOutput 15762 if *v == nil { 15763 sv = &AssociateProductWithPortfolioOutput{} 15764 } else { 15765 sv = *v 15766 } 15767 15768 for key, value := range shape { 15769 switch key { 15770 default: 15771 _, _ = key, value 15772 15773 } 15774 } 15775 *v = sv 15776 return nil 15777} 15778 15779func awsAwsjson11_deserializeOpDocumentAssociateServiceActionWithProvisioningArtifactOutput(v **AssociateServiceActionWithProvisioningArtifactOutput, value interface{}) error { 15780 if v == nil { 15781 return fmt.Errorf("unexpected nil of type %T", v) 15782 } 15783 if value == nil { 15784 return nil 15785 } 15786 15787 shape, ok := value.(map[string]interface{}) 15788 if !ok { 15789 return fmt.Errorf("unexpected JSON type %v", value) 15790 } 15791 15792 var sv *AssociateServiceActionWithProvisioningArtifactOutput 15793 if *v == nil { 15794 sv = &AssociateServiceActionWithProvisioningArtifactOutput{} 15795 } else { 15796 sv = *v 15797 } 15798 15799 for key, value := range shape { 15800 switch key { 15801 default: 15802 _, _ = key, value 15803 15804 } 15805 } 15806 *v = sv 15807 return nil 15808} 15809 15810func awsAwsjson11_deserializeOpDocumentAssociateTagOptionWithResourceOutput(v **AssociateTagOptionWithResourceOutput, value interface{}) error { 15811 if v == nil { 15812 return fmt.Errorf("unexpected nil of type %T", v) 15813 } 15814 if value == nil { 15815 return nil 15816 } 15817 15818 shape, ok := value.(map[string]interface{}) 15819 if !ok { 15820 return fmt.Errorf("unexpected JSON type %v", value) 15821 } 15822 15823 var sv *AssociateTagOptionWithResourceOutput 15824 if *v == nil { 15825 sv = &AssociateTagOptionWithResourceOutput{} 15826 } else { 15827 sv = *v 15828 } 15829 15830 for key, value := range shape { 15831 switch key { 15832 default: 15833 _, _ = key, value 15834 15835 } 15836 } 15837 *v = sv 15838 return nil 15839} 15840 15841func awsAwsjson11_deserializeOpDocumentBatchAssociateServiceActionWithProvisioningArtifactOutput(v **BatchAssociateServiceActionWithProvisioningArtifactOutput, value interface{}) error { 15842 if v == nil { 15843 return fmt.Errorf("unexpected nil of type %T", v) 15844 } 15845 if value == nil { 15846 return nil 15847 } 15848 15849 shape, ok := value.(map[string]interface{}) 15850 if !ok { 15851 return fmt.Errorf("unexpected JSON type %v", value) 15852 } 15853 15854 var sv *BatchAssociateServiceActionWithProvisioningArtifactOutput 15855 if *v == nil { 15856 sv = &BatchAssociateServiceActionWithProvisioningArtifactOutput{} 15857 } else { 15858 sv = *v 15859 } 15860 15861 for key, value := range shape { 15862 switch key { 15863 case "FailedServiceActionAssociations": 15864 if err := awsAwsjson11_deserializeDocumentFailedServiceActionAssociations(&sv.FailedServiceActionAssociations, value); err != nil { 15865 return err 15866 } 15867 15868 default: 15869 _, _ = key, value 15870 15871 } 15872 } 15873 *v = sv 15874 return nil 15875} 15876 15877func awsAwsjson11_deserializeOpDocumentBatchDisassociateServiceActionFromProvisioningArtifactOutput(v **BatchDisassociateServiceActionFromProvisioningArtifactOutput, value interface{}) error { 15878 if v == nil { 15879 return fmt.Errorf("unexpected nil of type %T", v) 15880 } 15881 if value == nil { 15882 return nil 15883 } 15884 15885 shape, ok := value.(map[string]interface{}) 15886 if !ok { 15887 return fmt.Errorf("unexpected JSON type %v", value) 15888 } 15889 15890 var sv *BatchDisassociateServiceActionFromProvisioningArtifactOutput 15891 if *v == nil { 15892 sv = &BatchDisassociateServiceActionFromProvisioningArtifactOutput{} 15893 } else { 15894 sv = *v 15895 } 15896 15897 for key, value := range shape { 15898 switch key { 15899 case "FailedServiceActionAssociations": 15900 if err := awsAwsjson11_deserializeDocumentFailedServiceActionAssociations(&sv.FailedServiceActionAssociations, value); err != nil { 15901 return err 15902 } 15903 15904 default: 15905 _, _ = key, value 15906 15907 } 15908 } 15909 *v = sv 15910 return nil 15911} 15912 15913func awsAwsjson11_deserializeOpDocumentCopyProductOutput(v **CopyProductOutput, value interface{}) error { 15914 if v == nil { 15915 return fmt.Errorf("unexpected nil of type %T", v) 15916 } 15917 if value == nil { 15918 return nil 15919 } 15920 15921 shape, ok := value.(map[string]interface{}) 15922 if !ok { 15923 return fmt.Errorf("unexpected JSON type %v", value) 15924 } 15925 15926 var sv *CopyProductOutput 15927 if *v == nil { 15928 sv = &CopyProductOutput{} 15929 } else { 15930 sv = *v 15931 } 15932 15933 for key, value := range shape { 15934 switch key { 15935 case "CopyProductToken": 15936 if value != nil { 15937 jtv, ok := value.(string) 15938 if !ok { 15939 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 15940 } 15941 sv.CopyProductToken = ptr.String(jtv) 15942 } 15943 15944 default: 15945 _, _ = key, value 15946 15947 } 15948 } 15949 *v = sv 15950 return nil 15951} 15952 15953func awsAwsjson11_deserializeOpDocumentCreateConstraintOutput(v **CreateConstraintOutput, value interface{}) error { 15954 if v == nil { 15955 return fmt.Errorf("unexpected nil of type %T", v) 15956 } 15957 if value == nil { 15958 return nil 15959 } 15960 15961 shape, ok := value.(map[string]interface{}) 15962 if !ok { 15963 return fmt.Errorf("unexpected JSON type %v", value) 15964 } 15965 15966 var sv *CreateConstraintOutput 15967 if *v == nil { 15968 sv = &CreateConstraintOutput{} 15969 } else { 15970 sv = *v 15971 } 15972 15973 for key, value := range shape { 15974 switch key { 15975 case "ConstraintDetail": 15976 if err := awsAwsjson11_deserializeDocumentConstraintDetail(&sv.ConstraintDetail, value); err != nil { 15977 return err 15978 } 15979 15980 case "ConstraintParameters": 15981 if value != nil { 15982 jtv, ok := value.(string) 15983 if !ok { 15984 return fmt.Errorf("expected ConstraintParameters to be of type string, got %T instead", value) 15985 } 15986 sv.ConstraintParameters = ptr.String(jtv) 15987 } 15988 15989 case "Status": 15990 if value != nil { 15991 jtv, ok := value.(string) 15992 if !ok { 15993 return fmt.Errorf("expected Status to be of type string, got %T instead", value) 15994 } 15995 sv.Status = types.Status(jtv) 15996 } 15997 15998 default: 15999 _, _ = key, value 16000 16001 } 16002 } 16003 *v = sv 16004 return nil 16005} 16006 16007func awsAwsjson11_deserializeOpDocumentCreatePortfolioOutput(v **CreatePortfolioOutput, 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 *CreatePortfolioOutput 16021 if *v == nil { 16022 sv = &CreatePortfolioOutput{} 16023 } else { 16024 sv = *v 16025 } 16026 16027 for key, value := range shape { 16028 switch key { 16029 case "PortfolioDetail": 16030 if err := awsAwsjson11_deserializeDocumentPortfolioDetail(&sv.PortfolioDetail, value); err != nil { 16031 return err 16032 } 16033 16034 case "Tags": 16035 if err := awsAwsjson11_deserializeDocumentTags(&sv.Tags, value); err != nil { 16036 return err 16037 } 16038 16039 default: 16040 _, _ = key, value 16041 16042 } 16043 } 16044 *v = sv 16045 return nil 16046} 16047 16048func awsAwsjson11_deserializeOpDocumentCreatePortfolioShareOutput(v **CreatePortfolioShareOutput, value interface{}) error { 16049 if v == nil { 16050 return fmt.Errorf("unexpected nil of type %T", v) 16051 } 16052 if value == nil { 16053 return nil 16054 } 16055 16056 shape, ok := value.(map[string]interface{}) 16057 if !ok { 16058 return fmt.Errorf("unexpected JSON type %v", value) 16059 } 16060 16061 var sv *CreatePortfolioShareOutput 16062 if *v == nil { 16063 sv = &CreatePortfolioShareOutput{} 16064 } else { 16065 sv = *v 16066 } 16067 16068 for key, value := range shape { 16069 switch key { 16070 case "PortfolioShareToken": 16071 if value != nil { 16072 jtv, ok := value.(string) 16073 if !ok { 16074 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 16075 } 16076 sv.PortfolioShareToken = ptr.String(jtv) 16077 } 16078 16079 default: 16080 _, _ = key, value 16081 16082 } 16083 } 16084 *v = sv 16085 return nil 16086} 16087 16088func awsAwsjson11_deserializeOpDocumentCreateProductOutput(v **CreateProductOutput, value interface{}) error { 16089 if v == nil { 16090 return fmt.Errorf("unexpected nil of type %T", v) 16091 } 16092 if value == nil { 16093 return nil 16094 } 16095 16096 shape, ok := value.(map[string]interface{}) 16097 if !ok { 16098 return fmt.Errorf("unexpected JSON type %v", value) 16099 } 16100 16101 var sv *CreateProductOutput 16102 if *v == nil { 16103 sv = &CreateProductOutput{} 16104 } else { 16105 sv = *v 16106 } 16107 16108 for key, value := range shape { 16109 switch key { 16110 case "ProductViewDetail": 16111 if err := awsAwsjson11_deserializeDocumentProductViewDetail(&sv.ProductViewDetail, value); err != nil { 16112 return err 16113 } 16114 16115 case "ProvisioningArtifactDetail": 16116 if err := awsAwsjson11_deserializeDocumentProvisioningArtifactDetail(&sv.ProvisioningArtifactDetail, value); err != nil { 16117 return err 16118 } 16119 16120 case "Tags": 16121 if err := awsAwsjson11_deserializeDocumentTags(&sv.Tags, value); err != nil { 16122 return err 16123 } 16124 16125 default: 16126 _, _ = key, value 16127 16128 } 16129 } 16130 *v = sv 16131 return nil 16132} 16133 16134func awsAwsjson11_deserializeOpDocumentCreateProvisionedProductPlanOutput(v **CreateProvisionedProductPlanOutput, value interface{}) error { 16135 if v == nil { 16136 return fmt.Errorf("unexpected nil of type %T", v) 16137 } 16138 if value == nil { 16139 return nil 16140 } 16141 16142 shape, ok := value.(map[string]interface{}) 16143 if !ok { 16144 return fmt.Errorf("unexpected JSON type %v", value) 16145 } 16146 16147 var sv *CreateProvisionedProductPlanOutput 16148 if *v == nil { 16149 sv = &CreateProvisionedProductPlanOutput{} 16150 } else { 16151 sv = *v 16152 } 16153 16154 for key, value := range shape { 16155 switch key { 16156 case "PlanId": 16157 if value != nil { 16158 jtv, ok := value.(string) 16159 if !ok { 16160 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 16161 } 16162 sv.PlanId = ptr.String(jtv) 16163 } 16164 16165 case "PlanName": 16166 if value != nil { 16167 jtv, ok := value.(string) 16168 if !ok { 16169 return fmt.Errorf("expected ProvisionedProductPlanName to be of type string, got %T instead", value) 16170 } 16171 sv.PlanName = ptr.String(jtv) 16172 } 16173 16174 case "ProvisionedProductName": 16175 if value != nil { 16176 jtv, ok := value.(string) 16177 if !ok { 16178 return fmt.Errorf("expected ProvisionedProductName to be of type string, got %T instead", value) 16179 } 16180 sv.ProvisionedProductName = ptr.String(jtv) 16181 } 16182 16183 case "ProvisioningArtifactId": 16184 if value != nil { 16185 jtv, ok := value.(string) 16186 if !ok { 16187 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 16188 } 16189 sv.ProvisioningArtifactId = ptr.String(jtv) 16190 } 16191 16192 case "ProvisionProductId": 16193 if value != nil { 16194 jtv, ok := value.(string) 16195 if !ok { 16196 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 16197 } 16198 sv.ProvisionProductId = ptr.String(jtv) 16199 } 16200 16201 default: 16202 _, _ = key, value 16203 16204 } 16205 } 16206 *v = sv 16207 return nil 16208} 16209 16210func awsAwsjson11_deserializeOpDocumentCreateProvisioningArtifactOutput(v **CreateProvisioningArtifactOutput, value interface{}) error { 16211 if v == nil { 16212 return fmt.Errorf("unexpected nil of type %T", v) 16213 } 16214 if value == nil { 16215 return nil 16216 } 16217 16218 shape, ok := value.(map[string]interface{}) 16219 if !ok { 16220 return fmt.Errorf("unexpected JSON type %v", value) 16221 } 16222 16223 var sv *CreateProvisioningArtifactOutput 16224 if *v == nil { 16225 sv = &CreateProvisioningArtifactOutput{} 16226 } else { 16227 sv = *v 16228 } 16229 16230 for key, value := range shape { 16231 switch key { 16232 case "Info": 16233 if err := awsAwsjson11_deserializeDocumentProvisioningArtifactInfo(&sv.Info, value); err != nil { 16234 return err 16235 } 16236 16237 case "ProvisioningArtifactDetail": 16238 if err := awsAwsjson11_deserializeDocumentProvisioningArtifactDetail(&sv.ProvisioningArtifactDetail, value); err != nil { 16239 return err 16240 } 16241 16242 case "Status": 16243 if value != nil { 16244 jtv, ok := value.(string) 16245 if !ok { 16246 return fmt.Errorf("expected Status to be of type string, got %T instead", value) 16247 } 16248 sv.Status = types.Status(jtv) 16249 } 16250 16251 default: 16252 _, _ = key, value 16253 16254 } 16255 } 16256 *v = sv 16257 return nil 16258} 16259 16260func awsAwsjson11_deserializeOpDocumentCreateServiceActionOutput(v **CreateServiceActionOutput, value interface{}) error { 16261 if v == nil { 16262 return fmt.Errorf("unexpected nil of type %T", v) 16263 } 16264 if value == nil { 16265 return nil 16266 } 16267 16268 shape, ok := value.(map[string]interface{}) 16269 if !ok { 16270 return fmt.Errorf("unexpected JSON type %v", value) 16271 } 16272 16273 var sv *CreateServiceActionOutput 16274 if *v == nil { 16275 sv = &CreateServiceActionOutput{} 16276 } else { 16277 sv = *v 16278 } 16279 16280 for key, value := range shape { 16281 switch key { 16282 case "ServiceActionDetail": 16283 if err := awsAwsjson11_deserializeDocumentServiceActionDetail(&sv.ServiceActionDetail, value); err != nil { 16284 return err 16285 } 16286 16287 default: 16288 _, _ = key, value 16289 16290 } 16291 } 16292 *v = sv 16293 return nil 16294} 16295 16296func awsAwsjson11_deserializeOpDocumentCreateTagOptionOutput(v **CreateTagOptionOutput, value interface{}) error { 16297 if v == nil { 16298 return fmt.Errorf("unexpected nil of type %T", v) 16299 } 16300 if value == nil { 16301 return nil 16302 } 16303 16304 shape, ok := value.(map[string]interface{}) 16305 if !ok { 16306 return fmt.Errorf("unexpected JSON type %v", value) 16307 } 16308 16309 var sv *CreateTagOptionOutput 16310 if *v == nil { 16311 sv = &CreateTagOptionOutput{} 16312 } else { 16313 sv = *v 16314 } 16315 16316 for key, value := range shape { 16317 switch key { 16318 case "TagOptionDetail": 16319 if err := awsAwsjson11_deserializeDocumentTagOptionDetail(&sv.TagOptionDetail, value); err != nil { 16320 return err 16321 } 16322 16323 default: 16324 _, _ = key, value 16325 16326 } 16327 } 16328 *v = sv 16329 return nil 16330} 16331 16332func awsAwsjson11_deserializeOpDocumentDeleteConstraintOutput(v **DeleteConstraintOutput, value interface{}) error { 16333 if v == nil { 16334 return fmt.Errorf("unexpected nil of type %T", v) 16335 } 16336 if value == nil { 16337 return nil 16338 } 16339 16340 shape, ok := value.(map[string]interface{}) 16341 if !ok { 16342 return fmt.Errorf("unexpected JSON type %v", value) 16343 } 16344 16345 var sv *DeleteConstraintOutput 16346 if *v == nil { 16347 sv = &DeleteConstraintOutput{} 16348 } else { 16349 sv = *v 16350 } 16351 16352 for key, value := range shape { 16353 switch key { 16354 default: 16355 _, _ = key, value 16356 16357 } 16358 } 16359 *v = sv 16360 return nil 16361} 16362 16363func awsAwsjson11_deserializeOpDocumentDeletePortfolioOutput(v **DeletePortfolioOutput, value interface{}) error { 16364 if v == nil { 16365 return fmt.Errorf("unexpected nil of type %T", v) 16366 } 16367 if value == nil { 16368 return nil 16369 } 16370 16371 shape, ok := value.(map[string]interface{}) 16372 if !ok { 16373 return fmt.Errorf("unexpected JSON type %v", value) 16374 } 16375 16376 var sv *DeletePortfolioOutput 16377 if *v == nil { 16378 sv = &DeletePortfolioOutput{} 16379 } else { 16380 sv = *v 16381 } 16382 16383 for key, value := range shape { 16384 switch key { 16385 default: 16386 _, _ = key, value 16387 16388 } 16389 } 16390 *v = sv 16391 return nil 16392} 16393 16394func awsAwsjson11_deserializeOpDocumentDeletePortfolioShareOutput(v **DeletePortfolioShareOutput, value interface{}) error { 16395 if v == nil { 16396 return fmt.Errorf("unexpected nil of type %T", v) 16397 } 16398 if value == nil { 16399 return nil 16400 } 16401 16402 shape, ok := value.(map[string]interface{}) 16403 if !ok { 16404 return fmt.Errorf("unexpected JSON type %v", value) 16405 } 16406 16407 var sv *DeletePortfolioShareOutput 16408 if *v == nil { 16409 sv = &DeletePortfolioShareOutput{} 16410 } else { 16411 sv = *v 16412 } 16413 16414 for key, value := range shape { 16415 switch key { 16416 case "PortfolioShareToken": 16417 if value != nil { 16418 jtv, ok := value.(string) 16419 if !ok { 16420 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 16421 } 16422 sv.PortfolioShareToken = ptr.String(jtv) 16423 } 16424 16425 default: 16426 _, _ = key, value 16427 16428 } 16429 } 16430 *v = sv 16431 return nil 16432} 16433 16434func awsAwsjson11_deserializeOpDocumentDeleteProductOutput(v **DeleteProductOutput, value interface{}) error { 16435 if v == nil { 16436 return fmt.Errorf("unexpected nil of type %T", v) 16437 } 16438 if value == nil { 16439 return nil 16440 } 16441 16442 shape, ok := value.(map[string]interface{}) 16443 if !ok { 16444 return fmt.Errorf("unexpected JSON type %v", value) 16445 } 16446 16447 var sv *DeleteProductOutput 16448 if *v == nil { 16449 sv = &DeleteProductOutput{} 16450 } else { 16451 sv = *v 16452 } 16453 16454 for key, value := range shape { 16455 switch key { 16456 default: 16457 _, _ = key, value 16458 16459 } 16460 } 16461 *v = sv 16462 return nil 16463} 16464 16465func awsAwsjson11_deserializeOpDocumentDeleteProvisionedProductPlanOutput(v **DeleteProvisionedProductPlanOutput, value interface{}) error { 16466 if v == nil { 16467 return fmt.Errorf("unexpected nil of type %T", v) 16468 } 16469 if value == nil { 16470 return nil 16471 } 16472 16473 shape, ok := value.(map[string]interface{}) 16474 if !ok { 16475 return fmt.Errorf("unexpected JSON type %v", value) 16476 } 16477 16478 var sv *DeleteProvisionedProductPlanOutput 16479 if *v == nil { 16480 sv = &DeleteProvisionedProductPlanOutput{} 16481 } else { 16482 sv = *v 16483 } 16484 16485 for key, value := range shape { 16486 switch key { 16487 default: 16488 _, _ = key, value 16489 16490 } 16491 } 16492 *v = sv 16493 return nil 16494} 16495 16496func awsAwsjson11_deserializeOpDocumentDeleteProvisioningArtifactOutput(v **DeleteProvisioningArtifactOutput, value interface{}) error { 16497 if v == nil { 16498 return fmt.Errorf("unexpected nil of type %T", v) 16499 } 16500 if value == nil { 16501 return nil 16502 } 16503 16504 shape, ok := value.(map[string]interface{}) 16505 if !ok { 16506 return fmt.Errorf("unexpected JSON type %v", value) 16507 } 16508 16509 var sv *DeleteProvisioningArtifactOutput 16510 if *v == nil { 16511 sv = &DeleteProvisioningArtifactOutput{} 16512 } else { 16513 sv = *v 16514 } 16515 16516 for key, value := range shape { 16517 switch key { 16518 default: 16519 _, _ = key, value 16520 16521 } 16522 } 16523 *v = sv 16524 return nil 16525} 16526 16527func awsAwsjson11_deserializeOpDocumentDeleteServiceActionOutput(v **DeleteServiceActionOutput, value interface{}) error { 16528 if v == nil { 16529 return fmt.Errorf("unexpected nil of type %T", v) 16530 } 16531 if value == nil { 16532 return nil 16533 } 16534 16535 shape, ok := value.(map[string]interface{}) 16536 if !ok { 16537 return fmt.Errorf("unexpected JSON type %v", value) 16538 } 16539 16540 var sv *DeleteServiceActionOutput 16541 if *v == nil { 16542 sv = &DeleteServiceActionOutput{} 16543 } else { 16544 sv = *v 16545 } 16546 16547 for key, value := range shape { 16548 switch key { 16549 default: 16550 _, _ = key, value 16551 16552 } 16553 } 16554 *v = sv 16555 return nil 16556} 16557 16558func awsAwsjson11_deserializeOpDocumentDeleteTagOptionOutput(v **DeleteTagOptionOutput, value interface{}) error { 16559 if v == nil { 16560 return fmt.Errorf("unexpected nil of type %T", v) 16561 } 16562 if value == nil { 16563 return nil 16564 } 16565 16566 shape, ok := value.(map[string]interface{}) 16567 if !ok { 16568 return fmt.Errorf("unexpected JSON type %v", value) 16569 } 16570 16571 var sv *DeleteTagOptionOutput 16572 if *v == nil { 16573 sv = &DeleteTagOptionOutput{} 16574 } else { 16575 sv = *v 16576 } 16577 16578 for key, value := range shape { 16579 switch key { 16580 default: 16581 _, _ = key, value 16582 16583 } 16584 } 16585 *v = sv 16586 return nil 16587} 16588 16589func awsAwsjson11_deserializeOpDocumentDescribeConstraintOutput(v **DescribeConstraintOutput, value interface{}) error { 16590 if v == nil { 16591 return fmt.Errorf("unexpected nil of type %T", v) 16592 } 16593 if value == nil { 16594 return nil 16595 } 16596 16597 shape, ok := value.(map[string]interface{}) 16598 if !ok { 16599 return fmt.Errorf("unexpected JSON type %v", value) 16600 } 16601 16602 var sv *DescribeConstraintOutput 16603 if *v == nil { 16604 sv = &DescribeConstraintOutput{} 16605 } else { 16606 sv = *v 16607 } 16608 16609 for key, value := range shape { 16610 switch key { 16611 case "ConstraintDetail": 16612 if err := awsAwsjson11_deserializeDocumentConstraintDetail(&sv.ConstraintDetail, value); err != nil { 16613 return err 16614 } 16615 16616 case "ConstraintParameters": 16617 if value != nil { 16618 jtv, ok := value.(string) 16619 if !ok { 16620 return fmt.Errorf("expected ConstraintParameters to be of type string, got %T instead", value) 16621 } 16622 sv.ConstraintParameters = ptr.String(jtv) 16623 } 16624 16625 case "Status": 16626 if value != nil { 16627 jtv, ok := value.(string) 16628 if !ok { 16629 return fmt.Errorf("expected Status to be of type string, got %T instead", value) 16630 } 16631 sv.Status = types.Status(jtv) 16632 } 16633 16634 default: 16635 _, _ = key, value 16636 16637 } 16638 } 16639 *v = sv 16640 return nil 16641} 16642 16643func awsAwsjson11_deserializeOpDocumentDescribeCopyProductStatusOutput(v **DescribeCopyProductStatusOutput, 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 *DescribeCopyProductStatusOutput 16657 if *v == nil { 16658 sv = &DescribeCopyProductStatusOutput{} 16659 } else { 16660 sv = *v 16661 } 16662 16663 for key, value := range shape { 16664 switch key { 16665 case "CopyProductStatus": 16666 if value != nil { 16667 jtv, ok := value.(string) 16668 if !ok { 16669 return fmt.Errorf("expected CopyProductStatus to be of type string, got %T instead", value) 16670 } 16671 sv.CopyProductStatus = types.CopyProductStatus(jtv) 16672 } 16673 16674 case "StatusDetail": 16675 if value != nil { 16676 jtv, ok := value.(string) 16677 if !ok { 16678 return fmt.Errorf("expected StatusDetail to be of type string, got %T instead", value) 16679 } 16680 sv.StatusDetail = ptr.String(jtv) 16681 } 16682 16683 case "TargetProductId": 16684 if value != nil { 16685 jtv, ok := value.(string) 16686 if !ok { 16687 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 16688 } 16689 sv.TargetProductId = ptr.String(jtv) 16690 } 16691 16692 default: 16693 _, _ = key, value 16694 16695 } 16696 } 16697 *v = sv 16698 return nil 16699} 16700 16701func awsAwsjson11_deserializeOpDocumentDescribePortfolioOutput(v **DescribePortfolioOutput, value interface{}) error { 16702 if v == nil { 16703 return fmt.Errorf("unexpected nil of type %T", v) 16704 } 16705 if value == nil { 16706 return nil 16707 } 16708 16709 shape, ok := value.(map[string]interface{}) 16710 if !ok { 16711 return fmt.Errorf("unexpected JSON type %v", value) 16712 } 16713 16714 var sv *DescribePortfolioOutput 16715 if *v == nil { 16716 sv = &DescribePortfolioOutput{} 16717 } else { 16718 sv = *v 16719 } 16720 16721 for key, value := range shape { 16722 switch key { 16723 case "Budgets": 16724 if err := awsAwsjson11_deserializeDocumentBudgets(&sv.Budgets, value); err != nil { 16725 return err 16726 } 16727 16728 case "PortfolioDetail": 16729 if err := awsAwsjson11_deserializeDocumentPortfolioDetail(&sv.PortfolioDetail, value); err != nil { 16730 return err 16731 } 16732 16733 case "TagOptions": 16734 if err := awsAwsjson11_deserializeDocumentTagOptionDetails(&sv.TagOptions, value); err != nil { 16735 return err 16736 } 16737 16738 case "Tags": 16739 if err := awsAwsjson11_deserializeDocumentTags(&sv.Tags, value); err != nil { 16740 return err 16741 } 16742 16743 default: 16744 _, _ = key, value 16745 16746 } 16747 } 16748 *v = sv 16749 return nil 16750} 16751 16752func awsAwsjson11_deserializeOpDocumentDescribePortfolioSharesOutput(v **DescribePortfolioSharesOutput, value interface{}) error { 16753 if v == nil { 16754 return fmt.Errorf("unexpected nil of type %T", v) 16755 } 16756 if value == nil { 16757 return nil 16758 } 16759 16760 shape, ok := value.(map[string]interface{}) 16761 if !ok { 16762 return fmt.Errorf("unexpected JSON type %v", value) 16763 } 16764 16765 var sv *DescribePortfolioSharesOutput 16766 if *v == nil { 16767 sv = &DescribePortfolioSharesOutput{} 16768 } else { 16769 sv = *v 16770 } 16771 16772 for key, value := range shape { 16773 switch key { 16774 case "NextPageToken": 16775 if value != nil { 16776 jtv, ok := value.(string) 16777 if !ok { 16778 return fmt.Errorf("expected PageToken to be of type string, got %T instead", value) 16779 } 16780 sv.NextPageToken = ptr.String(jtv) 16781 } 16782 16783 case "PortfolioShareDetails": 16784 if err := awsAwsjson11_deserializeDocumentPortfolioShareDetails(&sv.PortfolioShareDetails, value); err != nil { 16785 return err 16786 } 16787 16788 default: 16789 _, _ = key, value 16790 16791 } 16792 } 16793 *v = sv 16794 return nil 16795} 16796 16797func awsAwsjson11_deserializeOpDocumentDescribePortfolioShareStatusOutput(v **DescribePortfolioShareStatusOutput, value interface{}) error { 16798 if v == nil { 16799 return fmt.Errorf("unexpected nil of type %T", v) 16800 } 16801 if value == nil { 16802 return nil 16803 } 16804 16805 shape, ok := value.(map[string]interface{}) 16806 if !ok { 16807 return fmt.Errorf("unexpected JSON type %v", value) 16808 } 16809 16810 var sv *DescribePortfolioShareStatusOutput 16811 if *v == nil { 16812 sv = &DescribePortfolioShareStatusOutput{} 16813 } else { 16814 sv = *v 16815 } 16816 16817 for key, value := range shape { 16818 switch key { 16819 case "OrganizationNodeValue": 16820 if value != nil { 16821 jtv, ok := value.(string) 16822 if !ok { 16823 return fmt.Errorf("expected OrganizationNodeValue to be of type string, got %T instead", value) 16824 } 16825 sv.OrganizationNodeValue = ptr.String(jtv) 16826 } 16827 16828 case "PortfolioId": 16829 if value != nil { 16830 jtv, ok := value.(string) 16831 if !ok { 16832 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 16833 } 16834 sv.PortfolioId = ptr.String(jtv) 16835 } 16836 16837 case "PortfolioShareToken": 16838 if value != nil { 16839 jtv, ok := value.(string) 16840 if !ok { 16841 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 16842 } 16843 sv.PortfolioShareToken = ptr.String(jtv) 16844 } 16845 16846 case "ShareDetails": 16847 if err := awsAwsjson11_deserializeDocumentShareDetails(&sv.ShareDetails, value); err != nil { 16848 return err 16849 } 16850 16851 case "Status": 16852 if value != nil { 16853 jtv, ok := value.(string) 16854 if !ok { 16855 return fmt.Errorf("expected ShareStatus to be of type string, got %T instead", value) 16856 } 16857 sv.Status = types.ShareStatus(jtv) 16858 } 16859 16860 default: 16861 _, _ = key, value 16862 16863 } 16864 } 16865 *v = sv 16866 return nil 16867} 16868 16869func awsAwsjson11_deserializeOpDocumentDescribeProductAsAdminOutput(v **DescribeProductAsAdminOutput, value interface{}) error { 16870 if v == nil { 16871 return fmt.Errorf("unexpected nil of type %T", v) 16872 } 16873 if value == nil { 16874 return nil 16875 } 16876 16877 shape, ok := value.(map[string]interface{}) 16878 if !ok { 16879 return fmt.Errorf("unexpected JSON type %v", value) 16880 } 16881 16882 var sv *DescribeProductAsAdminOutput 16883 if *v == nil { 16884 sv = &DescribeProductAsAdminOutput{} 16885 } else { 16886 sv = *v 16887 } 16888 16889 for key, value := range shape { 16890 switch key { 16891 case "Budgets": 16892 if err := awsAwsjson11_deserializeDocumentBudgets(&sv.Budgets, value); err != nil { 16893 return err 16894 } 16895 16896 case "ProductViewDetail": 16897 if err := awsAwsjson11_deserializeDocumentProductViewDetail(&sv.ProductViewDetail, value); err != nil { 16898 return err 16899 } 16900 16901 case "ProvisioningArtifactSummaries": 16902 if err := awsAwsjson11_deserializeDocumentProvisioningArtifactSummaries(&sv.ProvisioningArtifactSummaries, value); err != nil { 16903 return err 16904 } 16905 16906 case "TagOptions": 16907 if err := awsAwsjson11_deserializeDocumentTagOptionDetails(&sv.TagOptions, value); err != nil { 16908 return err 16909 } 16910 16911 case "Tags": 16912 if err := awsAwsjson11_deserializeDocumentTags(&sv.Tags, value); err != nil { 16913 return err 16914 } 16915 16916 default: 16917 _, _ = key, value 16918 16919 } 16920 } 16921 *v = sv 16922 return nil 16923} 16924 16925func awsAwsjson11_deserializeOpDocumentDescribeProductOutput(v **DescribeProductOutput, value interface{}) error { 16926 if v == nil { 16927 return fmt.Errorf("unexpected nil of type %T", v) 16928 } 16929 if value == nil { 16930 return nil 16931 } 16932 16933 shape, ok := value.(map[string]interface{}) 16934 if !ok { 16935 return fmt.Errorf("unexpected JSON type %v", value) 16936 } 16937 16938 var sv *DescribeProductOutput 16939 if *v == nil { 16940 sv = &DescribeProductOutput{} 16941 } else { 16942 sv = *v 16943 } 16944 16945 for key, value := range shape { 16946 switch key { 16947 case "Budgets": 16948 if err := awsAwsjson11_deserializeDocumentBudgets(&sv.Budgets, value); err != nil { 16949 return err 16950 } 16951 16952 case "LaunchPaths": 16953 if err := awsAwsjson11_deserializeDocumentLaunchPaths(&sv.LaunchPaths, value); err != nil { 16954 return err 16955 } 16956 16957 case "ProductViewSummary": 16958 if err := awsAwsjson11_deserializeDocumentProductViewSummary(&sv.ProductViewSummary, value); err != nil { 16959 return err 16960 } 16961 16962 case "ProvisioningArtifacts": 16963 if err := awsAwsjson11_deserializeDocumentProvisioningArtifacts(&sv.ProvisioningArtifacts, value); err != nil { 16964 return err 16965 } 16966 16967 default: 16968 _, _ = key, value 16969 16970 } 16971 } 16972 *v = sv 16973 return nil 16974} 16975 16976func awsAwsjson11_deserializeOpDocumentDescribeProductViewOutput(v **DescribeProductViewOutput, value interface{}) error { 16977 if v == nil { 16978 return fmt.Errorf("unexpected nil of type %T", v) 16979 } 16980 if value == nil { 16981 return nil 16982 } 16983 16984 shape, ok := value.(map[string]interface{}) 16985 if !ok { 16986 return fmt.Errorf("unexpected JSON type %v", value) 16987 } 16988 16989 var sv *DescribeProductViewOutput 16990 if *v == nil { 16991 sv = &DescribeProductViewOutput{} 16992 } else { 16993 sv = *v 16994 } 16995 16996 for key, value := range shape { 16997 switch key { 16998 case "ProductViewSummary": 16999 if err := awsAwsjson11_deserializeDocumentProductViewSummary(&sv.ProductViewSummary, value); err != nil { 17000 return err 17001 } 17002 17003 case "ProvisioningArtifacts": 17004 if err := awsAwsjson11_deserializeDocumentProvisioningArtifacts(&sv.ProvisioningArtifacts, value); err != nil { 17005 return err 17006 } 17007 17008 default: 17009 _, _ = key, value 17010 17011 } 17012 } 17013 *v = sv 17014 return nil 17015} 17016 17017func awsAwsjson11_deserializeOpDocumentDescribeProvisionedProductOutput(v **DescribeProvisionedProductOutput, value interface{}) error { 17018 if v == nil { 17019 return fmt.Errorf("unexpected nil of type %T", v) 17020 } 17021 if value == nil { 17022 return nil 17023 } 17024 17025 shape, ok := value.(map[string]interface{}) 17026 if !ok { 17027 return fmt.Errorf("unexpected JSON type %v", value) 17028 } 17029 17030 var sv *DescribeProvisionedProductOutput 17031 if *v == nil { 17032 sv = &DescribeProvisionedProductOutput{} 17033 } else { 17034 sv = *v 17035 } 17036 17037 for key, value := range shape { 17038 switch key { 17039 case "CloudWatchDashboards": 17040 if err := awsAwsjson11_deserializeDocumentCloudWatchDashboards(&sv.CloudWatchDashboards, value); err != nil { 17041 return err 17042 } 17043 17044 case "ProvisionedProductDetail": 17045 if err := awsAwsjson11_deserializeDocumentProvisionedProductDetail(&sv.ProvisionedProductDetail, value); err != nil { 17046 return err 17047 } 17048 17049 default: 17050 _, _ = key, value 17051 17052 } 17053 } 17054 *v = sv 17055 return nil 17056} 17057 17058func awsAwsjson11_deserializeOpDocumentDescribeProvisionedProductPlanOutput(v **DescribeProvisionedProductPlanOutput, value interface{}) error { 17059 if v == nil { 17060 return fmt.Errorf("unexpected nil of type %T", v) 17061 } 17062 if value == nil { 17063 return nil 17064 } 17065 17066 shape, ok := value.(map[string]interface{}) 17067 if !ok { 17068 return fmt.Errorf("unexpected JSON type %v", value) 17069 } 17070 17071 var sv *DescribeProvisionedProductPlanOutput 17072 if *v == nil { 17073 sv = &DescribeProvisionedProductPlanOutput{} 17074 } else { 17075 sv = *v 17076 } 17077 17078 for key, value := range shape { 17079 switch key { 17080 case "NextPageToken": 17081 if value != nil { 17082 jtv, ok := value.(string) 17083 if !ok { 17084 return fmt.Errorf("expected PageToken to be of type string, got %T instead", value) 17085 } 17086 sv.NextPageToken = ptr.String(jtv) 17087 } 17088 17089 case "ProvisionedProductPlanDetails": 17090 if err := awsAwsjson11_deserializeDocumentProvisionedProductPlanDetails(&sv.ProvisionedProductPlanDetails, value); err != nil { 17091 return err 17092 } 17093 17094 case "ResourceChanges": 17095 if err := awsAwsjson11_deserializeDocumentResourceChanges(&sv.ResourceChanges, value); err != nil { 17096 return err 17097 } 17098 17099 default: 17100 _, _ = key, value 17101 17102 } 17103 } 17104 *v = sv 17105 return nil 17106} 17107 17108func awsAwsjson11_deserializeOpDocumentDescribeProvisioningArtifactOutput(v **DescribeProvisioningArtifactOutput, value interface{}) error { 17109 if v == nil { 17110 return fmt.Errorf("unexpected nil of type %T", v) 17111 } 17112 if value == nil { 17113 return nil 17114 } 17115 17116 shape, ok := value.(map[string]interface{}) 17117 if !ok { 17118 return fmt.Errorf("unexpected JSON type %v", value) 17119 } 17120 17121 var sv *DescribeProvisioningArtifactOutput 17122 if *v == nil { 17123 sv = &DescribeProvisioningArtifactOutput{} 17124 } else { 17125 sv = *v 17126 } 17127 17128 for key, value := range shape { 17129 switch key { 17130 case "Info": 17131 if err := awsAwsjson11_deserializeDocumentProvisioningArtifactInfo(&sv.Info, value); err != nil { 17132 return err 17133 } 17134 17135 case "ProvisioningArtifactDetail": 17136 if err := awsAwsjson11_deserializeDocumentProvisioningArtifactDetail(&sv.ProvisioningArtifactDetail, value); err != nil { 17137 return err 17138 } 17139 17140 case "Status": 17141 if value != nil { 17142 jtv, ok := value.(string) 17143 if !ok { 17144 return fmt.Errorf("expected Status to be of type string, got %T instead", value) 17145 } 17146 sv.Status = types.Status(jtv) 17147 } 17148 17149 default: 17150 _, _ = key, value 17151 17152 } 17153 } 17154 *v = sv 17155 return nil 17156} 17157 17158func awsAwsjson11_deserializeOpDocumentDescribeProvisioningParametersOutput(v **DescribeProvisioningParametersOutput, value interface{}) error { 17159 if v == nil { 17160 return fmt.Errorf("unexpected nil of type %T", v) 17161 } 17162 if value == nil { 17163 return nil 17164 } 17165 17166 shape, ok := value.(map[string]interface{}) 17167 if !ok { 17168 return fmt.Errorf("unexpected JSON type %v", value) 17169 } 17170 17171 var sv *DescribeProvisioningParametersOutput 17172 if *v == nil { 17173 sv = &DescribeProvisioningParametersOutput{} 17174 } else { 17175 sv = *v 17176 } 17177 17178 for key, value := range shape { 17179 switch key { 17180 case "ConstraintSummaries": 17181 if err := awsAwsjson11_deserializeDocumentConstraintSummaries(&sv.ConstraintSummaries, value); err != nil { 17182 return err 17183 } 17184 17185 case "ProvisioningArtifactOutputs": 17186 if err := awsAwsjson11_deserializeDocumentProvisioningArtifactOutputs(&sv.ProvisioningArtifactOutputs, value); err != nil { 17187 return err 17188 } 17189 17190 case "ProvisioningArtifactParameters": 17191 if err := awsAwsjson11_deserializeDocumentProvisioningArtifactParameters(&sv.ProvisioningArtifactParameters, value); err != nil { 17192 return err 17193 } 17194 17195 case "ProvisioningArtifactPreferences": 17196 if err := awsAwsjson11_deserializeDocumentProvisioningArtifactPreferences(&sv.ProvisioningArtifactPreferences, value); err != nil { 17197 return err 17198 } 17199 17200 case "TagOptions": 17201 if err := awsAwsjson11_deserializeDocumentTagOptionSummaries(&sv.TagOptions, value); err != nil { 17202 return err 17203 } 17204 17205 case "UsageInstructions": 17206 if err := awsAwsjson11_deserializeDocumentUsageInstructions(&sv.UsageInstructions, value); err != nil { 17207 return err 17208 } 17209 17210 default: 17211 _, _ = key, value 17212 17213 } 17214 } 17215 *v = sv 17216 return nil 17217} 17218 17219func awsAwsjson11_deserializeOpDocumentDescribeRecordOutput(v **DescribeRecordOutput, value interface{}) error { 17220 if v == nil { 17221 return fmt.Errorf("unexpected nil of type %T", v) 17222 } 17223 if value == nil { 17224 return nil 17225 } 17226 17227 shape, ok := value.(map[string]interface{}) 17228 if !ok { 17229 return fmt.Errorf("unexpected JSON type %v", value) 17230 } 17231 17232 var sv *DescribeRecordOutput 17233 if *v == nil { 17234 sv = &DescribeRecordOutput{} 17235 } else { 17236 sv = *v 17237 } 17238 17239 for key, value := range shape { 17240 switch key { 17241 case "NextPageToken": 17242 if value != nil { 17243 jtv, ok := value.(string) 17244 if !ok { 17245 return fmt.Errorf("expected PageToken to be of type string, got %T instead", value) 17246 } 17247 sv.NextPageToken = ptr.String(jtv) 17248 } 17249 17250 case "RecordDetail": 17251 if err := awsAwsjson11_deserializeDocumentRecordDetail(&sv.RecordDetail, value); err != nil { 17252 return err 17253 } 17254 17255 case "RecordOutputs": 17256 if err := awsAwsjson11_deserializeDocumentRecordOutputs(&sv.RecordOutputs, value); err != nil { 17257 return err 17258 } 17259 17260 default: 17261 _, _ = key, value 17262 17263 } 17264 } 17265 *v = sv 17266 return nil 17267} 17268 17269func awsAwsjson11_deserializeOpDocumentDescribeServiceActionExecutionParametersOutput(v **DescribeServiceActionExecutionParametersOutput, value interface{}) error { 17270 if v == nil { 17271 return fmt.Errorf("unexpected nil of type %T", v) 17272 } 17273 if value == nil { 17274 return nil 17275 } 17276 17277 shape, ok := value.(map[string]interface{}) 17278 if !ok { 17279 return fmt.Errorf("unexpected JSON type %v", value) 17280 } 17281 17282 var sv *DescribeServiceActionExecutionParametersOutput 17283 if *v == nil { 17284 sv = &DescribeServiceActionExecutionParametersOutput{} 17285 } else { 17286 sv = *v 17287 } 17288 17289 for key, value := range shape { 17290 switch key { 17291 case "ServiceActionParameters": 17292 if err := awsAwsjson11_deserializeDocumentExecutionParameters(&sv.ServiceActionParameters, value); err != nil { 17293 return err 17294 } 17295 17296 default: 17297 _, _ = key, value 17298 17299 } 17300 } 17301 *v = sv 17302 return nil 17303} 17304 17305func awsAwsjson11_deserializeOpDocumentDescribeServiceActionOutput(v **DescribeServiceActionOutput, value interface{}) error { 17306 if v == nil { 17307 return fmt.Errorf("unexpected nil of type %T", v) 17308 } 17309 if value == nil { 17310 return nil 17311 } 17312 17313 shape, ok := value.(map[string]interface{}) 17314 if !ok { 17315 return fmt.Errorf("unexpected JSON type %v", value) 17316 } 17317 17318 var sv *DescribeServiceActionOutput 17319 if *v == nil { 17320 sv = &DescribeServiceActionOutput{} 17321 } else { 17322 sv = *v 17323 } 17324 17325 for key, value := range shape { 17326 switch key { 17327 case "ServiceActionDetail": 17328 if err := awsAwsjson11_deserializeDocumentServiceActionDetail(&sv.ServiceActionDetail, value); err != nil { 17329 return err 17330 } 17331 17332 default: 17333 _, _ = key, value 17334 17335 } 17336 } 17337 *v = sv 17338 return nil 17339} 17340 17341func awsAwsjson11_deserializeOpDocumentDescribeTagOptionOutput(v **DescribeTagOptionOutput, value interface{}) error { 17342 if v == nil { 17343 return fmt.Errorf("unexpected nil of type %T", v) 17344 } 17345 if value == nil { 17346 return nil 17347 } 17348 17349 shape, ok := value.(map[string]interface{}) 17350 if !ok { 17351 return fmt.Errorf("unexpected JSON type %v", value) 17352 } 17353 17354 var sv *DescribeTagOptionOutput 17355 if *v == nil { 17356 sv = &DescribeTagOptionOutput{} 17357 } else { 17358 sv = *v 17359 } 17360 17361 for key, value := range shape { 17362 switch key { 17363 case "TagOptionDetail": 17364 if err := awsAwsjson11_deserializeDocumentTagOptionDetail(&sv.TagOptionDetail, value); err != nil { 17365 return err 17366 } 17367 17368 default: 17369 _, _ = key, value 17370 17371 } 17372 } 17373 *v = sv 17374 return nil 17375} 17376 17377func awsAwsjson11_deserializeOpDocumentDisableAWSOrganizationsAccessOutput(v **DisableAWSOrganizationsAccessOutput, value interface{}) error { 17378 if v == nil { 17379 return fmt.Errorf("unexpected nil of type %T", v) 17380 } 17381 if value == nil { 17382 return nil 17383 } 17384 17385 shape, ok := value.(map[string]interface{}) 17386 if !ok { 17387 return fmt.Errorf("unexpected JSON type %v", value) 17388 } 17389 17390 var sv *DisableAWSOrganizationsAccessOutput 17391 if *v == nil { 17392 sv = &DisableAWSOrganizationsAccessOutput{} 17393 } else { 17394 sv = *v 17395 } 17396 17397 for key, value := range shape { 17398 switch key { 17399 default: 17400 _, _ = key, value 17401 17402 } 17403 } 17404 *v = sv 17405 return nil 17406} 17407 17408func awsAwsjson11_deserializeOpDocumentDisassociateBudgetFromResourceOutput(v **DisassociateBudgetFromResourceOutput, value interface{}) error { 17409 if v == nil { 17410 return fmt.Errorf("unexpected nil of type %T", v) 17411 } 17412 if value == nil { 17413 return nil 17414 } 17415 17416 shape, ok := value.(map[string]interface{}) 17417 if !ok { 17418 return fmt.Errorf("unexpected JSON type %v", value) 17419 } 17420 17421 var sv *DisassociateBudgetFromResourceOutput 17422 if *v == nil { 17423 sv = &DisassociateBudgetFromResourceOutput{} 17424 } else { 17425 sv = *v 17426 } 17427 17428 for key, value := range shape { 17429 switch key { 17430 default: 17431 _, _ = key, value 17432 17433 } 17434 } 17435 *v = sv 17436 return nil 17437} 17438 17439func awsAwsjson11_deserializeOpDocumentDisassociatePrincipalFromPortfolioOutput(v **DisassociatePrincipalFromPortfolioOutput, value interface{}) error { 17440 if v == nil { 17441 return fmt.Errorf("unexpected nil of type %T", v) 17442 } 17443 if value == nil { 17444 return nil 17445 } 17446 17447 shape, ok := value.(map[string]interface{}) 17448 if !ok { 17449 return fmt.Errorf("unexpected JSON type %v", value) 17450 } 17451 17452 var sv *DisassociatePrincipalFromPortfolioOutput 17453 if *v == nil { 17454 sv = &DisassociatePrincipalFromPortfolioOutput{} 17455 } else { 17456 sv = *v 17457 } 17458 17459 for key, value := range shape { 17460 switch key { 17461 default: 17462 _, _ = key, value 17463 17464 } 17465 } 17466 *v = sv 17467 return nil 17468} 17469 17470func awsAwsjson11_deserializeOpDocumentDisassociateProductFromPortfolioOutput(v **DisassociateProductFromPortfolioOutput, value interface{}) error { 17471 if v == nil { 17472 return fmt.Errorf("unexpected nil of type %T", v) 17473 } 17474 if value == nil { 17475 return nil 17476 } 17477 17478 shape, ok := value.(map[string]interface{}) 17479 if !ok { 17480 return fmt.Errorf("unexpected JSON type %v", value) 17481 } 17482 17483 var sv *DisassociateProductFromPortfolioOutput 17484 if *v == nil { 17485 sv = &DisassociateProductFromPortfolioOutput{} 17486 } else { 17487 sv = *v 17488 } 17489 17490 for key, value := range shape { 17491 switch key { 17492 default: 17493 _, _ = key, value 17494 17495 } 17496 } 17497 *v = sv 17498 return nil 17499} 17500 17501func awsAwsjson11_deserializeOpDocumentDisassociateServiceActionFromProvisioningArtifactOutput(v **DisassociateServiceActionFromProvisioningArtifactOutput, value interface{}) error { 17502 if v == nil { 17503 return fmt.Errorf("unexpected nil of type %T", v) 17504 } 17505 if value == nil { 17506 return nil 17507 } 17508 17509 shape, ok := value.(map[string]interface{}) 17510 if !ok { 17511 return fmt.Errorf("unexpected JSON type %v", value) 17512 } 17513 17514 var sv *DisassociateServiceActionFromProvisioningArtifactOutput 17515 if *v == nil { 17516 sv = &DisassociateServiceActionFromProvisioningArtifactOutput{} 17517 } else { 17518 sv = *v 17519 } 17520 17521 for key, value := range shape { 17522 switch key { 17523 default: 17524 _, _ = key, value 17525 17526 } 17527 } 17528 *v = sv 17529 return nil 17530} 17531 17532func awsAwsjson11_deserializeOpDocumentDisassociateTagOptionFromResourceOutput(v **DisassociateTagOptionFromResourceOutput, value interface{}) error { 17533 if v == nil { 17534 return fmt.Errorf("unexpected nil of type %T", v) 17535 } 17536 if value == nil { 17537 return nil 17538 } 17539 17540 shape, ok := value.(map[string]interface{}) 17541 if !ok { 17542 return fmt.Errorf("unexpected JSON type %v", value) 17543 } 17544 17545 var sv *DisassociateTagOptionFromResourceOutput 17546 if *v == nil { 17547 sv = &DisassociateTagOptionFromResourceOutput{} 17548 } else { 17549 sv = *v 17550 } 17551 17552 for key, value := range shape { 17553 switch key { 17554 default: 17555 _, _ = key, value 17556 17557 } 17558 } 17559 *v = sv 17560 return nil 17561} 17562 17563func awsAwsjson11_deserializeOpDocumentEnableAWSOrganizationsAccessOutput(v **EnableAWSOrganizationsAccessOutput, value interface{}) error { 17564 if v == nil { 17565 return fmt.Errorf("unexpected nil of type %T", v) 17566 } 17567 if value == nil { 17568 return nil 17569 } 17570 17571 shape, ok := value.(map[string]interface{}) 17572 if !ok { 17573 return fmt.Errorf("unexpected JSON type %v", value) 17574 } 17575 17576 var sv *EnableAWSOrganizationsAccessOutput 17577 if *v == nil { 17578 sv = &EnableAWSOrganizationsAccessOutput{} 17579 } else { 17580 sv = *v 17581 } 17582 17583 for key, value := range shape { 17584 switch key { 17585 default: 17586 _, _ = key, value 17587 17588 } 17589 } 17590 *v = sv 17591 return nil 17592} 17593 17594func awsAwsjson11_deserializeOpDocumentExecuteProvisionedProductPlanOutput(v **ExecuteProvisionedProductPlanOutput, value interface{}) error { 17595 if v == nil { 17596 return fmt.Errorf("unexpected nil of type %T", v) 17597 } 17598 if value == nil { 17599 return nil 17600 } 17601 17602 shape, ok := value.(map[string]interface{}) 17603 if !ok { 17604 return fmt.Errorf("unexpected JSON type %v", value) 17605 } 17606 17607 var sv *ExecuteProvisionedProductPlanOutput 17608 if *v == nil { 17609 sv = &ExecuteProvisionedProductPlanOutput{} 17610 } else { 17611 sv = *v 17612 } 17613 17614 for key, value := range shape { 17615 switch key { 17616 case "RecordDetail": 17617 if err := awsAwsjson11_deserializeDocumentRecordDetail(&sv.RecordDetail, value); err != nil { 17618 return err 17619 } 17620 17621 default: 17622 _, _ = key, value 17623 17624 } 17625 } 17626 *v = sv 17627 return nil 17628} 17629 17630func awsAwsjson11_deserializeOpDocumentExecuteProvisionedProductServiceActionOutput(v **ExecuteProvisionedProductServiceActionOutput, value interface{}) error { 17631 if v == nil { 17632 return fmt.Errorf("unexpected nil of type %T", v) 17633 } 17634 if value == nil { 17635 return nil 17636 } 17637 17638 shape, ok := value.(map[string]interface{}) 17639 if !ok { 17640 return fmt.Errorf("unexpected JSON type %v", value) 17641 } 17642 17643 var sv *ExecuteProvisionedProductServiceActionOutput 17644 if *v == nil { 17645 sv = &ExecuteProvisionedProductServiceActionOutput{} 17646 } else { 17647 sv = *v 17648 } 17649 17650 for key, value := range shape { 17651 switch key { 17652 case "RecordDetail": 17653 if err := awsAwsjson11_deserializeDocumentRecordDetail(&sv.RecordDetail, value); err != nil { 17654 return err 17655 } 17656 17657 default: 17658 _, _ = key, value 17659 17660 } 17661 } 17662 *v = sv 17663 return nil 17664} 17665 17666func awsAwsjson11_deserializeOpDocumentGetAWSOrganizationsAccessStatusOutput(v **GetAWSOrganizationsAccessStatusOutput, value interface{}) error { 17667 if v == nil { 17668 return fmt.Errorf("unexpected nil of type %T", v) 17669 } 17670 if value == nil { 17671 return nil 17672 } 17673 17674 shape, ok := value.(map[string]interface{}) 17675 if !ok { 17676 return fmt.Errorf("unexpected JSON type %v", value) 17677 } 17678 17679 var sv *GetAWSOrganizationsAccessStatusOutput 17680 if *v == nil { 17681 sv = &GetAWSOrganizationsAccessStatusOutput{} 17682 } else { 17683 sv = *v 17684 } 17685 17686 for key, value := range shape { 17687 switch key { 17688 case "AccessStatus": 17689 if value != nil { 17690 jtv, ok := value.(string) 17691 if !ok { 17692 return fmt.Errorf("expected AccessStatus to be of type string, got %T instead", value) 17693 } 17694 sv.AccessStatus = types.AccessStatus(jtv) 17695 } 17696 17697 default: 17698 _, _ = key, value 17699 17700 } 17701 } 17702 *v = sv 17703 return nil 17704} 17705 17706func awsAwsjson11_deserializeOpDocumentGetProvisionedProductOutputsOutput(v **GetProvisionedProductOutputsOutput, value interface{}) error { 17707 if v == nil { 17708 return fmt.Errorf("unexpected nil of type %T", v) 17709 } 17710 if value == nil { 17711 return nil 17712 } 17713 17714 shape, ok := value.(map[string]interface{}) 17715 if !ok { 17716 return fmt.Errorf("unexpected JSON type %v", value) 17717 } 17718 17719 var sv *GetProvisionedProductOutputsOutput 17720 if *v == nil { 17721 sv = &GetProvisionedProductOutputsOutput{} 17722 } else { 17723 sv = *v 17724 } 17725 17726 for key, value := range shape { 17727 switch key { 17728 case "NextPageToken": 17729 if value != nil { 17730 jtv, ok := value.(string) 17731 if !ok { 17732 return fmt.Errorf("expected PageToken to be of type string, got %T instead", value) 17733 } 17734 sv.NextPageToken = ptr.String(jtv) 17735 } 17736 17737 case "Outputs": 17738 if err := awsAwsjson11_deserializeDocumentRecordOutputs(&sv.Outputs, value); err != nil { 17739 return err 17740 } 17741 17742 default: 17743 _, _ = key, value 17744 17745 } 17746 } 17747 *v = sv 17748 return nil 17749} 17750 17751func awsAwsjson11_deserializeOpDocumentImportAsProvisionedProductOutput(v **ImportAsProvisionedProductOutput, value interface{}) error { 17752 if v == nil { 17753 return fmt.Errorf("unexpected nil of type %T", v) 17754 } 17755 if value == nil { 17756 return nil 17757 } 17758 17759 shape, ok := value.(map[string]interface{}) 17760 if !ok { 17761 return fmt.Errorf("unexpected JSON type %v", value) 17762 } 17763 17764 var sv *ImportAsProvisionedProductOutput 17765 if *v == nil { 17766 sv = &ImportAsProvisionedProductOutput{} 17767 } else { 17768 sv = *v 17769 } 17770 17771 for key, value := range shape { 17772 switch key { 17773 case "RecordDetail": 17774 if err := awsAwsjson11_deserializeDocumentRecordDetail(&sv.RecordDetail, value); err != nil { 17775 return err 17776 } 17777 17778 default: 17779 _, _ = key, value 17780 17781 } 17782 } 17783 *v = sv 17784 return nil 17785} 17786 17787func awsAwsjson11_deserializeOpDocumentListAcceptedPortfolioSharesOutput(v **ListAcceptedPortfolioSharesOutput, value interface{}) error { 17788 if v == nil { 17789 return fmt.Errorf("unexpected nil of type %T", v) 17790 } 17791 if value == nil { 17792 return nil 17793 } 17794 17795 shape, ok := value.(map[string]interface{}) 17796 if !ok { 17797 return fmt.Errorf("unexpected JSON type %v", value) 17798 } 17799 17800 var sv *ListAcceptedPortfolioSharesOutput 17801 if *v == nil { 17802 sv = &ListAcceptedPortfolioSharesOutput{} 17803 } else { 17804 sv = *v 17805 } 17806 17807 for key, value := range shape { 17808 switch key { 17809 case "NextPageToken": 17810 if value != nil { 17811 jtv, ok := value.(string) 17812 if !ok { 17813 return fmt.Errorf("expected PageToken to be of type string, got %T instead", value) 17814 } 17815 sv.NextPageToken = ptr.String(jtv) 17816 } 17817 17818 case "PortfolioDetails": 17819 if err := awsAwsjson11_deserializeDocumentPortfolioDetails(&sv.PortfolioDetails, value); err != nil { 17820 return err 17821 } 17822 17823 default: 17824 _, _ = key, value 17825 17826 } 17827 } 17828 *v = sv 17829 return nil 17830} 17831 17832func awsAwsjson11_deserializeOpDocumentListBudgetsForResourceOutput(v **ListBudgetsForResourceOutput, value interface{}) error { 17833 if v == nil { 17834 return fmt.Errorf("unexpected nil of type %T", v) 17835 } 17836 if value == nil { 17837 return nil 17838 } 17839 17840 shape, ok := value.(map[string]interface{}) 17841 if !ok { 17842 return fmt.Errorf("unexpected JSON type %v", value) 17843 } 17844 17845 var sv *ListBudgetsForResourceOutput 17846 if *v == nil { 17847 sv = &ListBudgetsForResourceOutput{} 17848 } else { 17849 sv = *v 17850 } 17851 17852 for key, value := range shape { 17853 switch key { 17854 case "Budgets": 17855 if err := awsAwsjson11_deserializeDocumentBudgets(&sv.Budgets, value); err != nil { 17856 return err 17857 } 17858 17859 case "NextPageToken": 17860 if value != nil { 17861 jtv, ok := value.(string) 17862 if !ok { 17863 return fmt.Errorf("expected PageToken to be of type string, got %T instead", value) 17864 } 17865 sv.NextPageToken = ptr.String(jtv) 17866 } 17867 17868 default: 17869 _, _ = key, value 17870 17871 } 17872 } 17873 *v = sv 17874 return nil 17875} 17876 17877func awsAwsjson11_deserializeOpDocumentListConstraintsForPortfolioOutput(v **ListConstraintsForPortfolioOutput, value interface{}) error { 17878 if v == nil { 17879 return fmt.Errorf("unexpected nil of type %T", v) 17880 } 17881 if value == nil { 17882 return nil 17883 } 17884 17885 shape, ok := value.(map[string]interface{}) 17886 if !ok { 17887 return fmt.Errorf("unexpected JSON type %v", value) 17888 } 17889 17890 var sv *ListConstraintsForPortfolioOutput 17891 if *v == nil { 17892 sv = &ListConstraintsForPortfolioOutput{} 17893 } else { 17894 sv = *v 17895 } 17896 17897 for key, value := range shape { 17898 switch key { 17899 case "ConstraintDetails": 17900 if err := awsAwsjson11_deserializeDocumentConstraintDetails(&sv.ConstraintDetails, value); err != nil { 17901 return err 17902 } 17903 17904 case "NextPageToken": 17905 if value != nil { 17906 jtv, ok := value.(string) 17907 if !ok { 17908 return fmt.Errorf("expected PageToken to be of type string, got %T instead", value) 17909 } 17910 sv.NextPageToken = ptr.String(jtv) 17911 } 17912 17913 default: 17914 _, _ = key, value 17915 17916 } 17917 } 17918 *v = sv 17919 return nil 17920} 17921 17922func awsAwsjson11_deserializeOpDocumentListLaunchPathsOutput(v **ListLaunchPathsOutput, value interface{}) error { 17923 if v == nil { 17924 return fmt.Errorf("unexpected nil of type %T", v) 17925 } 17926 if value == nil { 17927 return nil 17928 } 17929 17930 shape, ok := value.(map[string]interface{}) 17931 if !ok { 17932 return fmt.Errorf("unexpected JSON type %v", value) 17933 } 17934 17935 var sv *ListLaunchPathsOutput 17936 if *v == nil { 17937 sv = &ListLaunchPathsOutput{} 17938 } else { 17939 sv = *v 17940 } 17941 17942 for key, value := range shape { 17943 switch key { 17944 case "LaunchPathSummaries": 17945 if err := awsAwsjson11_deserializeDocumentLaunchPathSummaries(&sv.LaunchPathSummaries, value); err != nil { 17946 return err 17947 } 17948 17949 case "NextPageToken": 17950 if value != nil { 17951 jtv, ok := value.(string) 17952 if !ok { 17953 return fmt.Errorf("expected PageToken to be of type string, got %T instead", value) 17954 } 17955 sv.NextPageToken = ptr.String(jtv) 17956 } 17957 17958 default: 17959 _, _ = key, value 17960 17961 } 17962 } 17963 *v = sv 17964 return nil 17965} 17966 17967func awsAwsjson11_deserializeOpDocumentListOrganizationPortfolioAccessOutput(v **ListOrganizationPortfolioAccessOutput, value interface{}) error { 17968 if v == nil { 17969 return fmt.Errorf("unexpected nil of type %T", v) 17970 } 17971 if value == nil { 17972 return nil 17973 } 17974 17975 shape, ok := value.(map[string]interface{}) 17976 if !ok { 17977 return fmt.Errorf("unexpected JSON type %v", value) 17978 } 17979 17980 var sv *ListOrganizationPortfolioAccessOutput 17981 if *v == nil { 17982 sv = &ListOrganizationPortfolioAccessOutput{} 17983 } else { 17984 sv = *v 17985 } 17986 17987 for key, value := range shape { 17988 switch key { 17989 case "NextPageToken": 17990 if value != nil { 17991 jtv, ok := value.(string) 17992 if !ok { 17993 return fmt.Errorf("expected PageToken to be of type string, got %T instead", value) 17994 } 17995 sv.NextPageToken = ptr.String(jtv) 17996 } 17997 17998 case "OrganizationNodes": 17999 if err := awsAwsjson11_deserializeDocumentOrganizationNodes(&sv.OrganizationNodes, value); err != nil { 18000 return err 18001 } 18002 18003 default: 18004 _, _ = key, value 18005 18006 } 18007 } 18008 *v = sv 18009 return nil 18010} 18011 18012func awsAwsjson11_deserializeOpDocumentListPortfolioAccessOutput(v **ListPortfolioAccessOutput, value interface{}) error { 18013 if v == nil { 18014 return fmt.Errorf("unexpected nil of type %T", v) 18015 } 18016 if value == nil { 18017 return nil 18018 } 18019 18020 shape, ok := value.(map[string]interface{}) 18021 if !ok { 18022 return fmt.Errorf("unexpected JSON type %v", value) 18023 } 18024 18025 var sv *ListPortfolioAccessOutput 18026 if *v == nil { 18027 sv = &ListPortfolioAccessOutput{} 18028 } else { 18029 sv = *v 18030 } 18031 18032 for key, value := range shape { 18033 switch key { 18034 case "AccountIds": 18035 if err := awsAwsjson11_deserializeDocumentAccountIds(&sv.AccountIds, value); err != nil { 18036 return err 18037 } 18038 18039 case "NextPageToken": 18040 if value != nil { 18041 jtv, ok := value.(string) 18042 if !ok { 18043 return fmt.Errorf("expected PageToken to be of type string, got %T instead", value) 18044 } 18045 sv.NextPageToken = ptr.String(jtv) 18046 } 18047 18048 default: 18049 _, _ = key, value 18050 18051 } 18052 } 18053 *v = sv 18054 return nil 18055} 18056 18057func awsAwsjson11_deserializeOpDocumentListPortfoliosForProductOutput(v **ListPortfoliosForProductOutput, value interface{}) error { 18058 if v == nil { 18059 return fmt.Errorf("unexpected nil of type %T", v) 18060 } 18061 if value == nil { 18062 return nil 18063 } 18064 18065 shape, ok := value.(map[string]interface{}) 18066 if !ok { 18067 return fmt.Errorf("unexpected JSON type %v", value) 18068 } 18069 18070 var sv *ListPortfoliosForProductOutput 18071 if *v == nil { 18072 sv = &ListPortfoliosForProductOutput{} 18073 } else { 18074 sv = *v 18075 } 18076 18077 for key, value := range shape { 18078 switch key { 18079 case "NextPageToken": 18080 if value != nil { 18081 jtv, ok := value.(string) 18082 if !ok { 18083 return fmt.Errorf("expected PageToken to be of type string, got %T instead", value) 18084 } 18085 sv.NextPageToken = ptr.String(jtv) 18086 } 18087 18088 case "PortfolioDetails": 18089 if err := awsAwsjson11_deserializeDocumentPortfolioDetails(&sv.PortfolioDetails, value); err != nil { 18090 return err 18091 } 18092 18093 default: 18094 _, _ = key, value 18095 18096 } 18097 } 18098 *v = sv 18099 return nil 18100} 18101 18102func awsAwsjson11_deserializeOpDocumentListPortfoliosOutput(v **ListPortfoliosOutput, value interface{}) error { 18103 if v == nil { 18104 return fmt.Errorf("unexpected nil of type %T", v) 18105 } 18106 if value == nil { 18107 return nil 18108 } 18109 18110 shape, ok := value.(map[string]interface{}) 18111 if !ok { 18112 return fmt.Errorf("unexpected JSON type %v", value) 18113 } 18114 18115 var sv *ListPortfoliosOutput 18116 if *v == nil { 18117 sv = &ListPortfoliosOutput{} 18118 } else { 18119 sv = *v 18120 } 18121 18122 for key, value := range shape { 18123 switch key { 18124 case "NextPageToken": 18125 if value != nil { 18126 jtv, ok := value.(string) 18127 if !ok { 18128 return fmt.Errorf("expected PageToken to be of type string, got %T instead", value) 18129 } 18130 sv.NextPageToken = ptr.String(jtv) 18131 } 18132 18133 case "PortfolioDetails": 18134 if err := awsAwsjson11_deserializeDocumentPortfolioDetails(&sv.PortfolioDetails, value); err != nil { 18135 return err 18136 } 18137 18138 default: 18139 _, _ = key, value 18140 18141 } 18142 } 18143 *v = sv 18144 return nil 18145} 18146 18147func awsAwsjson11_deserializeOpDocumentListPrincipalsForPortfolioOutput(v **ListPrincipalsForPortfolioOutput, value interface{}) error { 18148 if v == nil { 18149 return fmt.Errorf("unexpected nil of type %T", v) 18150 } 18151 if value == nil { 18152 return nil 18153 } 18154 18155 shape, ok := value.(map[string]interface{}) 18156 if !ok { 18157 return fmt.Errorf("unexpected JSON type %v", value) 18158 } 18159 18160 var sv *ListPrincipalsForPortfolioOutput 18161 if *v == nil { 18162 sv = &ListPrincipalsForPortfolioOutput{} 18163 } else { 18164 sv = *v 18165 } 18166 18167 for key, value := range shape { 18168 switch key { 18169 case "NextPageToken": 18170 if value != nil { 18171 jtv, ok := value.(string) 18172 if !ok { 18173 return fmt.Errorf("expected PageToken to be of type string, got %T instead", value) 18174 } 18175 sv.NextPageToken = ptr.String(jtv) 18176 } 18177 18178 case "Principals": 18179 if err := awsAwsjson11_deserializeDocumentPrincipals(&sv.Principals, value); err != nil { 18180 return err 18181 } 18182 18183 default: 18184 _, _ = key, value 18185 18186 } 18187 } 18188 *v = sv 18189 return nil 18190} 18191 18192func awsAwsjson11_deserializeOpDocumentListProvisionedProductPlansOutput(v **ListProvisionedProductPlansOutput, value interface{}) error { 18193 if v == nil { 18194 return fmt.Errorf("unexpected nil of type %T", v) 18195 } 18196 if value == nil { 18197 return nil 18198 } 18199 18200 shape, ok := value.(map[string]interface{}) 18201 if !ok { 18202 return fmt.Errorf("unexpected JSON type %v", value) 18203 } 18204 18205 var sv *ListProvisionedProductPlansOutput 18206 if *v == nil { 18207 sv = &ListProvisionedProductPlansOutput{} 18208 } else { 18209 sv = *v 18210 } 18211 18212 for key, value := range shape { 18213 switch key { 18214 case "NextPageToken": 18215 if value != nil { 18216 jtv, ok := value.(string) 18217 if !ok { 18218 return fmt.Errorf("expected PageToken to be of type string, got %T instead", value) 18219 } 18220 sv.NextPageToken = ptr.String(jtv) 18221 } 18222 18223 case "ProvisionedProductPlans": 18224 if err := awsAwsjson11_deserializeDocumentProvisionedProductPlans(&sv.ProvisionedProductPlans, value); err != nil { 18225 return err 18226 } 18227 18228 default: 18229 _, _ = key, value 18230 18231 } 18232 } 18233 *v = sv 18234 return nil 18235} 18236 18237func awsAwsjson11_deserializeOpDocumentListProvisioningArtifactsForServiceActionOutput(v **ListProvisioningArtifactsForServiceActionOutput, value interface{}) error { 18238 if v == nil { 18239 return fmt.Errorf("unexpected nil of type %T", v) 18240 } 18241 if value == nil { 18242 return nil 18243 } 18244 18245 shape, ok := value.(map[string]interface{}) 18246 if !ok { 18247 return fmt.Errorf("unexpected JSON type %v", value) 18248 } 18249 18250 var sv *ListProvisioningArtifactsForServiceActionOutput 18251 if *v == nil { 18252 sv = &ListProvisioningArtifactsForServiceActionOutput{} 18253 } else { 18254 sv = *v 18255 } 18256 18257 for key, value := range shape { 18258 switch key { 18259 case "NextPageToken": 18260 if value != nil { 18261 jtv, ok := value.(string) 18262 if !ok { 18263 return fmt.Errorf("expected PageToken to be of type string, got %T instead", value) 18264 } 18265 sv.NextPageToken = ptr.String(jtv) 18266 } 18267 18268 case "ProvisioningArtifactViews": 18269 if err := awsAwsjson11_deserializeDocumentProvisioningArtifactViews(&sv.ProvisioningArtifactViews, value); err != nil { 18270 return err 18271 } 18272 18273 default: 18274 _, _ = key, value 18275 18276 } 18277 } 18278 *v = sv 18279 return nil 18280} 18281 18282func awsAwsjson11_deserializeOpDocumentListProvisioningArtifactsOutput(v **ListProvisioningArtifactsOutput, value interface{}) error { 18283 if v == nil { 18284 return fmt.Errorf("unexpected nil of type %T", v) 18285 } 18286 if value == nil { 18287 return nil 18288 } 18289 18290 shape, ok := value.(map[string]interface{}) 18291 if !ok { 18292 return fmt.Errorf("unexpected JSON type %v", value) 18293 } 18294 18295 var sv *ListProvisioningArtifactsOutput 18296 if *v == nil { 18297 sv = &ListProvisioningArtifactsOutput{} 18298 } else { 18299 sv = *v 18300 } 18301 18302 for key, value := range shape { 18303 switch key { 18304 case "NextPageToken": 18305 if value != nil { 18306 jtv, ok := value.(string) 18307 if !ok { 18308 return fmt.Errorf("expected PageToken to be of type string, got %T instead", value) 18309 } 18310 sv.NextPageToken = ptr.String(jtv) 18311 } 18312 18313 case "ProvisioningArtifactDetails": 18314 if err := awsAwsjson11_deserializeDocumentProvisioningArtifactDetails(&sv.ProvisioningArtifactDetails, value); err != nil { 18315 return err 18316 } 18317 18318 default: 18319 _, _ = key, value 18320 18321 } 18322 } 18323 *v = sv 18324 return nil 18325} 18326 18327func awsAwsjson11_deserializeOpDocumentListRecordHistoryOutput(v **ListRecordHistoryOutput, value interface{}) error { 18328 if v == nil { 18329 return fmt.Errorf("unexpected nil of type %T", v) 18330 } 18331 if value == nil { 18332 return nil 18333 } 18334 18335 shape, ok := value.(map[string]interface{}) 18336 if !ok { 18337 return fmt.Errorf("unexpected JSON type %v", value) 18338 } 18339 18340 var sv *ListRecordHistoryOutput 18341 if *v == nil { 18342 sv = &ListRecordHistoryOutput{} 18343 } else { 18344 sv = *v 18345 } 18346 18347 for key, value := range shape { 18348 switch key { 18349 case "NextPageToken": 18350 if value != nil { 18351 jtv, ok := value.(string) 18352 if !ok { 18353 return fmt.Errorf("expected PageToken to be of type string, got %T instead", value) 18354 } 18355 sv.NextPageToken = ptr.String(jtv) 18356 } 18357 18358 case "RecordDetails": 18359 if err := awsAwsjson11_deserializeDocumentRecordDetails(&sv.RecordDetails, value); err != nil { 18360 return err 18361 } 18362 18363 default: 18364 _, _ = key, value 18365 18366 } 18367 } 18368 *v = sv 18369 return nil 18370} 18371 18372func awsAwsjson11_deserializeOpDocumentListResourcesForTagOptionOutput(v **ListResourcesForTagOptionOutput, value interface{}) error { 18373 if v == nil { 18374 return fmt.Errorf("unexpected nil of type %T", v) 18375 } 18376 if value == nil { 18377 return nil 18378 } 18379 18380 shape, ok := value.(map[string]interface{}) 18381 if !ok { 18382 return fmt.Errorf("unexpected JSON type %v", value) 18383 } 18384 18385 var sv *ListResourcesForTagOptionOutput 18386 if *v == nil { 18387 sv = &ListResourcesForTagOptionOutput{} 18388 } else { 18389 sv = *v 18390 } 18391 18392 for key, value := range shape { 18393 switch key { 18394 case "PageToken": 18395 if value != nil { 18396 jtv, ok := value.(string) 18397 if !ok { 18398 return fmt.Errorf("expected PageToken to be of type string, got %T instead", value) 18399 } 18400 sv.PageToken = ptr.String(jtv) 18401 } 18402 18403 case "ResourceDetails": 18404 if err := awsAwsjson11_deserializeDocumentResourceDetails(&sv.ResourceDetails, value); err != nil { 18405 return err 18406 } 18407 18408 default: 18409 _, _ = key, value 18410 18411 } 18412 } 18413 *v = sv 18414 return nil 18415} 18416 18417func awsAwsjson11_deserializeOpDocumentListServiceActionsForProvisioningArtifactOutput(v **ListServiceActionsForProvisioningArtifactOutput, value interface{}) error { 18418 if v == nil { 18419 return fmt.Errorf("unexpected nil of type %T", v) 18420 } 18421 if value == nil { 18422 return nil 18423 } 18424 18425 shape, ok := value.(map[string]interface{}) 18426 if !ok { 18427 return fmt.Errorf("unexpected JSON type %v", value) 18428 } 18429 18430 var sv *ListServiceActionsForProvisioningArtifactOutput 18431 if *v == nil { 18432 sv = &ListServiceActionsForProvisioningArtifactOutput{} 18433 } else { 18434 sv = *v 18435 } 18436 18437 for key, value := range shape { 18438 switch key { 18439 case "NextPageToken": 18440 if value != nil { 18441 jtv, ok := value.(string) 18442 if !ok { 18443 return fmt.Errorf("expected PageToken to be of type string, got %T instead", value) 18444 } 18445 sv.NextPageToken = ptr.String(jtv) 18446 } 18447 18448 case "ServiceActionSummaries": 18449 if err := awsAwsjson11_deserializeDocumentServiceActionSummaries(&sv.ServiceActionSummaries, value); err != nil { 18450 return err 18451 } 18452 18453 default: 18454 _, _ = key, value 18455 18456 } 18457 } 18458 *v = sv 18459 return nil 18460} 18461 18462func awsAwsjson11_deserializeOpDocumentListServiceActionsOutput(v **ListServiceActionsOutput, value interface{}) error { 18463 if v == nil { 18464 return fmt.Errorf("unexpected nil of type %T", v) 18465 } 18466 if value == nil { 18467 return nil 18468 } 18469 18470 shape, ok := value.(map[string]interface{}) 18471 if !ok { 18472 return fmt.Errorf("unexpected JSON type %v", value) 18473 } 18474 18475 var sv *ListServiceActionsOutput 18476 if *v == nil { 18477 sv = &ListServiceActionsOutput{} 18478 } else { 18479 sv = *v 18480 } 18481 18482 for key, value := range shape { 18483 switch key { 18484 case "NextPageToken": 18485 if value != nil { 18486 jtv, ok := value.(string) 18487 if !ok { 18488 return fmt.Errorf("expected PageToken to be of type string, got %T instead", value) 18489 } 18490 sv.NextPageToken = ptr.String(jtv) 18491 } 18492 18493 case "ServiceActionSummaries": 18494 if err := awsAwsjson11_deserializeDocumentServiceActionSummaries(&sv.ServiceActionSummaries, value); err != nil { 18495 return err 18496 } 18497 18498 default: 18499 _, _ = key, value 18500 18501 } 18502 } 18503 *v = sv 18504 return nil 18505} 18506 18507func awsAwsjson11_deserializeOpDocumentListStackInstancesForProvisionedProductOutput(v **ListStackInstancesForProvisionedProductOutput, value interface{}) error { 18508 if v == nil { 18509 return fmt.Errorf("unexpected nil of type %T", v) 18510 } 18511 if value == nil { 18512 return nil 18513 } 18514 18515 shape, ok := value.(map[string]interface{}) 18516 if !ok { 18517 return fmt.Errorf("unexpected JSON type %v", value) 18518 } 18519 18520 var sv *ListStackInstancesForProvisionedProductOutput 18521 if *v == nil { 18522 sv = &ListStackInstancesForProvisionedProductOutput{} 18523 } else { 18524 sv = *v 18525 } 18526 18527 for key, value := range shape { 18528 switch key { 18529 case "NextPageToken": 18530 if value != nil { 18531 jtv, ok := value.(string) 18532 if !ok { 18533 return fmt.Errorf("expected PageToken to be of type string, got %T instead", value) 18534 } 18535 sv.NextPageToken = ptr.String(jtv) 18536 } 18537 18538 case "StackInstances": 18539 if err := awsAwsjson11_deserializeDocumentStackInstances(&sv.StackInstances, value); err != nil { 18540 return err 18541 } 18542 18543 default: 18544 _, _ = key, value 18545 18546 } 18547 } 18548 *v = sv 18549 return nil 18550} 18551 18552func awsAwsjson11_deserializeOpDocumentListTagOptionsOutput(v **ListTagOptionsOutput, value interface{}) error { 18553 if v == nil { 18554 return fmt.Errorf("unexpected nil of type %T", v) 18555 } 18556 if value == nil { 18557 return nil 18558 } 18559 18560 shape, ok := value.(map[string]interface{}) 18561 if !ok { 18562 return fmt.Errorf("unexpected JSON type %v", value) 18563 } 18564 18565 var sv *ListTagOptionsOutput 18566 if *v == nil { 18567 sv = &ListTagOptionsOutput{} 18568 } else { 18569 sv = *v 18570 } 18571 18572 for key, value := range shape { 18573 switch key { 18574 case "PageToken": 18575 if value != nil { 18576 jtv, ok := value.(string) 18577 if !ok { 18578 return fmt.Errorf("expected PageToken to be of type string, got %T instead", value) 18579 } 18580 sv.PageToken = ptr.String(jtv) 18581 } 18582 18583 case "TagOptionDetails": 18584 if err := awsAwsjson11_deserializeDocumentTagOptionDetails(&sv.TagOptionDetails, value); err != nil { 18585 return err 18586 } 18587 18588 default: 18589 _, _ = key, value 18590 18591 } 18592 } 18593 *v = sv 18594 return nil 18595} 18596 18597func awsAwsjson11_deserializeOpDocumentProvisionProductOutput(v **ProvisionProductOutput, value interface{}) error { 18598 if v == nil { 18599 return fmt.Errorf("unexpected nil of type %T", v) 18600 } 18601 if value == nil { 18602 return nil 18603 } 18604 18605 shape, ok := value.(map[string]interface{}) 18606 if !ok { 18607 return fmt.Errorf("unexpected JSON type %v", value) 18608 } 18609 18610 var sv *ProvisionProductOutput 18611 if *v == nil { 18612 sv = &ProvisionProductOutput{} 18613 } else { 18614 sv = *v 18615 } 18616 18617 for key, value := range shape { 18618 switch key { 18619 case "RecordDetail": 18620 if err := awsAwsjson11_deserializeDocumentRecordDetail(&sv.RecordDetail, value); err != nil { 18621 return err 18622 } 18623 18624 default: 18625 _, _ = key, value 18626 18627 } 18628 } 18629 *v = sv 18630 return nil 18631} 18632 18633func awsAwsjson11_deserializeOpDocumentRejectPortfolioShareOutput(v **RejectPortfolioShareOutput, value interface{}) error { 18634 if v == nil { 18635 return fmt.Errorf("unexpected nil of type %T", v) 18636 } 18637 if value == nil { 18638 return nil 18639 } 18640 18641 shape, ok := value.(map[string]interface{}) 18642 if !ok { 18643 return fmt.Errorf("unexpected JSON type %v", value) 18644 } 18645 18646 var sv *RejectPortfolioShareOutput 18647 if *v == nil { 18648 sv = &RejectPortfolioShareOutput{} 18649 } else { 18650 sv = *v 18651 } 18652 18653 for key, value := range shape { 18654 switch key { 18655 default: 18656 _, _ = key, value 18657 18658 } 18659 } 18660 *v = sv 18661 return nil 18662} 18663 18664func awsAwsjson11_deserializeOpDocumentScanProvisionedProductsOutput(v **ScanProvisionedProductsOutput, value interface{}) error { 18665 if v == nil { 18666 return fmt.Errorf("unexpected nil of type %T", v) 18667 } 18668 if value == nil { 18669 return nil 18670 } 18671 18672 shape, ok := value.(map[string]interface{}) 18673 if !ok { 18674 return fmt.Errorf("unexpected JSON type %v", value) 18675 } 18676 18677 var sv *ScanProvisionedProductsOutput 18678 if *v == nil { 18679 sv = &ScanProvisionedProductsOutput{} 18680 } else { 18681 sv = *v 18682 } 18683 18684 for key, value := range shape { 18685 switch key { 18686 case "NextPageToken": 18687 if value != nil { 18688 jtv, ok := value.(string) 18689 if !ok { 18690 return fmt.Errorf("expected PageToken to be of type string, got %T instead", value) 18691 } 18692 sv.NextPageToken = ptr.String(jtv) 18693 } 18694 18695 case "ProvisionedProducts": 18696 if err := awsAwsjson11_deserializeDocumentProvisionedProductDetails(&sv.ProvisionedProducts, value); err != nil { 18697 return err 18698 } 18699 18700 default: 18701 _, _ = key, value 18702 18703 } 18704 } 18705 *v = sv 18706 return nil 18707} 18708 18709func awsAwsjson11_deserializeOpDocumentSearchProductsAsAdminOutput(v **SearchProductsAsAdminOutput, value interface{}) error { 18710 if v == nil { 18711 return fmt.Errorf("unexpected nil of type %T", v) 18712 } 18713 if value == nil { 18714 return nil 18715 } 18716 18717 shape, ok := value.(map[string]interface{}) 18718 if !ok { 18719 return fmt.Errorf("unexpected JSON type %v", value) 18720 } 18721 18722 var sv *SearchProductsAsAdminOutput 18723 if *v == nil { 18724 sv = &SearchProductsAsAdminOutput{} 18725 } else { 18726 sv = *v 18727 } 18728 18729 for key, value := range shape { 18730 switch key { 18731 case "NextPageToken": 18732 if value != nil { 18733 jtv, ok := value.(string) 18734 if !ok { 18735 return fmt.Errorf("expected PageToken to be of type string, got %T instead", value) 18736 } 18737 sv.NextPageToken = ptr.String(jtv) 18738 } 18739 18740 case "ProductViewDetails": 18741 if err := awsAwsjson11_deserializeDocumentProductViewDetails(&sv.ProductViewDetails, value); err != nil { 18742 return err 18743 } 18744 18745 default: 18746 _, _ = key, value 18747 18748 } 18749 } 18750 *v = sv 18751 return nil 18752} 18753 18754func awsAwsjson11_deserializeOpDocumentSearchProductsOutput(v **SearchProductsOutput, value interface{}) error { 18755 if v == nil { 18756 return fmt.Errorf("unexpected nil of type %T", v) 18757 } 18758 if value == nil { 18759 return nil 18760 } 18761 18762 shape, ok := value.(map[string]interface{}) 18763 if !ok { 18764 return fmt.Errorf("unexpected JSON type %v", value) 18765 } 18766 18767 var sv *SearchProductsOutput 18768 if *v == nil { 18769 sv = &SearchProductsOutput{} 18770 } else { 18771 sv = *v 18772 } 18773 18774 for key, value := range shape { 18775 switch key { 18776 case "NextPageToken": 18777 if value != nil { 18778 jtv, ok := value.(string) 18779 if !ok { 18780 return fmt.Errorf("expected PageToken to be of type string, got %T instead", value) 18781 } 18782 sv.NextPageToken = ptr.String(jtv) 18783 } 18784 18785 case "ProductViewAggregations": 18786 if err := awsAwsjson11_deserializeDocumentProductViewAggregations(&sv.ProductViewAggregations, value); err != nil { 18787 return err 18788 } 18789 18790 case "ProductViewSummaries": 18791 if err := awsAwsjson11_deserializeDocumentProductViewSummaries(&sv.ProductViewSummaries, value); err != nil { 18792 return err 18793 } 18794 18795 default: 18796 _, _ = key, value 18797 18798 } 18799 } 18800 *v = sv 18801 return nil 18802} 18803 18804func awsAwsjson11_deserializeOpDocumentSearchProvisionedProductsOutput(v **SearchProvisionedProductsOutput, value interface{}) error { 18805 if v == nil { 18806 return fmt.Errorf("unexpected nil of type %T", v) 18807 } 18808 if value == nil { 18809 return nil 18810 } 18811 18812 shape, ok := value.(map[string]interface{}) 18813 if !ok { 18814 return fmt.Errorf("unexpected JSON type %v", value) 18815 } 18816 18817 var sv *SearchProvisionedProductsOutput 18818 if *v == nil { 18819 sv = &SearchProvisionedProductsOutput{} 18820 } else { 18821 sv = *v 18822 } 18823 18824 for key, value := range shape { 18825 switch key { 18826 case "NextPageToken": 18827 if value != nil { 18828 jtv, ok := value.(string) 18829 if !ok { 18830 return fmt.Errorf("expected PageToken to be of type string, got %T instead", value) 18831 } 18832 sv.NextPageToken = ptr.String(jtv) 18833 } 18834 18835 case "ProvisionedProducts": 18836 if err := awsAwsjson11_deserializeDocumentProvisionedProductAttributes(&sv.ProvisionedProducts, value); err != nil { 18837 return err 18838 } 18839 18840 case "TotalResultsCount": 18841 if value != nil { 18842 jtv, ok := value.(json.Number) 18843 if !ok { 18844 return fmt.Errorf("expected TotalResultsCount to be json.Number, got %T instead", value) 18845 } 18846 i64, err := jtv.Int64() 18847 if err != nil { 18848 return err 18849 } 18850 sv.TotalResultsCount = int32(i64) 18851 } 18852 18853 default: 18854 _, _ = key, value 18855 18856 } 18857 } 18858 *v = sv 18859 return nil 18860} 18861 18862func awsAwsjson11_deserializeOpDocumentTerminateProvisionedProductOutput(v **TerminateProvisionedProductOutput, value interface{}) error { 18863 if v == nil { 18864 return fmt.Errorf("unexpected nil of type %T", v) 18865 } 18866 if value == nil { 18867 return nil 18868 } 18869 18870 shape, ok := value.(map[string]interface{}) 18871 if !ok { 18872 return fmt.Errorf("unexpected JSON type %v", value) 18873 } 18874 18875 var sv *TerminateProvisionedProductOutput 18876 if *v == nil { 18877 sv = &TerminateProvisionedProductOutput{} 18878 } else { 18879 sv = *v 18880 } 18881 18882 for key, value := range shape { 18883 switch key { 18884 case "RecordDetail": 18885 if err := awsAwsjson11_deserializeDocumentRecordDetail(&sv.RecordDetail, value); err != nil { 18886 return err 18887 } 18888 18889 default: 18890 _, _ = key, value 18891 18892 } 18893 } 18894 *v = sv 18895 return nil 18896} 18897 18898func awsAwsjson11_deserializeOpDocumentUpdateConstraintOutput(v **UpdateConstraintOutput, value interface{}) error { 18899 if v == nil { 18900 return fmt.Errorf("unexpected nil of type %T", v) 18901 } 18902 if value == nil { 18903 return nil 18904 } 18905 18906 shape, ok := value.(map[string]interface{}) 18907 if !ok { 18908 return fmt.Errorf("unexpected JSON type %v", value) 18909 } 18910 18911 var sv *UpdateConstraintOutput 18912 if *v == nil { 18913 sv = &UpdateConstraintOutput{} 18914 } else { 18915 sv = *v 18916 } 18917 18918 for key, value := range shape { 18919 switch key { 18920 case "ConstraintDetail": 18921 if err := awsAwsjson11_deserializeDocumentConstraintDetail(&sv.ConstraintDetail, value); err != nil { 18922 return err 18923 } 18924 18925 case "ConstraintParameters": 18926 if value != nil { 18927 jtv, ok := value.(string) 18928 if !ok { 18929 return fmt.Errorf("expected ConstraintParameters to be of type string, got %T instead", value) 18930 } 18931 sv.ConstraintParameters = ptr.String(jtv) 18932 } 18933 18934 case "Status": 18935 if value != nil { 18936 jtv, ok := value.(string) 18937 if !ok { 18938 return fmt.Errorf("expected Status to be of type string, got %T instead", value) 18939 } 18940 sv.Status = types.Status(jtv) 18941 } 18942 18943 default: 18944 _, _ = key, value 18945 18946 } 18947 } 18948 *v = sv 18949 return nil 18950} 18951 18952func awsAwsjson11_deserializeOpDocumentUpdatePortfolioOutput(v **UpdatePortfolioOutput, 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 *UpdatePortfolioOutput 18966 if *v == nil { 18967 sv = &UpdatePortfolioOutput{} 18968 } else { 18969 sv = *v 18970 } 18971 18972 for key, value := range shape { 18973 switch key { 18974 case "PortfolioDetail": 18975 if err := awsAwsjson11_deserializeDocumentPortfolioDetail(&sv.PortfolioDetail, value); err != nil { 18976 return err 18977 } 18978 18979 case "Tags": 18980 if err := awsAwsjson11_deserializeDocumentTags(&sv.Tags, value); err != nil { 18981 return err 18982 } 18983 18984 default: 18985 _, _ = key, value 18986 18987 } 18988 } 18989 *v = sv 18990 return nil 18991} 18992 18993func awsAwsjson11_deserializeOpDocumentUpdatePortfolioShareOutput(v **UpdatePortfolioShareOutput, value interface{}) error { 18994 if v == nil { 18995 return fmt.Errorf("unexpected nil of type %T", v) 18996 } 18997 if value == nil { 18998 return nil 18999 } 19000 19001 shape, ok := value.(map[string]interface{}) 19002 if !ok { 19003 return fmt.Errorf("unexpected JSON type %v", value) 19004 } 19005 19006 var sv *UpdatePortfolioShareOutput 19007 if *v == nil { 19008 sv = &UpdatePortfolioShareOutput{} 19009 } else { 19010 sv = *v 19011 } 19012 19013 for key, value := range shape { 19014 switch key { 19015 case "PortfolioShareToken": 19016 if value != nil { 19017 jtv, ok := value.(string) 19018 if !ok { 19019 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 19020 } 19021 sv.PortfolioShareToken = ptr.String(jtv) 19022 } 19023 19024 case "Status": 19025 if value != nil { 19026 jtv, ok := value.(string) 19027 if !ok { 19028 return fmt.Errorf("expected ShareStatus to be of type string, got %T instead", value) 19029 } 19030 sv.Status = types.ShareStatus(jtv) 19031 } 19032 19033 default: 19034 _, _ = key, value 19035 19036 } 19037 } 19038 *v = sv 19039 return nil 19040} 19041 19042func awsAwsjson11_deserializeOpDocumentUpdateProductOutput(v **UpdateProductOutput, value interface{}) error { 19043 if v == nil { 19044 return fmt.Errorf("unexpected nil of type %T", v) 19045 } 19046 if value == nil { 19047 return nil 19048 } 19049 19050 shape, ok := value.(map[string]interface{}) 19051 if !ok { 19052 return fmt.Errorf("unexpected JSON type %v", value) 19053 } 19054 19055 var sv *UpdateProductOutput 19056 if *v == nil { 19057 sv = &UpdateProductOutput{} 19058 } else { 19059 sv = *v 19060 } 19061 19062 for key, value := range shape { 19063 switch key { 19064 case "ProductViewDetail": 19065 if err := awsAwsjson11_deserializeDocumentProductViewDetail(&sv.ProductViewDetail, value); err != nil { 19066 return err 19067 } 19068 19069 case "Tags": 19070 if err := awsAwsjson11_deserializeDocumentTags(&sv.Tags, value); err != nil { 19071 return err 19072 } 19073 19074 default: 19075 _, _ = key, value 19076 19077 } 19078 } 19079 *v = sv 19080 return nil 19081} 19082 19083func awsAwsjson11_deserializeOpDocumentUpdateProvisionedProductOutput(v **UpdateProvisionedProductOutput, value interface{}) error { 19084 if v == nil { 19085 return fmt.Errorf("unexpected nil of type %T", v) 19086 } 19087 if value == nil { 19088 return nil 19089 } 19090 19091 shape, ok := value.(map[string]interface{}) 19092 if !ok { 19093 return fmt.Errorf("unexpected JSON type %v", value) 19094 } 19095 19096 var sv *UpdateProvisionedProductOutput 19097 if *v == nil { 19098 sv = &UpdateProvisionedProductOutput{} 19099 } else { 19100 sv = *v 19101 } 19102 19103 for key, value := range shape { 19104 switch key { 19105 case "RecordDetail": 19106 if err := awsAwsjson11_deserializeDocumentRecordDetail(&sv.RecordDetail, value); err != nil { 19107 return err 19108 } 19109 19110 default: 19111 _, _ = key, value 19112 19113 } 19114 } 19115 *v = sv 19116 return nil 19117} 19118 19119func awsAwsjson11_deserializeOpDocumentUpdateProvisionedProductPropertiesOutput(v **UpdateProvisionedProductPropertiesOutput, value interface{}) error { 19120 if v == nil { 19121 return fmt.Errorf("unexpected nil of type %T", v) 19122 } 19123 if value == nil { 19124 return nil 19125 } 19126 19127 shape, ok := value.(map[string]interface{}) 19128 if !ok { 19129 return fmt.Errorf("unexpected JSON type %v", value) 19130 } 19131 19132 var sv *UpdateProvisionedProductPropertiesOutput 19133 if *v == nil { 19134 sv = &UpdateProvisionedProductPropertiesOutput{} 19135 } else { 19136 sv = *v 19137 } 19138 19139 for key, value := range shape { 19140 switch key { 19141 case "ProvisionedProductId": 19142 if value != nil { 19143 jtv, ok := value.(string) 19144 if !ok { 19145 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 19146 } 19147 sv.ProvisionedProductId = ptr.String(jtv) 19148 } 19149 19150 case "ProvisionedProductProperties": 19151 if err := awsAwsjson11_deserializeDocumentProvisionedProductProperties(&sv.ProvisionedProductProperties, value); err != nil { 19152 return err 19153 } 19154 19155 case "RecordId": 19156 if value != nil { 19157 jtv, ok := value.(string) 19158 if !ok { 19159 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 19160 } 19161 sv.RecordId = ptr.String(jtv) 19162 } 19163 19164 case "Status": 19165 if value != nil { 19166 jtv, ok := value.(string) 19167 if !ok { 19168 return fmt.Errorf("expected RecordStatus to be of type string, got %T instead", value) 19169 } 19170 sv.Status = types.RecordStatus(jtv) 19171 } 19172 19173 default: 19174 _, _ = key, value 19175 19176 } 19177 } 19178 *v = sv 19179 return nil 19180} 19181 19182func awsAwsjson11_deserializeOpDocumentUpdateProvisioningArtifactOutput(v **UpdateProvisioningArtifactOutput, value interface{}) error { 19183 if v == nil { 19184 return fmt.Errorf("unexpected nil of type %T", v) 19185 } 19186 if value == nil { 19187 return nil 19188 } 19189 19190 shape, ok := value.(map[string]interface{}) 19191 if !ok { 19192 return fmt.Errorf("unexpected JSON type %v", value) 19193 } 19194 19195 var sv *UpdateProvisioningArtifactOutput 19196 if *v == nil { 19197 sv = &UpdateProvisioningArtifactOutput{} 19198 } else { 19199 sv = *v 19200 } 19201 19202 for key, value := range shape { 19203 switch key { 19204 case "Info": 19205 if err := awsAwsjson11_deserializeDocumentProvisioningArtifactInfo(&sv.Info, value); err != nil { 19206 return err 19207 } 19208 19209 case "ProvisioningArtifactDetail": 19210 if err := awsAwsjson11_deserializeDocumentProvisioningArtifactDetail(&sv.ProvisioningArtifactDetail, value); err != nil { 19211 return err 19212 } 19213 19214 case "Status": 19215 if value != nil { 19216 jtv, ok := value.(string) 19217 if !ok { 19218 return fmt.Errorf("expected Status to be of type string, got %T instead", value) 19219 } 19220 sv.Status = types.Status(jtv) 19221 } 19222 19223 default: 19224 _, _ = key, value 19225 19226 } 19227 } 19228 *v = sv 19229 return nil 19230} 19231 19232func awsAwsjson11_deserializeOpDocumentUpdateServiceActionOutput(v **UpdateServiceActionOutput, value interface{}) error { 19233 if v == nil { 19234 return fmt.Errorf("unexpected nil of type %T", v) 19235 } 19236 if value == nil { 19237 return nil 19238 } 19239 19240 shape, ok := value.(map[string]interface{}) 19241 if !ok { 19242 return fmt.Errorf("unexpected JSON type %v", value) 19243 } 19244 19245 var sv *UpdateServiceActionOutput 19246 if *v == nil { 19247 sv = &UpdateServiceActionOutput{} 19248 } else { 19249 sv = *v 19250 } 19251 19252 for key, value := range shape { 19253 switch key { 19254 case "ServiceActionDetail": 19255 if err := awsAwsjson11_deserializeDocumentServiceActionDetail(&sv.ServiceActionDetail, value); err != nil { 19256 return err 19257 } 19258 19259 default: 19260 _, _ = key, value 19261 19262 } 19263 } 19264 *v = sv 19265 return nil 19266} 19267 19268func awsAwsjson11_deserializeOpDocumentUpdateTagOptionOutput(v **UpdateTagOptionOutput, value interface{}) error { 19269 if v == nil { 19270 return fmt.Errorf("unexpected nil of type %T", v) 19271 } 19272 if value == nil { 19273 return nil 19274 } 19275 19276 shape, ok := value.(map[string]interface{}) 19277 if !ok { 19278 return fmt.Errorf("unexpected JSON type %v", value) 19279 } 19280 19281 var sv *UpdateTagOptionOutput 19282 if *v == nil { 19283 sv = &UpdateTagOptionOutput{} 19284 } else { 19285 sv = *v 19286 } 19287 19288 for key, value := range shape { 19289 switch key { 19290 case "TagOptionDetail": 19291 if err := awsAwsjson11_deserializeDocumentTagOptionDetail(&sv.TagOptionDetail, value); err != nil { 19292 return err 19293 } 19294 19295 default: 19296 _, _ = key, value 19297 19298 } 19299 } 19300 *v = sv 19301 return nil 19302} 19303