1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package appstream 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/appstream/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_deserializeOpAssociateFleet struct { 23} 24 25func (*awsAwsjson11_deserializeOpAssociateFleet) ID() string { 26 return "OperationDeserializer" 27} 28 29func (m *awsAwsjson11_deserializeOpAssociateFleet) 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_deserializeOpErrorAssociateFleet(response, &metadata) 44 } 45 output := &AssociateFleetOutput{} 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_deserializeOpDocumentAssociateFleetOutput(&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_deserializeOpErrorAssociateFleet(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("ConcurrentModificationException", errorCode): 121 return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody) 122 123 case strings.EqualFold("IncompatibleImageException", errorCode): 124 return awsAwsjson11_deserializeErrorIncompatibleImageException(response, errorBody) 125 126 case strings.EqualFold("InvalidAccountStatusException", errorCode): 127 return awsAwsjson11_deserializeErrorInvalidAccountStatusException(response, errorBody) 128 129 case strings.EqualFold("LimitExceededException", errorCode): 130 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 131 132 case strings.EqualFold("OperationNotPermittedException", errorCode): 133 return awsAwsjson11_deserializeErrorOperationNotPermittedException(response, errorBody) 134 135 case strings.EqualFold("ResourceNotFoundException", errorCode): 136 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 137 138 default: 139 genericError := &smithy.GenericAPIError{ 140 Code: errorCode, 141 Message: errorMessage, 142 } 143 return genericError 144 145 } 146} 147 148type awsAwsjson11_deserializeOpBatchAssociateUserStack struct { 149} 150 151func (*awsAwsjson11_deserializeOpBatchAssociateUserStack) ID() string { 152 return "OperationDeserializer" 153} 154 155func (m *awsAwsjson11_deserializeOpBatchAssociateUserStack) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 156 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 157) { 158 out, metadata, err = next.HandleDeserialize(ctx, in) 159 if err != nil { 160 return out, metadata, err 161 } 162 163 response, ok := out.RawResponse.(*smithyhttp.Response) 164 if !ok { 165 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 166 } 167 168 if response.StatusCode < 200 || response.StatusCode >= 300 { 169 return out, metadata, awsAwsjson11_deserializeOpErrorBatchAssociateUserStack(response, &metadata) 170 } 171 output := &BatchAssociateUserStackOutput{} 172 out.Result = output 173 174 var buff [1024]byte 175 ringBuffer := smithyio.NewRingBuffer(buff[:]) 176 177 body := io.TeeReader(response.Body, ringBuffer) 178 decoder := json.NewDecoder(body) 179 decoder.UseNumber() 180 var shape interface{} 181 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 182 var snapshot bytes.Buffer 183 io.Copy(&snapshot, ringBuffer) 184 err = &smithy.DeserializationError{ 185 Err: fmt.Errorf("failed to decode response body, %w", err), 186 Snapshot: snapshot.Bytes(), 187 } 188 return out, metadata, err 189 } 190 191 err = awsAwsjson11_deserializeOpDocumentBatchAssociateUserStackOutput(&output, shape) 192 if err != nil { 193 var snapshot bytes.Buffer 194 io.Copy(&snapshot, ringBuffer) 195 err = &smithy.DeserializationError{ 196 Err: fmt.Errorf("failed to decode response body, %w", err), 197 Snapshot: snapshot.Bytes(), 198 } 199 return out, metadata, err 200 } 201 202 return out, metadata, err 203} 204 205func awsAwsjson11_deserializeOpErrorBatchAssociateUserStack(response *smithyhttp.Response, metadata *middleware.Metadata) error { 206 var errorBuffer bytes.Buffer 207 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 208 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 209 } 210 errorBody := bytes.NewReader(errorBuffer.Bytes()) 211 212 errorCode := "UnknownError" 213 errorMessage := errorCode 214 215 code := response.Header.Get("X-Amzn-ErrorType") 216 if len(code) != 0 { 217 errorCode = restjson.SanitizeErrorCode(code) 218 } 219 220 var buff [1024]byte 221 ringBuffer := smithyio.NewRingBuffer(buff[:]) 222 223 body := io.TeeReader(errorBody, ringBuffer) 224 decoder := json.NewDecoder(body) 225 decoder.UseNumber() 226 code, message, err := restjson.GetErrorInfo(decoder) 227 if err != nil { 228 var snapshot bytes.Buffer 229 io.Copy(&snapshot, ringBuffer) 230 err = &smithy.DeserializationError{ 231 Err: fmt.Errorf("failed to decode response body, %w", err), 232 Snapshot: snapshot.Bytes(), 233 } 234 return err 235 } 236 237 errorBody.Seek(0, io.SeekStart) 238 if len(code) != 0 { 239 errorCode = restjson.SanitizeErrorCode(code) 240 } 241 if len(message) != 0 { 242 errorMessage = message 243 } 244 245 switch { 246 case strings.EqualFold("InvalidParameterCombinationException", errorCode): 247 return awsAwsjson11_deserializeErrorInvalidParameterCombinationException(response, errorBody) 248 249 case strings.EqualFold("OperationNotPermittedException", errorCode): 250 return awsAwsjson11_deserializeErrorOperationNotPermittedException(response, errorBody) 251 252 default: 253 genericError := &smithy.GenericAPIError{ 254 Code: errorCode, 255 Message: errorMessage, 256 } 257 return genericError 258 259 } 260} 261 262type awsAwsjson11_deserializeOpBatchDisassociateUserStack struct { 263} 264 265func (*awsAwsjson11_deserializeOpBatchDisassociateUserStack) ID() string { 266 return "OperationDeserializer" 267} 268 269func (m *awsAwsjson11_deserializeOpBatchDisassociateUserStack) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 270 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 271) { 272 out, metadata, err = next.HandleDeserialize(ctx, in) 273 if err != nil { 274 return out, metadata, err 275 } 276 277 response, ok := out.RawResponse.(*smithyhttp.Response) 278 if !ok { 279 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 280 } 281 282 if response.StatusCode < 200 || response.StatusCode >= 300 { 283 return out, metadata, awsAwsjson11_deserializeOpErrorBatchDisassociateUserStack(response, &metadata) 284 } 285 output := &BatchDisassociateUserStackOutput{} 286 out.Result = output 287 288 var buff [1024]byte 289 ringBuffer := smithyio.NewRingBuffer(buff[:]) 290 291 body := io.TeeReader(response.Body, ringBuffer) 292 decoder := json.NewDecoder(body) 293 decoder.UseNumber() 294 var shape interface{} 295 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 296 var snapshot bytes.Buffer 297 io.Copy(&snapshot, ringBuffer) 298 err = &smithy.DeserializationError{ 299 Err: fmt.Errorf("failed to decode response body, %w", err), 300 Snapshot: snapshot.Bytes(), 301 } 302 return out, metadata, err 303 } 304 305 err = awsAwsjson11_deserializeOpDocumentBatchDisassociateUserStackOutput(&output, shape) 306 if err != nil { 307 var snapshot bytes.Buffer 308 io.Copy(&snapshot, ringBuffer) 309 err = &smithy.DeserializationError{ 310 Err: fmt.Errorf("failed to decode response body, %w", err), 311 Snapshot: snapshot.Bytes(), 312 } 313 return out, metadata, err 314 } 315 316 return out, metadata, err 317} 318 319func awsAwsjson11_deserializeOpErrorBatchDisassociateUserStack(response *smithyhttp.Response, metadata *middleware.Metadata) error { 320 var errorBuffer bytes.Buffer 321 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 322 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 323 } 324 errorBody := bytes.NewReader(errorBuffer.Bytes()) 325 326 errorCode := "UnknownError" 327 errorMessage := errorCode 328 329 code := response.Header.Get("X-Amzn-ErrorType") 330 if len(code) != 0 { 331 errorCode = restjson.SanitizeErrorCode(code) 332 } 333 334 var buff [1024]byte 335 ringBuffer := smithyio.NewRingBuffer(buff[:]) 336 337 body := io.TeeReader(errorBody, ringBuffer) 338 decoder := json.NewDecoder(body) 339 decoder.UseNumber() 340 code, message, err := restjson.GetErrorInfo(decoder) 341 if err != nil { 342 var snapshot bytes.Buffer 343 io.Copy(&snapshot, ringBuffer) 344 err = &smithy.DeserializationError{ 345 Err: fmt.Errorf("failed to decode response body, %w", err), 346 Snapshot: snapshot.Bytes(), 347 } 348 return err 349 } 350 351 errorBody.Seek(0, io.SeekStart) 352 if len(code) != 0 { 353 errorCode = restjson.SanitizeErrorCode(code) 354 } 355 if len(message) != 0 { 356 errorMessage = message 357 } 358 359 switch { 360 case strings.EqualFold("InvalidParameterCombinationException", errorCode): 361 return awsAwsjson11_deserializeErrorInvalidParameterCombinationException(response, errorBody) 362 363 case strings.EqualFold("OperationNotPermittedException", errorCode): 364 return awsAwsjson11_deserializeErrorOperationNotPermittedException(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_deserializeOpCopyImage struct { 377} 378 379func (*awsAwsjson11_deserializeOpCopyImage) ID() string { 380 return "OperationDeserializer" 381} 382 383func (m *awsAwsjson11_deserializeOpCopyImage) 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_deserializeOpErrorCopyImage(response, &metadata) 398 } 399 output := &CopyImageOutput{} 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_deserializeOpDocumentCopyImageOutput(&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_deserializeOpErrorCopyImage(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("IncompatibleImageException", errorCode): 475 return awsAwsjson11_deserializeErrorIncompatibleImageException(response, errorBody) 476 477 case strings.EqualFold("InvalidAccountStatusException", errorCode): 478 return awsAwsjson11_deserializeErrorInvalidAccountStatusException(response, errorBody) 479 480 case strings.EqualFold("LimitExceededException", errorCode): 481 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 482 483 case strings.EqualFold("ResourceAlreadyExistsException", errorCode): 484 return awsAwsjson11_deserializeErrorResourceAlreadyExistsException(response, errorBody) 485 486 case strings.EqualFold("ResourceNotAvailableException", errorCode): 487 return awsAwsjson11_deserializeErrorResourceNotAvailableException(response, errorBody) 488 489 case strings.EqualFold("ResourceNotFoundException", errorCode): 490 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 491 492 default: 493 genericError := &smithy.GenericAPIError{ 494 Code: errorCode, 495 Message: errorMessage, 496 } 497 return genericError 498 499 } 500} 501 502type awsAwsjson11_deserializeOpCreateDirectoryConfig struct { 503} 504 505func (*awsAwsjson11_deserializeOpCreateDirectoryConfig) ID() string { 506 return "OperationDeserializer" 507} 508 509func (m *awsAwsjson11_deserializeOpCreateDirectoryConfig) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 510 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 511) { 512 out, metadata, err = next.HandleDeserialize(ctx, in) 513 if err != nil { 514 return out, metadata, err 515 } 516 517 response, ok := out.RawResponse.(*smithyhttp.Response) 518 if !ok { 519 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 520 } 521 522 if response.StatusCode < 200 || response.StatusCode >= 300 { 523 return out, metadata, awsAwsjson11_deserializeOpErrorCreateDirectoryConfig(response, &metadata) 524 } 525 output := &CreateDirectoryConfigOutput{} 526 out.Result = output 527 528 var buff [1024]byte 529 ringBuffer := smithyio.NewRingBuffer(buff[:]) 530 531 body := io.TeeReader(response.Body, ringBuffer) 532 decoder := json.NewDecoder(body) 533 decoder.UseNumber() 534 var shape interface{} 535 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 536 var snapshot bytes.Buffer 537 io.Copy(&snapshot, ringBuffer) 538 err = &smithy.DeserializationError{ 539 Err: fmt.Errorf("failed to decode response body, %w", err), 540 Snapshot: snapshot.Bytes(), 541 } 542 return out, metadata, err 543 } 544 545 err = awsAwsjson11_deserializeOpDocumentCreateDirectoryConfigOutput(&output, shape) 546 if err != nil { 547 var snapshot bytes.Buffer 548 io.Copy(&snapshot, ringBuffer) 549 err = &smithy.DeserializationError{ 550 Err: fmt.Errorf("failed to decode response body, %w", err), 551 Snapshot: snapshot.Bytes(), 552 } 553 return out, metadata, err 554 } 555 556 return out, metadata, err 557} 558 559func awsAwsjson11_deserializeOpErrorCreateDirectoryConfig(response *smithyhttp.Response, metadata *middleware.Metadata) error { 560 var errorBuffer bytes.Buffer 561 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 562 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 563 } 564 errorBody := bytes.NewReader(errorBuffer.Bytes()) 565 566 errorCode := "UnknownError" 567 errorMessage := errorCode 568 569 code := response.Header.Get("X-Amzn-ErrorType") 570 if len(code) != 0 { 571 errorCode = restjson.SanitizeErrorCode(code) 572 } 573 574 var buff [1024]byte 575 ringBuffer := smithyio.NewRingBuffer(buff[:]) 576 577 body := io.TeeReader(errorBody, ringBuffer) 578 decoder := json.NewDecoder(body) 579 decoder.UseNumber() 580 code, message, err := restjson.GetErrorInfo(decoder) 581 if err != nil { 582 var snapshot bytes.Buffer 583 io.Copy(&snapshot, ringBuffer) 584 err = &smithy.DeserializationError{ 585 Err: fmt.Errorf("failed to decode response body, %w", err), 586 Snapshot: snapshot.Bytes(), 587 } 588 return err 589 } 590 591 errorBody.Seek(0, io.SeekStart) 592 if len(code) != 0 { 593 errorCode = restjson.SanitizeErrorCode(code) 594 } 595 if len(message) != 0 { 596 errorMessage = message 597 } 598 599 switch { 600 case strings.EqualFold("InvalidAccountStatusException", errorCode): 601 return awsAwsjson11_deserializeErrorInvalidAccountStatusException(response, errorBody) 602 603 case strings.EqualFold("InvalidRoleException", errorCode): 604 return awsAwsjson11_deserializeErrorInvalidRoleException(response, errorBody) 605 606 case strings.EqualFold("LimitExceededException", errorCode): 607 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 608 609 case strings.EqualFold("OperationNotPermittedException", errorCode): 610 return awsAwsjson11_deserializeErrorOperationNotPermittedException(response, errorBody) 611 612 case strings.EqualFold("ResourceAlreadyExistsException", errorCode): 613 return awsAwsjson11_deserializeErrorResourceAlreadyExistsException(response, errorBody) 614 615 case strings.EqualFold("ResourceNotFoundException", errorCode): 616 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 617 618 default: 619 genericError := &smithy.GenericAPIError{ 620 Code: errorCode, 621 Message: errorMessage, 622 } 623 return genericError 624 625 } 626} 627 628type awsAwsjson11_deserializeOpCreateFleet struct { 629} 630 631func (*awsAwsjson11_deserializeOpCreateFleet) ID() string { 632 return "OperationDeserializer" 633} 634 635func (m *awsAwsjson11_deserializeOpCreateFleet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 636 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 637) { 638 out, metadata, err = next.HandleDeserialize(ctx, in) 639 if err != nil { 640 return out, metadata, err 641 } 642 643 response, ok := out.RawResponse.(*smithyhttp.Response) 644 if !ok { 645 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 646 } 647 648 if response.StatusCode < 200 || response.StatusCode >= 300 { 649 return out, metadata, awsAwsjson11_deserializeOpErrorCreateFleet(response, &metadata) 650 } 651 output := &CreateFleetOutput{} 652 out.Result = output 653 654 var buff [1024]byte 655 ringBuffer := smithyio.NewRingBuffer(buff[:]) 656 657 body := io.TeeReader(response.Body, ringBuffer) 658 decoder := json.NewDecoder(body) 659 decoder.UseNumber() 660 var shape interface{} 661 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 662 var snapshot bytes.Buffer 663 io.Copy(&snapshot, ringBuffer) 664 err = &smithy.DeserializationError{ 665 Err: fmt.Errorf("failed to decode response body, %w", err), 666 Snapshot: snapshot.Bytes(), 667 } 668 return out, metadata, err 669 } 670 671 err = awsAwsjson11_deserializeOpDocumentCreateFleetOutput(&output, shape) 672 if err != nil { 673 var snapshot bytes.Buffer 674 io.Copy(&snapshot, ringBuffer) 675 err = &smithy.DeserializationError{ 676 Err: fmt.Errorf("failed to decode response body, %w", err), 677 Snapshot: snapshot.Bytes(), 678 } 679 return out, metadata, err 680 } 681 682 return out, metadata, err 683} 684 685func awsAwsjson11_deserializeOpErrorCreateFleet(response *smithyhttp.Response, metadata *middleware.Metadata) error { 686 var errorBuffer bytes.Buffer 687 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 688 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 689 } 690 errorBody := bytes.NewReader(errorBuffer.Bytes()) 691 692 errorCode := "UnknownError" 693 errorMessage := errorCode 694 695 code := response.Header.Get("X-Amzn-ErrorType") 696 if len(code) != 0 { 697 errorCode = restjson.SanitizeErrorCode(code) 698 } 699 700 var buff [1024]byte 701 ringBuffer := smithyio.NewRingBuffer(buff[:]) 702 703 body := io.TeeReader(errorBody, ringBuffer) 704 decoder := json.NewDecoder(body) 705 decoder.UseNumber() 706 code, message, err := restjson.GetErrorInfo(decoder) 707 if err != nil { 708 var snapshot bytes.Buffer 709 io.Copy(&snapshot, ringBuffer) 710 err = &smithy.DeserializationError{ 711 Err: fmt.Errorf("failed to decode response body, %w", err), 712 Snapshot: snapshot.Bytes(), 713 } 714 return err 715 } 716 717 errorBody.Seek(0, io.SeekStart) 718 if len(code) != 0 { 719 errorCode = restjson.SanitizeErrorCode(code) 720 } 721 if len(message) != 0 { 722 errorMessage = message 723 } 724 725 switch { 726 case strings.EqualFold("ConcurrentModificationException", errorCode): 727 return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody) 728 729 case strings.EqualFold("IncompatibleImageException", errorCode): 730 return awsAwsjson11_deserializeErrorIncompatibleImageException(response, errorBody) 731 732 case strings.EqualFold("InvalidAccountStatusException", errorCode): 733 return awsAwsjson11_deserializeErrorInvalidAccountStatusException(response, errorBody) 734 735 case strings.EqualFold("InvalidParameterCombinationException", errorCode): 736 return awsAwsjson11_deserializeErrorInvalidParameterCombinationException(response, errorBody) 737 738 case strings.EqualFold("InvalidRoleException", errorCode): 739 return awsAwsjson11_deserializeErrorInvalidRoleException(response, errorBody) 740 741 case strings.EqualFold("LimitExceededException", errorCode): 742 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 743 744 case strings.EqualFold("OperationNotPermittedException", errorCode): 745 return awsAwsjson11_deserializeErrorOperationNotPermittedException(response, errorBody) 746 747 case strings.EqualFold("RequestLimitExceededException", errorCode): 748 return awsAwsjson11_deserializeErrorRequestLimitExceededException(response, errorBody) 749 750 case strings.EqualFold("ResourceAlreadyExistsException", errorCode): 751 return awsAwsjson11_deserializeErrorResourceAlreadyExistsException(response, errorBody) 752 753 case strings.EqualFold("ResourceNotAvailableException", errorCode): 754 return awsAwsjson11_deserializeErrorResourceNotAvailableException(response, errorBody) 755 756 case strings.EqualFold("ResourceNotFoundException", errorCode): 757 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 758 759 default: 760 genericError := &smithy.GenericAPIError{ 761 Code: errorCode, 762 Message: errorMessage, 763 } 764 return genericError 765 766 } 767} 768 769type awsAwsjson11_deserializeOpCreateImageBuilder struct { 770} 771 772func (*awsAwsjson11_deserializeOpCreateImageBuilder) ID() string { 773 return "OperationDeserializer" 774} 775 776func (m *awsAwsjson11_deserializeOpCreateImageBuilder) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 777 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 778) { 779 out, metadata, err = next.HandleDeserialize(ctx, in) 780 if err != nil { 781 return out, metadata, err 782 } 783 784 response, ok := out.RawResponse.(*smithyhttp.Response) 785 if !ok { 786 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 787 } 788 789 if response.StatusCode < 200 || response.StatusCode >= 300 { 790 return out, metadata, awsAwsjson11_deserializeOpErrorCreateImageBuilder(response, &metadata) 791 } 792 output := &CreateImageBuilderOutput{} 793 out.Result = output 794 795 var buff [1024]byte 796 ringBuffer := smithyio.NewRingBuffer(buff[:]) 797 798 body := io.TeeReader(response.Body, ringBuffer) 799 decoder := json.NewDecoder(body) 800 decoder.UseNumber() 801 var shape interface{} 802 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 803 var snapshot bytes.Buffer 804 io.Copy(&snapshot, ringBuffer) 805 err = &smithy.DeserializationError{ 806 Err: fmt.Errorf("failed to decode response body, %w", err), 807 Snapshot: snapshot.Bytes(), 808 } 809 return out, metadata, err 810 } 811 812 err = awsAwsjson11_deserializeOpDocumentCreateImageBuilderOutput(&output, shape) 813 if err != nil { 814 var snapshot bytes.Buffer 815 io.Copy(&snapshot, ringBuffer) 816 err = &smithy.DeserializationError{ 817 Err: fmt.Errorf("failed to decode response body, %w", err), 818 Snapshot: snapshot.Bytes(), 819 } 820 return out, metadata, err 821 } 822 823 return out, metadata, err 824} 825 826func awsAwsjson11_deserializeOpErrorCreateImageBuilder(response *smithyhttp.Response, metadata *middleware.Metadata) error { 827 var errorBuffer bytes.Buffer 828 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 829 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 830 } 831 errorBody := bytes.NewReader(errorBuffer.Bytes()) 832 833 errorCode := "UnknownError" 834 errorMessage := errorCode 835 836 code := response.Header.Get("X-Amzn-ErrorType") 837 if len(code) != 0 { 838 errorCode = restjson.SanitizeErrorCode(code) 839 } 840 841 var buff [1024]byte 842 ringBuffer := smithyio.NewRingBuffer(buff[:]) 843 844 body := io.TeeReader(errorBody, ringBuffer) 845 decoder := json.NewDecoder(body) 846 decoder.UseNumber() 847 code, message, err := restjson.GetErrorInfo(decoder) 848 if err != nil { 849 var snapshot bytes.Buffer 850 io.Copy(&snapshot, ringBuffer) 851 err = &smithy.DeserializationError{ 852 Err: fmt.Errorf("failed to decode response body, %w", err), 853 Snapshot: snapshot.Bytes(), 854 } 855 return err 856 } 857 858 errorBody.Seek(0, io.SeekStart) 859 if len(code) != 0 { 860 errorCode = restjson.SanitizeErrorCode(code) 861 } 862 if len(message) != 0 { 863 errorMessage = message 864 } 865 866 switch { 867 case strings.EqualFold("ConcurrentModificationException", errorCode): 868 return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody) 869 870 case strings.EqualFold("IncompatibleImageException", errorCode): 871 return awsAwsjson11_deserializeErrorIncompatibleImageException(response, errorBody) 872 873 case strings.EqualFold("InvalidAccountStatusException", errorCode): 874 return awsAwsjson11_deserializeErrorInvalidAccountStatusException(response, errorBody) 875 876 case strings.EqualFold("InvalidParameterCombinationException", errorCode): 877 return awsAwsjson11_deserializeErrorInvalidParameterCombinationException(response, errorBody) 878 879 case strings.EqualFold("InvalidRoleException", errorCode): 880 return awsAwsjson11_deserializeErrorInvalidRoleException(response, errorBody) 881 882 case strings.EqualFold("LimitExceededException", errorCode): 883 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 884 885 case strings.EqualFold("OperationNotPermittedException", errorCode): 886 return awsAwsjson11_deserializeErrorOperationNotPermittedException(response, errorBody) 887 888 case strings.EqualFold("RequestLimitExceededException", errorCode): 889 return awsAwsjson11_deserializeErrorRequestLimitExceededException(response, errorBody) 890 891 case strings.EqualFold("ResourceAlreadyExistsException", errorCode): 892 return awsAwsjson11_deserializeErrorResourceAlreadyExistsException(response, errorBody) 893 894 case strings.EqualFold("ResourceNotAvailableException", errorCode): 895 return awsAwsjson11_deserializeErrorResourceNotAvailableException(response, errorBody) 896 897 case strings.EqualFold("ResourceNotFoundException", errorCode): 898 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 899 900 default: 901 genericError := &smithy.GenericAPIError{ 902 Code: errorCode, 903 Message: errorMessage, 904 } 905 return genericError 906 907 } 908} 909 910type awsAwsjson11_deserializeOpCreateImageBuilderStreamingURL struct { 911} 912 913func (*awsAwsjson11_deserializeOpCreateImageBuilderStreamingURL) ID() string { 914 return "OperationDeserializer" 915} 916 917func (m *awsAwsjson11_deserializeOpCreateImageBuilderStreamingURL) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 918 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 919) { 920 out, metadata, err = next.HandleDeserialize(ctx, in) 921 if err != nil { 922 return out, metadata, err 923 } 924 925 response, ok := out.RawResponse.(*smithyhttp.Response) 926 if !ok { 927 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 928 } 929 930 if response.StatusCode < 200 || response.StatusCode >= 300 { 931 return out, metadata, awsAwsjson11_deserializeOpErrorCreateImageBuilderStreamingURL(response, &metadata) 932 } 933 output := &CreateImageBuilderStreamingURLOutput{} 934 out.Result = output 935 936 var buff [1024]byte 937 ringBuffer := smithyio.NewRingBuffer(buff[:]) 938 939 body := io.TeeReader(response.Body, ringBuffer) 940 decoder := json.NewDecoder(body) 941 decoder.UseNumber() 942 var shape interface{} 943 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 944 var snapshot bytes.Buffer 945 io.Copy(&snapshot, ringBuffer) 946 err = &smithy.DeserializationError{ 947 Err: fmt.Errorf("failed to decode response body, %w", err), 948 Snapshot: snapshot.Bytes(), 949 } 950 return out, metadata, err 951 } 952 953 err = awsAwsjson11_deserializeOpDocumentCreateImageBuilderStreamingURLOutput(&output, shape) 954 if err != nil { 955 var snapshot bytes.Buffer 956 io.Copy(&snapshot, ringBuffer) 957 err = &smithy.DeserializationError{ 958 Err: fmt.Errorf("failed to decode response body, %w", err), 959 Snapshot: snapshot.Bytes(), 960 } 961 return out, metadata, err 962 } 963 964 return out, metadata, err 965} 966 967func awsAwsjson11_deserializeOpErrorCreateImageBuilderStreamingURL(response *smithyhttp.Response, metadata *middleware.Metadata) error { 968 var errorBuffer bytes.Buffer 969 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 970 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 971 } 972 errorBody := bytes.NewReader(errorBuffer.Bytes()) 973 974 errorCode := "UnknownError" 975 errorMessage := errorCode 976 977 code := response.Header.Get("X-Amzn-ErrorType") 978 if len(code) != 0 { 979 errorCode = restjson.SanitizeErrorCode(code) 980 } 981 982 var buff [1024]byte 983 ringBuffer := smithyio.NewRingBuffer(buff[:]) 984 985 body := io.TeeReader(errorBody, ringBuffer) 986 decoder := json.NewDecoder(body) 987 decoder.UseNumber() 988 code, message, err := restjson.GetErrorInfo(decoder) 989 if err != nil { 990 var snapshot bytes.Buffer 991 io.Copy(&snapshot, ringBuffer) 992 err = &smithy.DeserializationError{ 993 Err: fmt.Errorf("failed to decode response body, %w", err), 994 Snapshot: snapshot.Bytes(), 995 } 996 return err 997 } 998 999 errorBody.Seek(0, io.SeekStart) 1000 if len(code) != 0 { 1001 errorCode = restjson.SanitizeErrorCode(code) 1002 } 1003 if len(message) != 0 { 1004 errorMessage = message 1005 } 1006 1007 switch { 1008 case strings.EqualFold("OperationNotPermittedException", errorCode): 1009 return awsAwsjson11_deserializeErrorOperationNotPermittedException(response, errorBody) 1010 1011 case strings.EqualFold("ResourceNotFoundException", errorCode): 1012 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 1013 1014 default: 1015 genericError := &smithy.GenericAPIError{ 1016 Code: errorCode, 1017 Message: errorMessage, 1018 } 1019 return genericError 1020 1021 } 1022} 1023 1024type awsAwsjson11_deserializeOpCreateStack struct { 1025} 1026 1027func (*awsAwsjson11_deserializeOpCreateStack) ID() string { 1028 return "OperationDeserializer" 1029} 1030 1031func (m *awsAwsjson11_deserializeOpCreateStack) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1032 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1033) { 1034 out, metadata, err = next.HandleDeserialize(ctx, in) 1035 if err != nil { 1036 return out, metadata, err 1037 } 1038 1039 response, ok := out.RawResponse.(*smithyhttp.Response) 1040 if !ok { 1041 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1042 } 1043 1044 if response.StatusCode < 200 || response.StatusCode >= 300 { 1045 return out, metadata, awsAwsjson11_deserializeOpErrorCreateStack(response, &metadata) 1046 } 1047 output := &CreateStackOutput{} 1048 out.Result = output 1049 1050 var buff [1024]byte 1051 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1052 1053 body := io.TeeReader(response.Body, ringBuffer) 1054 decoder := json.NewDecoder(body) 1055 decoder.UseNumber() 1056 var shape interface{} 1057 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1058 var snapshot bytes.Buffer 1059 io.Copy(&snapshot, ringBuffer) 1060 err = &smithy.DeserializationError{ 1061 Err: fmt.Errorf("failed to decode response body, %w", err), 1062 Snapshot: snapshot.Bytes(), 1063 } 1064 return out, metadata, err 1065 } 1066 1067 err = awsAwsjson11_deserializeOpDocumentCreateStackOutput(&output, shape) 1068 if err != nil { 1069 var snapshot bytes.Buffer 1070 io.Copy(&snapshot, ringBuffer) 1071 err = &smithy.DeserializationError{ 1072 Err: fmt.Errorf("failed to decode response body, %w", err), 1073 Snapshot: snapshot.Bytes(), 1074 } 1075 return out, metadata, err 1076 } 1077 1078 return out, metadata, err 1079} 1080 1081func awsAwsjson11_deserializeOpErrorCreateStack(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1082 var errorBuffer bytes.Buffer 1083 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1084 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1085 } 1086 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1087 1088 errorCode := "UnknownError" 1089 errorMessage := errorCode 1090 1091 code := response.Header.Get("X-Amzn-ErrorType") 1092 if len(code) != 0 { 1093 errorCode = restjson.SanitizeErrorCode(code) 1094 } 1095 1096 var buff [1024]byte 1097 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1098 1099 body := io.TeeReader(errorBody, ringBuffer) 1100 decoder := json.NewDecoder(body) 1101 decoder.UseNumber() 1102 code, message, err := restjson.GetErrorInfo(decoder) 1103 if err != nil { 1104 var snapshot bytes.Buffer 1105 io.Copy(&snapshot, ringBuffer) 1106 err = &smithy.DeserializationError{ 1107 Err: fmt.Errorf("failed to decode response body, %w", err), 1108 Snapshot: snapshot.Bytes(), 1109 } 1110 return err 1111 } 1112 1113 errorBody.Seek(0, io.SeekStart) 1114 if len(code) != 0 { 1115 errorCode = restjson.SanitizeErrorCode(code) 1116 } 1117 if len(message) != 0 { 1118 errorMessage = message 1119 } 1120 1121 switch { 1122 case strings.EqualFold("ConcurrentModificationException", errorCode): 1123 return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody) 1124 1125 case strings.EqualFold("InvalidAccountStatusException", errorCode): 1126 return awsAwsjson11_deserializeErrorInvalidAccountStatusException(response, errorBody) 1127 1128 case strings.EqualFold("InvalidParameterCombinationException", errorCode): 1129 return awsAwsjson11_deserializeErrorInvalidParameterCombinationException(response, errorBody) 1130 1131 case strings.EqualFold("InvalidRoleException", errorCode): 1132 return awsAwsjson11_deserializeErrorInvalidRoleException(response, errorBody) 1133 1134 case strings.EqualFold("LimitExceededException", errorCode): 1135 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 1136 1137 case strings.EqualFold("ResourceAlreadyExistsException", errorCode): 1138 return awsAwsjson11_deserializeErrorResourceAlreadyExistsException(response, errorBody) 1139 1140 case strings.EqualFold("ResourceNotFoundException", errorCode): 1141 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 1142 1143 default: 1144 genericError := &smithy.GenericAPIError{ 1145 Code: errorCode, 1146 Message: errorMessage, 1147 } 1148 return genericError 1149 1150 } 1151} 1152 1153type awsAwsjson11_deserializeOpCreateStreamingURL struct { 1154} 1155 1156func (*awsAwsjson11_deserializeOpCreateStreamingURL) ID() string { 1157 return "OperationDeserializer" 1158} 1159 1160func (m *awsAwsjson11_deserializeOpCreateStreamingURL) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1161 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1162) { 1163 out, metadata, err = next.HandleDeserialize(ctx, in) 1164 if err != nil { 1165 return out, metadata, err 1166 } 1167 1168 response, ok := out.RawResponse.(*smithyhttp.Response) 1169 if !ok { 1170 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1171 } 1172 1173 if response.StatusCode < 200 || response.StatusCode >= 300 { 1174 return out, metadata, awsAwsjson11_deserializeOpErrorCreateStreamingURL(response, &metadata) 1175 } 1176 output := &CreateStreamingURLOutput{} 1177 out.Result = output 1178 1179 var buff [1024]byte 1180 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1181 1182 body := io.TeeReader(response.Body, ringBuffer) 1183 decoder := json.NewDecoder(body) 1184 decoder.UseNumber() 1185 var shape interface{} 1186 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1187 var snapshot bytes.Buffer 1188 io.Copy(&snapshot, ringBuffer) 1189 err = &smithy.DeserializationError{ 1190 Err: fmt.Errorf("failed to decode response body, %w", err), 1191 Snapshot: snapshot.Bytes(), 1192 } 1193 return out, metadata, err 1194 } 1195 1196 err = awsAwsjson11_deserializeOpDocumentCreateStreamingURLOutput(&output, shape) 1197 if err != nil { 1198 var snapshot bytes.Buffer 1199 io.Copy(&snapshot, ringBuffer) 1200 err = &smithy.DeserializationError{ 1201 Err: fmt.Errorf("failed to decode response body, %w", err), 1202 Snapshot: snapshot.Bytes(), 1203 } 1204 return out, metadata, err 1205 } 1206 1207 return out, metadata, err 1208} 1209 1210func awsAwsjson11_deserializeOpErrorCreateStreamingURL(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1211 var errorBuffer bytes.Buffer 1212 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1213 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1214 } 1215 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1216 1217 errorCode := "UnknownError" 1218 errorMessage := errorCode 1219 1220 code := response.Header.Get("X-Amzn-ErrorType") 1221 if len(code) != 0 { 1222 errorCode = restjson.SanitizeErrorCode(code) 1223 } 1224 1225 var buff [1024]byte 1226 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1227 1228 body := io.TeeReader(errorBody, ringBuffer) 1229 decoder := json.NewDecoder(body) 1230 decoder.UseNumber() 1231 code, message, err := restjson.GetErrorInfo(decoder) 1232 if err != nil { 1233 var snapshot bytes.Buffer 1234 io.Copy(&snapshot, ringBuffer) 1235 err = &smithy.DeserializationError{ 1236 Err: fmt.Errorf("failed to decode response body, %w", err), 1237 Snapshot: snapshot.Bytes(), 1238 } 1239 return err 1240 } 1241 1242 errorBody.Seek(0, io.SeekStart) 1243 if len(code) != 0 { 1244 errorCode = restjson.SanitizeErrorCode(code) 1245 } 1246 if len(message) != 0 { 1247 errorMessage = message 1248 } 1249 1250 switch { 1251 case strings.EqualFold("InvalidParameterCombinationException", errorCode): 1252 return awsAwsjson11_deserializeErrorInvalidParameterCombinationException(response, errorBody) 1253 1254 case strings.EqualFold("OperationNotPermittedException", errorCode): 1255 return awsAwsjson11_deserializeErrorOperationNotPermittedException(response, errorBody) 1256 1257 case strings.EqualFold("ResourceNotAvailableException", errorCode): 1258 return awsAwsjson11_deserializeErrorResourceNotAvailableException(response, errorBody) 1259 1260 case strings.EqualFold("ResourceNotFoundException", errorCode): 1261 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 1262 1263 default: 1264 genericError := &smithy.GenericAPIError{ 1265 Code: errorCode, 1266 Message: errorMessage, 1267 } 1268 return genericError 1269 1270 } 1271} 1272 1273type awsAwsjson11_deserializeOpCreateUpdatedImage struct { 1274} 1275 1276func (*awsAwsjson11_deserializeOpCreateUpdatedImage) ID() string { 1277 return "OperationDeserializer" 1278} 1279 1280func (m *awsAwsjson11_deserializeOpCreateUpdatedImage) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1281 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1282) { 1283 out, metadata, err = next.HandleDeserialize(ctx, in) 1284 if err != nil { 1285 return out, metadata, err 1286 } 1287 1288 response, ok := out.RawResponse.(*smithyhttp.Response) 1289 if !ok { 1290 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1291 } 1292 1293 if response.StatusCode < 200 || response.StatusCode >= 300 { 1294 return out, metadata, awsAwsjson11_deserializeOpErrorCreateUpdatedImage(response, &metadata) 1295 } 1296 output := &CreateUpdatedImageOutput{} 1297 out.Result = output 1298 1299 var buff [1024]byte 1300 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1301 1302 body := io.TeeReader(response.Body, ringBuffer) 1303 decoder := json.NewDecoder(body) 1304 decoder.UseNumber() 1305 var shape interface{} 1306 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1307 var snapshot bytes.Buffer 1308 io.Copy(&snapshot, ringBuffer) 1309 err = &smithy.DeserializationError{ 1310 Err: fmt.Errorf("failed to decode response body, %w", err), 1311 Snapshot: snapshot.Bytes(), 1312 } 1313 return out, metadata, err 1314 } 1315 1316 err = awsAwsjson11_deserializeOpDocumentCreateUpdatedImageOutput(&output, shape) 1317 if err != nil { 1318 var snapshot bytes.Buffer 1319 io.Copy(&snapshot, ringBuffer) 1320 err = &smithy.DeserializationError{ 1321 Err: fmt.Errorf("failed to decode response body, %w", err), 1322 Snapshot: snapshot.Bytes(), 1323 } 1324 return out, metadata, err 1325 } 1326 1327 return out, metadata, err 1328} 1329 1330func awsAwsjson11_deserializeOpErrorCreateUpdatedImage(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1331 var errorBuffer bytes.Buffer 1332 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1333 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1334 } 1335 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1336 1337 errorCode := "UnknownError" 1338 errorMessage := errorCode 1339 1340 code := response.Header.Get("X-Amzn-ErrorType") 1341 if len(code) != 0 { 1342 errorCode = restjson.SanitizeErrorCode(code) 1343 } 1344 1345 var buff [1024]byte 1346 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1347 1348 body := io.TeeReader(errorBody, ringBuffer) 1349 decoder := json.NewDecoder(body) 1350 decoder.UseNumber() 1351 code, message, err := restjson.GetErrorInfo(decoder) 1352 if err != nil { 1353 var snapshot bytes.Buffer 1354 io.Copy(&snapshot, ringBuffer) 1355 err = &smithy.DeserializationError{ 1356 Err: fmt.Errorf("failed to decode response body, %w", err), 1357 Snapshot: snapshot.Bytes(), 1358 } 1359 return err 1360 } 1361 1362 errorBody.Seek(0, io.SeekStart) 1363 if len(code) != 0 { 1364 errorCode = restjson.SanitizeErrorCode(code) 1365 } 1366 if len(message) != 0 { 1367 errorMessage = message 1368 } 1369 1370 switch { 1371 case strings.EqualFold("ConcurrentModificationException", errorCode): 1372 return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody) 1373 1374 case strings.EqualFold("IncompatibleImageException", errorCode): 1375 return awsAwsjson11_deserializeErrorIncompatibleImageException(response, errorBody) 1376 1377 case strings.EqualFold("InvalidAccountStatusException", errorCode): 1378 return awsAwsjson11_deserializeErrorInvalidAccountStatusException(response, errorBody) 1379 1380 case strings.EqualFold("LimitExceededException", errorCode): 1381 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 1382 1383 case strings.EqualFold("OperationNotPermittedException", errorCode): 1384 return awsAwsjson11_deserializeErrorOperationNotPermittedException(response, errorBody) 1385 1386 case strings.EqualFold("ResourceAlreadyExistsException", errorCode): 1387 return awsAwsjson11_deserializeErrorResourceAlreadyExistsException(response, errorBody) 1388 1389 case strings.EqualFold("ResourceNotFoundException", errorCode): 1390 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 1391 1392 default: 1393 genericError := &smithy.GenericAPIError{ 1394 Code: errorCode, 1395 Message: errorMessage, 1396 } 1397 return genericError 1398 1399 } 1400} 1401 1402type awsAwsjson11_deserializeOpCreateUsageReportSubscription struct { 1403} 1404 1405func (*awsAwsjson11_deserializeOpCreateUsageReportSubscription) ID() string { 1406 return "OperationDeserializer" 1407} 1408 1409func (m *awsAwsjson11_deserializeOpCreateUsageReportSubscription) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1410 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1411) { 1412 out, metadata, err = next.HandleDeserialize(ctx, in) 1413 if err != nil { 1414 return out, metadata, err 1415 } 1416 1417 response, ok := out.RawResponse.(*smithyhttp.Response) 1418 if !ok { 1419 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1420 } 1421 1422 if response.StatusCode < 200 || response.StatusCode >= 300 { 1423 return out, metadata, awsAwsjson11_deserializeOpErrorCreateUsageReportSubscription(response, &metadata) 1424 } 1425 output := &CreateUsageReportSubscriptionOutput{} 1426 out.Result = output 1427 1428 var buff [1024]byte 1429 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1430 1431 body := io.TeeReader(response.Body, ringBuffer) 1432 decoder := json.NewDecoder(body) 1433 decoder.UseNumber() 1434 var shape interface{} 1435 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1436 var snapshot bytes.Buffer 1437 io.Copy(&snapshot, ringBuffer) 1438 err = &smithy.DeserializationError{ 1439 Err: fmt.Errorf("failed to decode response body, %w", err), 1440 Snapshot: snapshot.Bytes(), 1441 } 1442 return out, metadata, err 1443 } 1444 1445 err = awsAwsjson11_deserializeOpDocumentCreateUsageReportSubscriptionOutput(&output, shape) 1446 if err != nil { 1447 var snapshot bytes.Buffer 1448 io.Copy(&snapshot, ringBuffer) 1449 err = &smithy.DeserializationError{ 1450 Err: fmt.Errorf("failed to decode response body, %w", err), 1451 Snapshot: snapshot.Bytes(), 1452 } 1453 return out, metadata, err 1454 } 1455 1456 return out, metadata, err 1457} 1458 1459func awsAwsjson11_deserializeOpErrorCreateUsageReportSubscription(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1460 var errorBuffer bytes.Buffer 1461 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1462 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1463 } 1464 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1465 1466 errorCode := "UnknownError" 1467 errorMessage := errorCode 1468 1469 code := response.Header.Get("X-Amzn-ErrorType") 1470 if len(code) != 0 { 1471 errorCode = restjson.SanitizeErrorCode(code) 1472 } 1473 1474 var buff [1024]byte 1475 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1476 1477 body := io.TeeReader(errorBody, ringBuffer) 1478 decoder := json.NewDecoder(body) 1479 decoder.UseNumber() 1480 code, message, err := restjson.GetErrorInfo(decoder) 1481 if err != nil { 1482 var snapshot bytes.Buffer 1483 io.Copy(&snapshot, ringBuffer) 1484 err = &smithy.DeserializationError{ 1485 Err: fmt.Errorf("failed to decode response body, %w", err), 1486 Snapshot: snapshot.Bytes(), 1487 } 1488 return err 1489 } 1490 1491 errorBody.Seek(0, io.SeekStart) 1492 if len(code) != 0 { 1493 errorCode = restjson.SanitizeErrorCode(code) 1494 } 1495 if len(message) != 0 { 1496 errorMessage = message 1497 } 1498 1499 switch { 1500 case strings.EqualFold("InvalidAccountStatusException", errorCode): 1501 return awsAwsjson11_deserializeErrorInvalidAccountStatusException(response, errorBody) 1502 1503 case strings.EqualFold("InvalidRoleException", errorCode): 1504 return awsAwsjson11_deserializeErrorInvalidRoleException(response, errorBody) 1505 1506 case strings.EqualFold("LimitExceededException", errorCode): 1507 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 1508 1509 default: 1510 genericError := &smithy.GenericAPIError{ 1511 Code: errorCode, 1512 Message: errorMessage, 1513 } 1514 return genericError 1515 1516 } 1517} 1518 1519type awsAwsjson11_deserializeOpCreateUser struct { 1520} 1521 1522func (*awsAwsjson11_deserializeOpCreateUser) ID() string { 1523 return "OperationDeserializer" 1524} 1525 1526func (m *awsAwsjson11_deserializeOpCreateUser) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1527 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1528) { 1529 out, metadata, err = next.HandleDeserialize(ctx, in) 1530 if err != nil { 1531 return out, metadata, err 1532 } 1533 1534 response, ok := out.RawResponse.(*smithyhttp.Response) 1535 if !ok { 1536 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1537 } 1538 1539 if response.StatusCode < 200 || response.StatusCode >= 300 { 1540 return out, metadata, awsAwsjson11_deserializeOpErrorCreateUser(response, &metadata) 1541 } 1542 output := &CreateUserOutput{} 1543 out.Result = output 1544 1545 var buff [1024]byte 1546 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1547 1548 body := io.TeeReader(response.Body, ringBuffer) 1549 decoder := json.NewDecoder(body) 1550 decoder.UseNumber() 1551 var shape interface{} 1552 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1553 var snapshot bytes.Buffer 1554 io.Copy(&snapshot, ringBuffer) 1555 err = &smithy.DeserializationError{ 1556 Err: fmt.Errorf("failed to decode response body, %w", err), 1557 Snapshot: snapshot.Bytes(), 1558 } 1559 return out, metadata, err 1560 } 1561 1562 err = awsAwsjson11_deserializeOpDocumentCreateUserOutput(&output, shape) 1563 if err != nil { 1564 var snapshot bytes.Buffer 1565 io.Copy(&snapshot, ringBuffer) 1566 err = &smithy.DeserializationError{ 1567 Err: fmt.Errorf("failed to decode response body, %w", err), 1568 Snapshot: snapshot.Bytes(), 1569 } 1570 return out, metadata, err 1571 } 1572 1573 return out, metadata, err 1574} 1575 1576func awsAwsjson11_deserializeOpErrorCreateUser(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1577 var errorBuffer bytes.Buffer 1578 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1579 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1580 } 1581 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1582 1583 errorCode := "UnknownError" 1584 errorMessage := errorCode 1585 1586 code := response.Header.Get("X-Amzn-ErrorType") 1587 if len(code) != 0 { 1588 errorCode = restjson.SanitizeErrorCode(code) 1589 } 1590 1591 var buff [1024]byte 1592 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1593 1594 body := io.TeeReader(errorBody, ringBuffer) 1595 decoder := json.NewDecoder(body) 1596 decoder.UseNumber() 1597 code, message, err := restjson.GetErrorInfo(decoder) 1598 if err != nil { 1599 var snapshot bytes.Buffer 1600 io.Copy(&snapshot, ringBuffer) 1601 err = &smithy.DeserializationError{ 1602 Err: fmt.Errorf("failed to decode response body, %w", err), 1603 Snapshot: snapshot.Bytes(), 1604 } 1605 return err 1606 } 1607 1608 errorBody.Seek(0, io.SeekStart) 1609 if len(code) != 0 { 1610 errorCode = restjson.SanitizeErrorCode(code) 1611 } 1612 if len(message) != 0 { 1613 errorMessage = message 1614 } 1615 1616 switch { 1617 case strings.EqualFold("InvalidAccountStatusException", errorCode): 1618 return awsAwsjson11_deserializeErrorInvalidAccountStatusException(response, errorBody) 1619 1620 case strings.EqualFold("InvalidParameterCombinationException", errorCode): 1621 return awsAwsjson11_deserializeErrorInvalidParameterCombinationException(response, errorBody) 1622 1623 case strings.EqualFold("LimitExceededException", errorCode): 1624 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 1625 1626 case strings.EqualFold("OperationNotPermittedException", errorCode): 1627 return awsAwsjson11_deserializeErrorOperationNotPermittedException(response, errorBody) 1628 1629 case strings.EqualFold("ResourceAlreadyExistsException", errorCode): 1630 return awsAwsjson11_deserializeErrorResourceAlreadyExistsException(response, errorBody) 1631 1632 default: 1633 genericError := &smithy.GenericAPIError{ 1634 Code: errorCode, 1635 Message: errorMessage, 1636 } 1637 return genericError 1638 1639 } 1640} 1641 1642type awsAwsjson11_deserializeOpDeleteDirectoryConfig struct { 1643} 1644 1645func (*awsAwsjson11_deserializeOpDeleteDirectoryConfig) ID() string { 1646 return "OperationDeserializer" 1647} 1648 1649func (m *awsAwsjson11_deserializeOpDeleteDirectoryConfig) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1650 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1651) { 1652 out, metadata, err = next.HandleDeserialize(ctx, in) 1653 if err != nil { 1654 return out, metadata, err 1655 } 1656 1657 response, ok := out.RawResponse.(*smithyhttp.Response) 1658 if !ok { 1659 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1660 } 1661 1662 if response.StatusCode < 200 || response.StatusCode >= 300 { 1663 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteDirectoryConfig(response, &metadata) 1664 } 1665 output := &DeleteDirectoryConfigOutput{} 1666 out.Result = output 1667 1668 var buff [1024]byte 1669 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1670 1671 body := io.TeeReader(response.Body, ringBuffer) 1672 decoder := json.NewDecoder(body) 1673 decoder.UseNumber() 1674 var shape interface{} 1675 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1676 var snapshot bytes.Buffer 1677 io.Copy(&snapshot, ringBuffer) 1678 err = &smithy.DeserializationError{ 1679 Err: fmt.Errorf("failed to decode response body, %w", err), 1680 Snapshot: snapshot.Bytes(), 1681 } 1682 return out, metadata, err 1683 } 1684 1685 err = awsAwsjson11_deserializeOpDocumentDeleteDirectoryConfigOutput(&output, shape) 1686 if err != nil { 1687 var snapshot bytes.Buffer 1688 io.Copy(&snapshot, ringBuffer) 1689 err = &smithy.DeserializationError{ 1690 Err: fmt.Errorf("failed to decode response body, %w", err), 1691 Snapshot: snapshot.Bytes(), 1692 } 1693 return out, metadata, err 1694 } 1695 1696 return out, metadata, err 1697} 1698 1699func awsAwsjson11_deserializeOpErrorDeleteDirectoryConfig(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1700 var errorBuffer bytes.Buffer 1701 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1702 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1703 } 1704 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1705 1706 errorCode := "UnknownError" 1707 errorMessage := errorCode 1708 1709 code := response.Header.Get("X-Amzn-ErrorType") 1710 if len(code) != 0 { 1711 errorCode = restjson.SanitizeErrorCode(code) 1712 } 1713 1714 var buff [1024]byte 1715 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1716 1717 body := io.TeeReader(errorBody, ringBuffer) 1718 decoder := json.NewDecoder(body) 1719 decoder.UseNumber() 1720 code, message, err := restjson.GetErrorInfo(decoder) 1721 if err != nil { 1722 var snapshot bytes.Buffer 1723 io.Copy(&snapshot, ringBuffer) 1724 err = &smithy.DeserializationError{ 1725 Err: fmt.Errorf("failed to decode response body, %w", err), 1726 Snapshot: snapshot.Bytes(), 1727 } 1728 return err 1729 } 1730 1731 errorBody.Seek(0, io.SeekStart) 1732 if len(code) != 0 { 1733 errorCode = restjson.SanitizeErrorCode(code) 1734 } 1735 if len(message) != 0 { 1736 errorMessage = message 1737 } 1738 1739 switch { 1740 case strings.EqualFold("ResourceInUseException", errorCode): 1741 return awsAwsjson11_deserializeErrorResourceInUseException(response, errorBody) 1742 1743 case strings.EqualFold("ResourceNotFoundException", errorCode): 1744 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 1745 1746 default: 1747 genericError := &smithy.GenericAPIError{ 1748 Code: errorCode, 1749 Message: errorMessage, 1750 } 1751 return genericError 1752 1753 } 1754} 1755 1756type awsAwsjson11_deserializeOpDeleteFleet struct { 1757} 1758 1759func (*awsAwsjson11_deserializeOpDeleteFleet) ID() string { 1760 return "OperationDeserializer" 1761} 1762 1763func (m *awsAwsjson11_deserializeOpDeleteFleet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1764 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1765) { 1766 out, metadata, err = next.HandleDeserialize(ctx, in) 1767 if err != nil { 1768 return out, metadata, err 1769 } 1770 1771 response, ok := out.RawResponse.(*smithyhttp.Response) 1772 if !ok { 1773 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1774 } 1775 1776 if response.StatusCode < 200 || response.StatusCode >= 300 { 1777 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteFleet(response, &metadata) 1778 } 1779 output := &DeleteFleetOutput{} 1780 out.Result = output 1781 1782 var buff [1024]byte 1783 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1784 1785 body := io.TeeReader(response.Body, ringBuffer) 1786 decoder := json.NewDecoder(body) 1787 decoder.UseNumber() 1788 var shape interface{} 1789 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1790 var snapshot bytes.Buffer 1791 io.Copy(&snapshot, ringBuffer) 1792 err = &smithy.DeserializationError{ 1793 Err: fmt.Errorf("failed to decode response body, %w", err), 1794 Snapshot: snapshot.Bytes(), 1795 } 1796 return out, metadata, err 1797 } 1798 1799 err = awsAwsjson11_deserializeOpDocumentDeleteFleetOutput(&output, shape) 1800 if err != nil { 1801 var snapshot bytes.Buffer 1802 io.Copy(&snapshot, ringBuffer) 1803 err = &smithy.DeserializationError{ 1804 Err: fmt.Errorf("failed to decode response body, %w", err), 1805 Snapshot: snapshot.Bytes(), 1806 } 1807 return out, metadata, err 1808 } 1809 1810 return out, metadata, err 1811} 1812 1813func awsAwsjson11_deserializeOpErrorDeleteFleet(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1814 var errorBuffer bytes.Buffer 1815 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1816 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1817 } 1818 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1819 1820 errorCode := "UnknownError" 1821 errorMessage := errorCode 1822 1823 code := response.Header.Get("X-Amzn-ErrorType") 1824 if len(code) != 0 { 1825 errorCode = restjson.SanitizeErrorCode(code) 1826 } 1827 1828 var buff [1024]byte 1829 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1830 1831 body := io.TeeReader(errorBody, ringBuffer) 1832 decoder := json.NewDecoder(body) 1833 decoder.UseNumber() 1834 code, message, err := restjson.GetErrorInfo(decoder) 1835 if err != nil { 1836 var snapshot bytes.Buffer 1837 io.Copy(&snapshot, ringBuffer) 1838 err = &smithy.DeserializationError{ 1839 Err: fmt.Errorf("failed to decode response body, %w", err), 1840 Snapshot: snapshot.Bytes(), 1841 } 1842 return err 1843 } 1844 1845 errorBody.Seek(0, io.SeekStart) 1846 if len(code) != 0 { 1847 errorCode = restjson.SanitizeErrorCode(code) 1848 } 1849 if len(message) != 0 { 1850 errorMessage = message 1851 } 1852 1853 switch { 1854 case strings.EqualFold("ConcurrentModificationException", errorCode): 1855 return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody) 1856 1857 case strings.EqualFold("ResourceInUseException", errorCode): 1858 return awsAwsjson11_deserializeErrorResourceInUseException(response, errorBody) 1859 1860 case strings.EqualFold("ResourceNotFoundException", errorCode): 1861 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 1862 1863 default: 1864 genericError := &smithy.GenericAPIError{ 1865 Code: errorCode, 1866 Message: errorMessage, 1867 } 1868 return genericError 1869 1870 } 1871} 1872 1873type awsAwsjson11_deserializeOpDeleteImage struct { 1874} 1875 1876func (*awsAwsjson11_deserializeOpDeleteImage) ID() string { 1877 return "OperationDeserializer" 1878} 1879 1880func (m *awsAwsjson11_deserializeOpDeleteImage) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1881 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1882) { 1883 out, metadata, err = next.HandleDeserialize(ctx, in) 1884 if err != nil { 1885 return out, metadata, err 1886 } 1887 1888 response, ok := out.RawResponse.(*smithyhttp.Response) 1889 if !ok { 1890 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1891 } 1892 1893 if response.StatusCode < 200 || response.StatusCode >= 300 { 1894 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteImage(response, &metadata) 1895 } 1896 output := &DeleteImageOutput{} 1897 out.Result = output 1898 1899 var buff [1024]byte 1900 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1901 1902 body := io.TeeReader(response.Body, ringBuffer) 1903 decoder := json.NewDecoder(body) 1904 decoder.UseNumber() 1905 var shape interface{} 1906 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1907 var snapshot bytes.Buffer 1908 io.Copy(&snapshot, ringBuffer) 1909 err = &smithy.DeserializationError{ 1910 Err: fmt.Errorf("failed to decode response body, %w", err), 1911 Snapshot: snapshot.Bytes(), 1912 } 1913 return out, metadata, err 1914 } 1915 1916 err = awsAwsjson11_deserializeOpDocumentDeleteImageOutput(&output, shape) 1917 if err != nil { 1918 var snapshot bytes.Buffer 1919 io.Copy(&snapshot, ringBuffer) 1920 err = &smithy.DeserializationError{ 1921 Err: fmt.Errorf("failed to decode response body, %w", err), 1922 Snapshot: snapshot.Bytes(), 1923 } 1924 return out, metadata, err 1925 } 1926 1927 return out, metadata, err 1928} 1929 1930func awsAwsjson11_deserializeOpErrorDeleteImage(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1931 var errorBuffer bytes.Buffer 1932 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1933 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1934 } 1935 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1936 1937 errorCode := "UnknownError" 1938 errorMessage := errorCode 1939 1940 code := response.Header.Get("X-Amzn-ErrorType") 1941 if len(code) != 0 { 1942 errorCode = restjson.SanitizeErrorCode(code) 1943 } 1944 1945 var buff [1024]byte 1946 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1947 1948 body := io.TeeReader(errorBody, ringBuffer) 1949 decoder := json.NewDecoder(body) 1950 decoder.UseNumber() 1951 code, message, err := restjson.GetErrorInfo(decoder) 1952 if err != nil { 1953 var snapshot bytes.Buffer 1954 io.Copy(&snapshot, ringBuffer) 1955 err = &smithy.DeserializationError{ 1956 Err: fmt.Errorf("failed to decode response body, %w", err), 1957 Snapshot: snapshot.Bytes(), 1958 } 1959 return err 1960 } 1961 1962 errorBody.Seek(0, io.SeekStart) 1963 if len(code) != 0 { 1964 errorCode = restjson.SanitizeErrorCode(code) 1965 } 1966 if len(message) != 0 { 1967 errorMessage = message 1968 } 1969 1970 switch { 1971 case strings.EqualFold("ConcurrentModificationException", errorCode): 1972 return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody) 1973 1974 case strings.EqualFold("OperationNotPermittedException", errorCode): 1975 return awsAwsjson11_deserializeErrorOperationNotPermittedException(response, errorBody) 1976 1977 case strings.EqualFold("ResourceInUseException", errorCode): 1978 return awsAwsjson11_deserializeErrorResourceInUseException(response, errorBody) 1979 1980 case strings.EqualFold("ResourceNotFoundException", errorCode): 1981 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 1982 1983 default: 1984 genericError := &smithy.GenericAPIError{ 1985 Code: errorCode, 1986 Message: errorMessage, 1987 } 1988 return genericError 1989 1990 } 1991} 1992 1993type awsAwsjson11_deserializeOpDeleteImageBuilder struct { 1994} 1995 1996func (*awsAwsjson11_deserializeOpDeleteImageBuilder) ID() string { 1997 return "OperationDeserializer" 1998} 1999 2000func (m *awsAwsjson11_deserializeOpDeleteImageBuilder) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2001 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2002) { 2003 out, metadata, err = next.HandleDeserialize(ctx, in) 2004 if err != nil { 2005 return out, metadata, err 2006 } 2007 2008 response, ok := out.RawResponse.(*smithyhttp.Response) 2009 if !ok { 2010 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2011 } 2012 2013 if response.StatusCode < 200 || response.StatusCode >= 300 { 2014 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteImageBuilder(response, &metadata) 2015 } 2016 output := &DeleteImageBuilderOutput{} 2017 out.Result = output 2018 2019 var buff [1024]byte 2020 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2021 2022 body := io.TeeReader(response.Body, ringBuffer) 2023 decoder := json.NewDecoder(body) 2024 decoder.UseNumber() 2025 var shape interface{} 2026 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2027 var snapshot bytes.Buffer 2028 io.Copy(&snapshot, ringBuffer) 2029 err = &smithy.DeserializationError{ 2030 Err: fmt.Errorf("failed to decode response body, %w", err), 2031 Snapshot: snapshot.Bytes(), 2032 } 2033 return out, metadata, err 2034 } 2035 2036 err = awsAwsjson11_deserializeOpDocumentDeleteImageBuilderOutput(&output, shape) 2037 if err != nil { 2038 var snapshot bytes.Buffer 2039 io.Copy(&snapshot, ringBuffer) 2040 err = &smithy.DeserializationError{ 2041 Err: fmt.Errorf("failed to decode response body, %w", err), 2042 Snapshot: snapshot.Bytes(), 2043 } 2044 return out, metadata, err 2045 } 2046 2047 return out, metadata, err 2048} 2049 2050func awsAwsjson11_deserializeOpErrorDeleteImageBuilder(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2051 var errorBuffer bytes.Buffer 2052 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2053 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2054 } 2055 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2056 2057 errorCode := "UnknownError" 2058 errorMessage := errorCode 2059 2060 code := response.Header.Get("X-Amzn-ErrorType") 2061 if len(code) != 0 { 2062 errorCode = restjson.SanitizeErrorCode(code) 2063 } 2064 2065 var buff [1024]byte 2066 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2067 2068 body := io.TeeReader(errorBody, ringBuffer) 2069 decoder := json.NewDecoder(body) 2070 decoder.UseNumber() 2071 code, message, err := restjson.GetErrorInfo(decoder) 2072 if err != nil { 2073 var snapshot bytes.Buffer 2074 io.Copy(&snapshot, ringBuffer) 2075 err = &smithy.DeserializationError{ 2076 Err: fmt.Errorf("failed to decode response body, %w", err), 2077 Snapshot: snapshot.Bytes(), 2078 } 2079 return err 2080 } 2081 2082 errorBody.Seek(0, io.SeekStart) 2083 if len(code) != 0 { 2084 errorCode = restjson.SanitizeErrorCode(code) 2085 } 2086 if len(message) != 0 { 2087 errorMessage = message 2088 } 2089 2090 switch { 2091 case strings.EqualFold("ConcurrentModificationException", errorCode): 2092 return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody) 2093 2094 case strings.EqualFold("OperationNotPermittedException", errorCode): 2095 return awsAwsjson11_deserializeErrorOperationNotPermittedException(response, errorBody) 2096 2097 case strings.EqualFold("ResourceNotFoundException", errorCode): 2098 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 2099 2100 default: 2101 genericError := &smithy.GenericAPIError{ 2102 Code: errorCode, 2103 Message: errorMessage, 2104 } 2105 return genericError 2106 2107 } 2108} 2109 2110type awsAwsjson11_deserializeOpDeleteImagePermissions struct { 2111} 2112 2113func (*awsAwsjson11_deserializeOpDeleteImagePermissions) ID() string { 2114 return "OperationDeserializer" 2115} 2116 2117func (m *awsAwsjson11_deserializeOpDeleteImagePermissions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2118 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2119) { 2120 out, metadata, err = next.HandleDeserialize(ctx, in) 2121 if err != nil { 2122 return out, metadata, err 2123 } 2124 2125 response, ok := out.RawResponse.(*smithyhttp.Response) 2126 if !ok { 2127 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2128 } 2129 2130 if response.StatusCode < 200 || response.StatusCode >= 300 { 2131 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteImagePermissions(response, &metadata) 2132 } 2133 output := &DeleteImagePermissionsOutput{} 2134 out.Result = output 2135 2136 var buff [1024]byte 2137 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2138 2139 body := io.TeeReader(response.Body, ringBuffer) 2140 decoder := json.NewDecoder(body) 2141 decoder.UseNumber() 2142 var shape interface{} 2143 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2144 var snapshot bytes.Buffer 2145 io.Copy(&snapshot, ringBuffer) 2146 err = &smithy.DeserializationError{ 2147 Err: fmt.Errorf("failed to decode response body, %w", err), 2148 Snapshot: snapshot.Bytes(), 2149 } 2150 return out, metadata, err 2151 } 2152 2153 err = awsAwsjson11_deserializeOpDocumentDeleteImagePermissionsOutput(&output, shape) 2154 if err != nil { 2155 var snapshot bytes.Buffer 2156 io.Copy(&snapshot, ringBuffer) 2157 err = &smithy.DeserializationError{ 2158 Err: fmt.Errorf("failed to decode response body, %w", err), 2159 Snapshot: snapshot.Bytes(), 2160 } 2161 return out, metadata, err 2162 } 2163 2164 return out, metadata, err 2165} 2166 2167func awsAwsjson11_deserializeOpErrorDeleteImagePermissions(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2168 var errorBuffer bytes.Buffer 2169 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2170 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2171 } 2172 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2173 2174 errorCode := "UnknownError" 2175 errorMessage := errorCode 2176 2177 code := response.Header.Get("X-Amzn-ErrorType") 2178 if len(code) != 0 { 2179 errorCode = restjson.SanitizeErrorCode(code) 2180 } 2181 2182 var buff [1024]byte 2183 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2184 2185 body := io.TeeReader(errorBody, ringBuffer) 2186 decoder := json.NewDecoder(body) 2187 decoder.UseNumber() 2188 code, message, err := restjson.GetErrorInfo(decoder) 2189 if err != nil { 2190 var snapshot bytes.Buffer 2191 io.Copy(&snapshot, ringBuffer) 2192 err = &smithy.DeserializationError{ 2193 Err: fmt.Errorf("failed to decode response body, %w", err), 2194 Snapshot: snapshot.Bytes(), 2195 } 2196 return err 2197 } 2198 2199 errorBody.Seek(0, io.SeekStart) 2200 if len(code) != 0 { 2201 errorCode = restjson.SanitizeErrorCode(code) 2202 } 2203 if len(message) != 0 { 2204 errorMessage = message 2205 } 2206 2207 switch { 2208 case strings.EqualFold("ResourceNotAvailableException", errorCode): 2209 return awsAwsjson11_deserializeErrorResourceNotAvailableException(response, errorBody) 2210 2211 case strings.EqualFold("ResourceNotFoundException", errorCode): 2212 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 2213 2214 default: 2215 genericError := &smithy.GenericAPIError{ 2216 Code: errorCode, 2217 Message: errorMessage, 2218 } 2219 return genericError 2220 2221 } 2222} 2223 2224type awsAwsjson11_deserializeOpDeleteStack struct { 2225} 2226 2227func (*awsAwsjson11_deserializeOpDeleteStack) ID() string { 2228 return "OperationDeserializer" 2229} 2230 2231func (m *awsAwsjson11_deserializeOpDeleteStack) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2232 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2233) { 2234 out, metadata, err = next.HandleDeserialize(ctx, in) 2235 if err != nil { 2236 return out, metadata, err 2237 } 2238 2239 response, ok := out.RawResponse.(*smithyhttp.Response) 2240 if !ok { 2241 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2242 } 2243 2244 if response.StatusCode < 200 || response.StatusCode >= 300 { 2245 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteStack(response, &metadata) 2246 } 2247 output := &DeleteStackOutput{} 2248 out.Result = output 2249 2250 var buff [1024]byte 2251 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2252 2253 body := io.TeeReader(response.Body, ringBuffer) 2254 decoder := json.NewDecoder(body) 2255 decoder.UseNumber() 2256 var shape interface{} 2257 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2258 var snapshot bytes.Buffer 2259 io.Copy(&snapshot, ringBuffer) 2260 err = &smithy.DeserializationError{ 2261 Err: fmt.Errorf("failed to decode response body, %w", err), 2262 Snapshot: snapshot.Bytes(), 2263 } 2264 return out, metadata, err 2265 } 2266 2267 err = awsAwsjson11_deserializeOpDocumentDeleteStackOutput(&output, shape) 2268 if err != nil { 2269 var snapshot bytes.Buffer 2270 io.Copy(&snapshot, ringBuffer) 2271 err = &smithy.DeserializationError{ 2272 Err: fmt.Errorf("failed to decode response body, %w", err), 2273 Snapshot: snapshot.Bytes(), 2274 } 2275 return out, metadata, err 2276 } 2277 2278 return out, metadata, err 2279} 2280 2281func awsAwsjson11_deserializeOpErrorDeleteStack(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2282 var errorBuffer bytes.Buffer 2283 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2284 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2285 } 2286 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2287 2288 errorCode := "UnknownError" 2289 errorMessage := errorCode 2290 2291 code := response.Header.Get("X-Amzn-ErrorType") 2292 if len(code) != 0 { 2293 errorCode = restjson.SanitizeErrorCode(code) 2294 } 2295 2296 var buff [1024]byte 2297 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2298 2299 body := io.TeeReader(errorBody, ringBuffer) 2300 decoder := json.NewDecoder(body) 2301 decoder.UseNumber() 2302 code, message, err := restjson.GetErrorInfo(decoder) 2303 if err != nil { 2304 var snapshot bytes.Buffer 2305 io.Copy(&snapshot, ringBuffer) 2306 err = &smithy.DeserializationError{ 2307 Err: fmt.Errorf("failed to decode response body, %w", err), 2308 Snapshot: snapshot.Bytes(), 2309 } 2310 return err 2311 } 2312 2313 errorBody.Seek(0, io.SeekStart) 2314 if len(code) != 0 { 2315 errorCode = restjson.SanitizeErrorCode(code) 2316 } 2317 if len(message) != 0 { 2318 errorMessage = message 2319 } 2320 2321 switch { 2322 case strings.EqualFold("ConcurrentModificationException", errorCode): 2323 return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody) 2324 2325 case strings.EqualFold("ResourceInUseException", errorCode): 2326 return awsAwsjson11_deserializeErrorResourceInUseException(response, errorBody) 2327 2328 case strings.EqualFold("ResourceNotFoundException", errorCode): 2329 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 2330 2331 default: 2332 genericError := &smithy.GenericAPIError{ 2333 Code: errorCode, 2334 Message: errorMessage, 2335 } 2336 return genericError 2337 2338 } 2339} 2340 2341type awsAwsjson11_deserializeOpDeleteUsageReportSubscription struct { 2342} 2343 2344func (*awsAwsjson11_deserializeOpDeleteUsageReportSubscription) ID() string { 2345 return "OperationDeserializer" 2346} 2347 2348func (m *awsAwsjson11_deserializeOpDeleteUsageReportSubscription) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2349 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2350) { 2351 out, metadata, err = next.HandleDeserialize(ctx, in) 2352 if err != nil { 2353 return out, metadata, err 2354 } 2355 2356 response, ok := out.RawResponse.(*smithyhttp.Response) 2357 if !ok { 2358 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2359 } 2360 2361 if response.StatusCode < 200 || response.StatusCode >= 300 { 2362 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteUsageReportSubscription(response, &metadata) 2363 } 2364 output := &DeleteUsageReportSubscriptionOutput{} 2365 out.Result = output 2366 2367 var buff [1024]byte 2368 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2369 2370 body := io.TeeReader(response.Body, ringBuffer) 2371 decoder := json.NewDecoder(body) 2372 decoder.UseNumber() 2373 var shape interface{} 2374 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2375 var snapshot bytes.Buffer 2376 io.Copy(&snapshot, ringBuffer) 2377 err = &smithy.DeserializationError{ 2378 Err: fmt.Errorf("failed to decode response body, %w", err), 2379 Snapshot: snapshot.Bytes(), 2380 } 2381 return out, metadata, err 2382 } 2383 2384 err = awsAwsjson11_deserializeOpDocumentDeleteUsageReportSubscriptionOutput(&output, shape) 2385 if err != nil { 2386 var snapshot bytes.Buffer 2387 io.Copy(&snapshot, ringBuffer) 2388 err = &smithy.DeserializationError{ 2389 Err: fmt.Errorf("failed to decode response body, %w", err), 2390 Snapshot: snapshot.Bytes(), 2391 } 2392 return out, metadata, err 2393 } 2394 2395 return out, metadata, err 2396} 2397 2398func awsAwsjson11_deserializeOpErrorDeleteUsageReportSubscription(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2399 var errorBuffer bytes.Buffer 2400 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2401 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2402 } 2403 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2404 2405 errorCode := "UnknownError" 2406 errorMessage := errorCode 2407 2408 code := response.Header.Get("X-Amzn-ErrorType") 2409 if len(code) != 0 { 2410 errorCode = restjson.SanitizeErrorCode(code) 2411 } 2412 2413 var buff [1024]byte 2414 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2415 2416 body := io.TeeReader(errorBody, ringBuffer) 2417 decoder := json.NewDecoder(body) 2418 decoder.UseNumber() 2419 code, message, err := restjson.GetErrorInfo(decoder) 2420 if err != nil { 2421 var snapshot bytes.Buffer 2422 io.Copy(&snapshot, ringBuffer) 2423 err = &smithy.DeserializationError{ 2424 Err: fmt.Errorf("failed to decode response body, %w", err), 2425 Snapshot: snapshot.Bytes(), 2426 } 2427 return err 2428 } 2429 2430 errorBody.Seek(0, io.SeekStart) 2431 if len(code) != 0 { 2432 errorCode = restjson.SanitizeErrorCode(code) 2433 } 2434 if len(message) != 0 { 2435 errorMessage = message 2436 } 2437 2438 switch { 2439 case strings.EqualFold("InvalidAccountStatusException", errorCode): 2440 return awsAwsjson11_deserializeErrorInvalidAccountStatusException(response, errorBody) 2441 2442 case strings.EqualFold("ResourceNotFoundException", errorCode): 2443 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 2444 2445 default: 2446 genericError := &smithy.GenericAPIError{ 2447 Code: errorCode, 2448 Message: errorMessage, 2449 } 2450 return genericError 2451 2452 } 2453} 2454 2455type awsAwsjson11_deserializeOpDeleteUser struct { 2456} 2457 2458func (*awsAwsjson11_deserializeOpDeleteUser) ID() string { 2459 return "OperationDeserializer" 2460} 2461 2462func (m *awsAwsjson11_deserializeOpDeleteUser) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2463 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2464) { 2465 out, metadata, err = next.HandleDeserialize(ctx, in) 2466 if err != nil { 2467 return out, metadata, err 2468 } 2469 2470 response, ok := out.RawResponse.(*smithyhttp.Response) 2471 if !ok { 2472 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2473 } 2474 2475 if response.StatusCode < 200 || response.StatusCode >= 300 { 2476 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteUser(response, &metadata) 2477 } 2478 output := &DeleteUserOutput{} 2479 out.Result = output 2480 2481 var buff [1024]byte 2482 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2483 2484 body := io.TeeReader(response.Body, ringBuffer) 2485 decoder := json.NewDecoder(body) 2486 decoder.UseNumber() 2487 var shape interface{} 2488 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2489 var snapshot bytes.Buffer 2490 io.Copy(&snapshot, ringBuffer) 2491 err = &smithy.DeserializationError{ 2492 Err: fmt.Errorf("failed to decode response body, %w", err), 2493 Snapshot: snapshot.Bytes(), 2494 } 2495 return out, metadata, err 2496 } 2497 2498 err = awsAwsjson11_deserializeOpDocumentDeleteUserOutput(&output, shape) 2499 if err != nil { 2500 var snapshot bytes.Buffer 2501 io.Copy(&snapshot, ringBuffer) 2502 err = &smithy.DeserializationError{ 2503 Err: fmt.Errorf("failed to decode response body, %w", err), 2504 Snapshot: snapshot.Bytes(), 2505 } 2506 return out, metadata, err 2507 } 2508 2509 return out, metadata, err 2510} 2511 2512func awsAwsjson11_deserializeOpErrorDeleteUser(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2513 var errorBuffer bytes.Buffer 2514 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2515 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2516 } 2517 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2518 2519 errorCode := "UnknownError" 2520 errorMessage := errorCode 2521 2522 code := response.Header.Get("X-Amzn-ErrorType") 2523 if len(code) != 0 { 2524 errorCode = restjson.SanitizeErrorCode(code) 2525 } 2526 2527 var buff [1024]byte 2528 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2529 2530 body := io.TeeReader(errorBody, ringBuffer) 2531 decoder := json.NewDecoder(body) 2532 decoder.UseNumber() 2533 code, message, err := restjson.GetErrorInfo(decoder) 2534 if err != nil { 2535 var snapshot bytes.Buffer 2536 io.Copy(&snapshot, ringBuffer) 2537 err = &smithy.DeserializationError{ 2538 Err: fmt.Errorf("failed to decode response body, %w", err), 2539 Snapshot: snapshot.Bytes(), 2540 } 2541 return err 2542 } 2543 2544 errorBody.Seek(0, io.SeekStart) 2545 if len(code) != 0 { 2546 errorCode = restjson.SanitizeErrorCode(code) 2547 } 2548 if len(message) != 0 { 2549 errorMessage = message 2550 } 2551 2552 switch { 2553 case strings.EqualFold("ResourceNotFoundException", errorCode): 2554 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 2555 2556 default: 2557 genericError := &smithy.GenericAPIError{ 2558 Code: errorCode, 2559 Message: errorMessage, 2560 } 2561 return genericError 2562 2563 } 2564} 2565 2566type awsAwsjson11_deserializeOpDescribeDirectoryConfigs struct { 2567} 2568 2569func (*awsAwsjson11_deserializeOpDescribeDirectoryConfigs) ID() string { 2570 return "OperationDeserializer" 2571} 2572 2573func (m *awsAwsjson11_deserializeOpDescribeDirectoryConfigs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2574 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2575) { 2576 out, metadata, err = next.HandleDeserialize(ctx, in) 2577 if err != nil { 2578 return out, metadata, err 2579 } 2580 2581 response, ok := out.RawResponse.(*smithyhttp.Response) 2582 if !ok { 2583 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2584 } 2585 2586 if response.StatusCode < 200 || response.StatusCode >= 300 { 2587 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeDirectoryConfigs(response, &metadata) 2588 } 2589 output := &DescribeDirectoryConfigsOutput{} 2590 out.Result = output 2591 2592 var buff [1024]byte 2593 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2594 2595 body := io.TeeReader(response.Body, ringBuffer) 2596 decoder := json.NewDecoder(body) 2597 decoder.UseNumber() 2598 var shape interface{} 2599 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2600 var snapshot bytes.Buffer 2601 io.Copy(&snapshot, ringBuffer) 2602 err = &smithy.DeserializationError{ 2603 Err: fmt.Errorf("failed to decode response body, %w", err), 2604 Snapshot: snapshot.Bytes(), 2605 } 2606 return out, metadata, err 2607 } 2608 2609 err = awsAwsjson11_deserializeOpDocumentDescribeDirectoryConfigsOutput(&output, shape) 2610 if err != nil { 2611 var snapshot bytes.Buffer 2612 io.Copy(&snapshot, ringBuffer) 2613 err = &smithy.DeserializationError{ 2614 Err: fmt.Errorf("failed to decode response body, %w", err), 2615 Snapshot: snapshot.Bytes(), 2616 } 2617 return out, metadata, err 2618 } 2619 2620 return out, metadata, err 2621} 2622 2623func awsAwsjson11_deserializeOpErrorDescribeDirectoryConfigs(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2624 var errorBuffer bytes.Buffer 2625 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2626 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2627 } 2628 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2629 2630 errorCode := "UnknownError" 2631 errorMessage := errorCode 2632 2633 code := response.Header.Get("X-Amzn-ErrorType") 2634 if len(code) != 0 { 2635 errorCode = restjson.SanitizeErrorCode(code) 2636 } 2637 2638 var buff [1024]byte 2639 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2640 2641 body := io.TeeReader(errorBody, ringBuffer) 2642 decoder := json.NewDecoder(body) 2643 decoder.UseNumber() 2644 code, message, err := restjson.GetErrorInfo(decoder) 2645 if err != nil { 2646 var snapshot bytes.Buffer 2647 io.Copy(&snapshot, ringBuffer) 2648 err = &smithy.DeserializationError{ 2649 Err: fmt.Errorf("failed to decode response body, %w", err), 2650 Snapshot: snapshot.Bytes(), 2651 } 2652 return err 2653 } 2654 2655 errorBody.Seek(0, io.SeekStart) 2656 if len(code) != 0 { 2657 errorCode = restjson.SanitizeErrorCode(code) 2658 } 2659 if len(message) != 0 { 2660 errorMessage = message 2661 } 2662 2663 switch { 2664 case strings.EqualFold("ResourceNotFoundException", errorCode): 2665 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 2666 2667 default: 2668 genericError := &smithy.GenericAPIError{ 2669 Code: errorCode, 2670 Message: errorMessage, 2671 } 2672 return genericError 2673 2674 } 2675} 2676 2677type awsAwsjson11_deserializeOpDescribeFleets struct { 2678} 2679 2680func (*awsAwsjson11_deserializeOpDescribeFleets) ID() string { 2681 return "OperationDeserializer" 2682} 2683 2684func (m *awsAwsjson11_deserializeOpDescribeFleets) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2685 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2686) { 2687 out, metadata, err = next.HandleDeserialize(ctx, in) 2688 if err != nil { 2689 return out, metadata, err 2690 } 2691 2692 response, ok := out.RawResponse.(*smithyhttp.Response) 2693 if !ok { 2694 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2695 } 2696 2697 if response.StatusCode < 200 || response.StatusCode >= 300 { 2698 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeFleets(response, &metadata) 2699 } 2700 output := &DescribeFleetsOutput{} 2701 out.Result = output 2702 2703 var buff [1024]byte 2704 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2705 2706 body := io.TeeReader(response.Body, ringBuffer) 2707 decoder := json.NewDecoder(body) 2708 decoder.UseNumber() 2709 var shape interface{} 2710 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2711 var snapshot bytes.Buffer 2712 io.Copy(&snapshot, ringBuffer) 2713 err = &smithy.DeserializationError{ 2714 Err: fmt.Errorf("failed to decode response body, %w", err), 2715 Snapshot: snapshot.Bytes(), 2716 } 2717 return out, metadata, err 2718 } 2719 2720 err = awsAwsjson11_deserializeOpDocumentDescribeFleetsOutput(&output, shape) 2721 if err != nil { 2722 var snapshot bytes.Buffer 2723 io.Copy(&snapshot, ringBuffer) 2724 err = &smithy.DeserializationError{ 2725 Err: fmt.Errorf("failed to decode response body, %w", err), 2726 Snapshot: snapshot.Bytes(), 2727 } 2728 return out, metadata, err 2729 } 2730 2731 return out, metadata, err 2732} 2733 2734func awsAwsjson11_deserializeOpErrorDescribeFleets(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2735 var errorBuffer bytes.Buffer 2736 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2737 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2738 } 2739 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2740 2741 errorCode := "UnknownError" 2742 errorMessage := errorCode 2743 2744 code := response.Header.Get("X-Amzn-ErrorType") 2745 if len(code) != 0 { 2746 errorCode = restjson.SanitizeErrorCode(code) 2747 } 2748 2749 var buff [1024]byte 2750 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2751 2752 body := io.TeeReader(errorBody, ringBuffer) 2753 decoder := json.NewDecoder(body) 2754 decoder.UseNumber() 2755 code, message, err := restjson.GetErrorInfo(decoder) 2756 if err != nil { 2757 var snapshot bytes.Buffer 2758 io.Copy(&snapshot, ringBuffer) 2759 err = &smithy.DeserializationError{ 2760 Err: fmt.Errorf("failed to decode response body, %w", err), 2761 Snapshot: snapshot.Bytes(), 2762 } 2763 return err 2764 } 2765 2766 errorBody.Seek(0, io.SeekStart) 2767 if len(code) != 0 { 2768 errorCode = restjson.SanitizeErrorCode(code) 2769 } 2770 if len(message) != 0 { 2771 errorMessage = message 2772 } 2773 2774 switch { 2775 case strings.EqualFold("ResourceNotFoundException", errorCode): 2776 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 2777 2778 default: 2779 genericError := &smithy.GenericAPIError{ 2780 Code: errorCode, 2781 Message: errorMessage, 2782 } 2783 return genericError 2784 2785 } 2786} 2787 2788type awsAwsjson11_deserializeOpDescribeImageBuilders struct { 2789} 2790 2791func (*awsAwsjson11_deserializeOpDescribeImageBuilders) ID() string { 2792 return "OperationDeserializer" 2793} 2794 2795func (m *awsAwsjson11_deserializeOpDescribeImageBuilders) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2796 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2797) { 2798 out, metadata, err = next.HandleDeserialize(ctx, in) 2799 if err != nil { 2800 return out, metadata, err 2801 } 2802 2803 response, ok := out.RawResponse.(*smithyhttp.Response) 2804 if !ok { 2805 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2806 } 2807 2808 if response.StatusCode < 200 || response.StatusCode >= 300 { 2809 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeImageBuilders(response, &metadata) 2810 } 2811 output := &DescribeImageBuildersOutput{} 2812 out.Result = output 2813 2814 var buff [1024]byte 2815 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2816 2817 body := io.TeeReader(response.Body, ringBuffer) 2818 decoder := json.NewDecoder(body) 2819 decoder.UseNumber() 2820 var shape interface{} 2821 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2822 var snapshot bytes.Buffer 2823 io.Copy(&snapshot, ringBuffer) 2824 err = &smithy.DeserializationError{ 2825 Err: fmt.Errorf("failed to decode response body, %w", err), 2826 Snapshot: snapshot.Bytes(), 2827 } 2828 return out, metadata, err 2829 } 2830 2831 err = awsAwsjson11_deserializeOpDocumentDescribeImageBuildersOutput(&output, shape) 2832 if err != nil { 2833 var snapshot bytes.Buffer 2834 io.Copy(&snapshot, ringBuffer) 2835 err = &smithy.DeserializationError{ 2836 Err: fmt.Errorf("failed to decode response body, %w", err), 2837 Snapshot: snapshot.Bytes(), 2838 } 2839 return out, metadata, err 2840 } 2841 2842 return out, metadata, err 2843} 2844 2845func awsAwsjson11_deserializeOpErrorDescribeImageBuilders(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2846 var errorBuffer bytes.Buffer 2847 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2848 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2849 } 2850 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2851 2852 errorCode := "UnknownError" 2853 errorMessage := errorCode 2854 2855 code := response.Header.Get("X-Amzn-ErrorType") 2856 if len(code) != 0 { 2857 errorCode = restjson.SanitizeErrorCode(code) 2858 } 2859 2860 var buff [1024]byte 2861 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2862 2863 body := io.TeeReader(errorBody, ringBuffer) 2864 decoder := json.NewDecoder(body) 2865 decoder.UseNumber() 2866 code, message, err := restjson.GetErrorInfo(decoder) 2867 if err != nil { 2868 var snapshot bytes.Buffer 2869 io.Copy(&snapshot, ringBuffer) 2870 err = &smithy.DeserializationError{ 2871 Err: fmt.Errorf("failed to decode response body, %w", err), 2872 Snapshot: snapshot.Bytes(), 2873 } 2874 return err 2875 } 2876 2877 errorBody.Seek(0, io.SeekStart) 2878 if len(code) != 0 { 2879 errorCode = restjson.SanitizeErrorCode(code) 2880 } 2881 if len(message) != 0 { 2882 errorMessage = message 2883 } 2884 2885 switch { 2886 case strings.EqualFold("ResourceNotFoundException", errorCode): 2887 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 2888 2889 default: 2890 genericError := &smithy.GenericAPIError{ 2891 Code: errorCode, 2892 Message: errorMessage, 2893 } 2894 return genericError 2895 2896 } 2897} 2898 2899type awsAwsjson11_deserializeOpDescribeImagePermissions struct { 2900} 2901 2902func (*awsAwsjson11_deserializeOpDescribeImagePermissions) ID() string { 2903 return "OperationDeserializer" 2904} 2905 2906func (m *awsAwsjson11_deserializeOpDescribeImagePermissions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2907 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2908) { 2909 out, metadata, err = next.HandleDeserialize(ctx, in) 2910 if err != nil { 2911 return out, metadata, err 2912 } 2913 2914 response, ok := out.RawResponse.(*smithyhttp.Response) 2915 if !ok { 2916 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2917 } 2918 2919 if response.StatusCode < 200 || response.StatusCode >= 300 { 2920 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeImagePermissions(response, &metadata) 2921 } 2922 output := &DescribeImagePermissionsOutput{} 2923 out.Result = output 2924 2925 var buff [1024]byte 2926 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2927 2928 body := io.TeeReader(response.Body, ringBuffer) 2929 decoder := json.NewDecoder(body) 2930 decoder.UseNumber() 2931 var shape interface{} 2932 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2933 var snapshot bytes.Buffer 2934 io.Copy(&snapshot, ringBuffer) 2935 err = &smithy.DeserializationError{ 2936 Err: fmt.Errorf("failed to decode response body, %w", err), 2937 Snapshot: snapshot.Bytes(), 2938 } 2939 return out, metadata, err 2940 } 2941 2942 err = awsAwsjson11_deserializeOpDocumentDescribeImagePermissionsOutput(&output, shape) 2943 if err != nil { 2944 var snapshot bytes.Buffer 2945 io.Copy(&snapshot, ringBuffer) 2946 err = &smithy.DeserializationError{ 2947 Err: fmt.Errorf("failed to decode response body, %w", err), 2948 Snapshot: snapshot.Bytes(), 2949 } 2950 return out, metadata, err 2951 } 2952 2953 return out, metadata, err 2954} 2955 2956func awsAwsjson11_deserializeOpErrorDescribeImagePermissions(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2957 var errorBuffer bytes.Buffer 2958 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2959 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2960 } 2961 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2962 2963 errorCode := "UnknownError" 2964 errorMessage := errorCode 2965 2966 code := response.Header.Get("X-Amzn-ErrorType") 2967 if len(code) != 0 { 2968 errorCode = restjson.SanitizeErrorCode(code) 2969 } 2970 2971 var buff [1024]byte 2972 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2973 2974 body := io.TeeReader(errorBody, ringBuffer) 2975 decoder := json.NewDecoder(body) 2976 decoder.UseNumber() 2977 code, message, err := restjson.GetErrorInfo(decoder) 2978 if err != nil { 2979 var snapshot bytes.Buffer 2980 io.Copy(&snapshot, ringBuffer) 2981 err = &smithy.DeserializationError{ 2982 Err: fmt.Errorf("failed to decode response body, %w", err), 2983 Snapshot: snapshot.Bytes(), 2984 } 2985 return err 2986 } 2987 2988 errorBody.Seek(0, io.SeekStart) 2989 if len(code) != 0 { 2990 errorCode = restjson.SanitizeErrorCode(code) 2991 } 2992 if len(message) != 0 { 2993 errorMessage = message 2994 } 2995 2996 switch { 2997 case strings.EqualFold("ResourceNotFoundException", errorCode): 2998 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 2999 3000 default: 3001 genericError := &smithy.GenericAPIError{ 3002 Code: errorCode, 3003 Message: errorMessage, 3004 } 3005 return genericError 3006 3007 } 3008} 3009 3010type awsAwsjson11_deserializeOpDescribeImages struct { 3011} 3012 3013func (*awsAwsjson11_deserializeOpDescribeImages) ID() string { 3014 return "OperationDeserializer" 3015} 3016 3017func (m *awsAwsjson11_deserializeOpDescribeImages) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3018 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3019) { 3020 out, metadata, err = next.HandleDeserialize(ctx, in) 3021 if err != nil { 3022 return out, metadata, err 3023 } 3024 3025 response, ok := out.RawResponse.(*smithyhttp.Response) 3026 if !ok { 3027 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3028 } 3029 3030 if response.StatusCode < 200 || response.StatusCode >= 300 { 3031 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeImages(response, &metadata) 3032 } 3033 output := &DescribeImagesOutput{} 3034 out.Result = output 3035 3036 var buff [1024]byte 3037 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3038 3039 body := io.TeeReader(response.Body, ringBuffer) 3040 decoder := json.NewDecoder(body) 3041 decoder.UseNumber() 3042 var shape interface{} 3043 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3044 var snapshot bytes.Buffer 3045 io.Copy(&snapshot, ringBuffer) 3046 err = &smithy.DeserializationError{ 3047 Err: fmt.Errorf("failed to decode response body, %w", err), 3048 Snapshot: snapshot.Bytes(), 3049 } 3050 return out, metadata, err 3051 } 3052 3053 err = awsAwsjson11_deserializeOpDocumentDescribeImagesOutput(&output, shape) 3054 if err != nil { 3055 var snapshot bytes.Buffer 3056 io.Copy(&snapshot, ringBuffer) 3057 err = &smithy.DeserializationError{ 3058 Err: fmt.Errorf("failed to decode response body, %w", err), 3059 Snapshot: snapshot.Bytes(), 3060 } 3061 return out, metadata, err 3062 } 3063 3064 return out, metadata, err 3065} 3066 3067func awsAwsjson11_deserializeOpErrorDescribeImages(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3068 var errorBuffer bytes.Buffer 3069 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3070 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3071 } 3072 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3073 3074 errorCode := "UnknownError" 3075 errorMessage := errorCode 3076 3077 code := response.Header.Get("X-Amzn-ErrorType") 3078 if len(code) != 0 { 3079 errorCode = restjson.SanitizeErrorCode(code) 3080 } 3081 3082 var buff [1024]byte 3083 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3084 3085 body := io.TeeReader(errorBody, ringBuffer) 3086 decoder := json.NewDecoder(body) 3087 decoder.UseNumber() 3088 code, message, err := restjson.GetErrorInfo(decoder) 3089 if err != nil { 3090 var snapshot bytes.Buffer 3091 io.Copy(&snapshot, ringBuffer) 3092 err = &smithy.DeserializationError{ 3093 Err: fmt.Errorf("failed to decode response body, %w", err), 3094 Snapshot: snapshot.Bytes(), 3095 } 3096 return err 3097 } 3098 3099 errorBody.Seek(0, io.SeekStart) 3100 if len(code) != 0 { 3101 errorCode = restjson.SanitizeErrorCode(code) 3102 } 3103 if len(message) != 0 { 3104 errorMessage = message 3105 } 3106 3107 switch { 3108 case strings.EqualFold("InvalidParameterCombinationException", errorCode): 3109 return awsAwsjson11_deserializeErrorInvalidParameterCombinationException(response, errorBody) 3110 3111 case strings.EqualFold("ResourceNotFoundException", errorCode): 3112 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 3113 3114 default: 3115 genericError := &smithy.GenericAPIError{ 3116 Code: errorCode, 3117 Message: errorMessage, 3118 } 3119 return genericError 3120 3121 } 3122} 3123 3124type awsAwsjson11_deserializeOpDescribeSessions struct { 3125} 3126 3127func (*awsAwsjson11_deserializeOpDescribeSessions) ID() string { 3128 return "OperationDeserializer" 3129} 3130 3131func (m *awsAwsjson11_deserializeOpDescribeSessions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3132 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3133) { 3134 out, metadata, err = next.HandleDeserialize(ctx, in) 3135 if err != nil { 3136 return out, metadata, err 3137 } 3138 3139 response, ok := out.RawResponse.(*smithyhttp.Response) 3140 if !ok { 3141 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3142 } 3143 3144 if response.StatusCode < 200 || response.StatusCode >= 300 { 3145 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeSessions(response, &metadata) 3146 } 3147 output := &DescribeSessionsOutput{} 3148 out.Result = output 3149 3150 var buff [1024]byte 3151 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3152 3153 body := io.TeeReader(response.Body, ringBuffer) 3154 decoder := json.NewDecoder(body) 3155 decoder.UseNumber() 3156 var shape interface{} 3157 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3158 var snapshot bytes.Buffer 3159 io.Copy(&snapshot, ringBuffer) 3160 err = &smithy.DeserializationError{ 3161 Err: fmt.Errorf("failed to decode response body, %w", err), 3162 Snapshot: snapshot.Bytes(), 3163 } 3164 return out, metadata, err 3165 } 3166 3167 err = awsAwsjson11_deserializeOpDocumentDescribeSessionsOutput(&output, shape) 3168 if err != nil { 3169 var snapshot bytes.Buffer 3170 io.Copy(&snapshot, ringBuffer) 3171 err = &smithy.DeserializationError{ 3172 Err: fmt.Errorf("failed to decode response body, %w", err), 3173 Snapshot: snapshot.Bytes(), 3174 } 3175 return out, metadata, err 3176 } 3177 3178 return out, metadata, err 3179} 3180 3181func awsAwsjson11_deserializeOpErrorDescribeSessions(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3182 var errorBuffer bytes.Buffer 3183 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3184 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3185 } 3186 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3187 3188 errorCode := "UnknownError" 3189 errorMessage := errorCode 3190 3191 code := response.Header.Get("X-Amzn-ErrorType") 3192 if len(code) != 0 { 3193 errorCode = restjson.SanitizeErrorCode(code) 3194 } 3195 3196 var buff [1024]byte 3197 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3198 3199 body := io.TeeReader(errorBody, ringBuffer) 3200 decoder := json.NewDecoder(body) 3201 decoder.UseNumber() 3202 code, message, err := restjson.GetErrorInfo(decoder) 3203 if err != nil { 3204 var snapshot bytes.Buffer 3205 io.Copy(&snapshot, ringBuffer) 3206 err = &smithy.DeserializationError{ 3207 Err: fmt.Errorf("failed to decode response body, %w", err), 3208 Snapshot: snapshot.Bytes(), 3209 } 3210 return err 3211 } 3212 3213 errorBody.Seek(0, io.SeekStart) 3214 if len(code) != 0 { 3215 errorCode = restjson.SanitizeErrorCode(code) 3216 } 3217 if len(message) != 0 { 3218 errorMessage = message 3219 } 3220 3221 switch { 3222 case strings.EqualFold("InvalidParameterCombinationException", errorCode): 3223 return awsAwsjson11_deserializeErrorInvalidParameterCombinationException(response, errorBody) 3224 3225 default: 3226 genericError := &smithy.GenericAPIError{ 3227 Code: errorCode, 3228 Message: errorMessage, 3229 } 3230 return genericError 3231 3232 } 3233} 3234 3235type awsAwsjson11_deserializeOpDescribeStacks struct { 3236} 3237 3238func (*awsAwsjson11_deserializeOpDescribeStacks) ID() string { 3239 return "OperationDeserializer" 3240} 3241 3242func (m *awsAwsjson11_deserializeOpDescribeStacks) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3243 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3244) { 3245 out, metadata, err = next.HandleDeserialize(ctx, in) 3246 if err != nil { 3247 return out, metadata, err 3248 } 3249 3250 response, ok := out.RawResponse.(*smithyhttp.Response) 3251 if !ok { 3252 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3253 } 3254 3255 if response.StatusCode < 200 || response.StatusCode >= 300 { 3256 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeStacks(response, &metadata) 3257 } 3258 output := &DescribeStacksOutput{} 3259 out.Result = output 3260 3261 var buff [1024]byte 3262 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3263 3264 body := io.TeeReader(response.Body, ringBuffer) 3265 decoder := json.NewDecoder(body) 3266 decoder.UseNumber() 3267 var shape interface{} 3268 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3269 var snapshot bytes.Buffer 3270 io.Copy(&snapshot, ringBuffer) 3271 err = &smithy.DeserializationError{ 3272 Err: fmt.Errorf("failed to decode response body, %w", err), 3273 Snapshot: snapshot.Bytes(), 3274 } 3275 return out, metadata, err 3276 } 3277 3278 err = awsAwsjson11_deserializeOpDocumentDescribeStacksOutput(&output, shape) 3279 if err != nil { 3280 var snapshot bytes.Buffer 3281 io.Copy(&snapshot, ringBuffer) 3282 err = &smithy.DeserializationError{ 3283 Err: fmt.Errorf("failed to decode response body, %w", err), 3284 Snapshot: snapshot.Bytes(), 3285 } 3286 return out, metadata, err 3287 } 3288 3289 return out, metadata, err 3290} 3291 3292func awsAwsjson11_deserializeOpErrorDescribeStacks(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3293 var errorBuffer bytes.Buffer 3294 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3295 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3296 } 3297 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3298 3299 errorCode := "UnknownError" 3300 errorMessage := errorCode 3301 3302 code := response.Header.Get("X-Amzn-ErrorType") 3303 if len(code) != 0 { 3304 errorCode = restjson.SanitizeErrorCode(code) 3305 } 3306 3307 var buff [1024]byte 3308 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3309 3310 body := io.TeeReader(errorBody, ringBuffer) 3311 decoder := json.NewDecoder(body) 3312 decoder.UseNumber() 3313 code, message, err := restjson.GetErrorInfo(decoder) 3314 if err != nil { 3315 var snapshot bytes.Buffer 3316 io.Copy(&snapshot, ringBuffer) 3317 err = &smithy.DeserializationError{ 3318 Err: fmt.Errorf("failed to decode response body, %w", err), 3319 Snapshot: snapshot.Bytes(), 3320 } 3321 return err 3322 } 3323 3324 errorBody.Seek(0, io.SeekStart) 3325 if len(code) != 0 { 3326 errorCode = restjson.SanitizeErrorCode(code) 3327 } 3328 if len(message) != 0 { 3329 errorMessage = message 3330 } 3331 3332 switch { 3333 case strings.EqualFold("ResourceNotFoundException", errorCode): 3334 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 3335 3336 default: 3337 genericError := &smithy.GenericAPIError{ 3338 Code: errorCode, 3339 Message: errorMessage, 3340 } 3341 return genericError 3342 3343 } 3344} 3345 3346type awsAwsjson11_deserializeOpDescribeUsageReportSubscriptions struct { 3347} 3348 3349func (*awsAwsjson11_deserializeOpDescribeUsageReportSubscriptions) ID() string { 3350 return "OperationDeserializer" 3351} 3352 3353func (m *awsAwsjson11_deserializeOpDescribeUsageReportSubscriptions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3354 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3355) { 3356 out, metadata, err = next.HandleDeserialize(ctx, in) 3357 if err != nil { 3358 return out, metadata, err 3359 } 3360 3361 response, ok := out.RawResponse.(*smithyhttp.Response) 3362 if !ok { 3363 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3364 } 3365 3366 if response.StatusCode < 200 || response.StatusCode >= 300 { 3367 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeUsageReportSubscriptions(response, &metadata) 3368 } 3369 output := &DescribeUsageReportSubscriptionsOutput{} 3370 out.Result = output 3371 3372 var buff [1024]byte 3373 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3374 3375 body := io.TeeReader(response.Body, ringBuffer) 3376 decoder := json.NewDecoder(body) 3377 decoder.UseNumber() 3378 var shape interface{} 3379 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3380 var snapshot bytes.Buffer 3381 io.Copy(&snapshot, ringBuffer) 3382 err = &smithy.DeserializationError{ 3383 Err: fmt.Errorf("failed to decode response body, %w", err), 3384 Snapshot: snapshot.Bytes(), 3385 } 3386 return out, metadata, err 3387 } 3388 3389 err = awsAwsjson11_deserializeOpDocumentDescribeUsageReportSubscriptionsOutput(&output, shape) 3390 if err != nil { 3391 var snapshot bytes.Buffer 3392 io.Copy(&snapshot, ringBuffer) 3393 err = &smithy.DeserializationError{ 3394 Err: fmt.Errorf("failed to decode response body, %w", err), 3395 Snapshot: snapshot.Bytes(), 3396 } 3397 return out, metadata, err 3398 } 3399 3400 return out, metadata, err 3401} 3402 3403func awsAwsjson11_deserializeOpErrorDescribeUsageReportSubscriptions(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3404 var errorBuffer bytes.Buffer 3405 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3406 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3407 } 3408 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3409 3410 errorCode := "UnknownError" 3411 errorMessage := errorCode 3412 3413 code := response.Header.Get("X-Amzn-ErrorType") 3414 if len(code) != 0 { 3415 errorCode = restjson.SanitizeErrorCode(code) 3416 } 3417 3418 var buff [1024]byte 3419 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3420 3421 body := io.TeeReader(errorBody, ringBuffer) 3422 decoder := json.NewDecoder(body) 3423 decoder.UseNumber() 3424 code, message, err := restjson.GetErrorInfo(decoder) 3425 if err != nil { 3426 var snapshot bytes.Buffer 3427 io.Copy(&snapshot, ringBuffer) 3428 err = &smithy.DeserializationError{ 3429 Err: fmt.Errorf("failed to decode response body, %w", err), 3430 Snapshot: snapshot.Bytes(), 3431 } 3432 return err 3433 } 3434 3435 errorBody.Seek(0, io.SeekStart) 3436 if len(code) != 0 { 3437 errorCode = restjson.SanitizeErrorCode(code) 3438 } 3439 if len(message) != 0 { 3440 errorMessage = message 3441 } 3442 3443 switch { 3444 case strings.EqualFold("InvalidAccountStatusException", errorCode): 3445 return awsAwsjson11_deserializeErrorInvalidAccountStatusException(response, errorBody) 3446 3447 case strings.EqualFold("ResourceNotFoundException", errorCode): 3448 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 3449 3450 default: 3451 genericError := &smithy.GenericAPIError{ 3452 Code: errorCode, 3453 Message: errorMessage, 3454 } 3455 return genericError 3456 3457 } 3458} 3459 3460type awsAwsjson11_deserializeOpDescribeUsers struct { 3461} 3462 3463func (*awsAwsjson11_deserializeOpDescribeUsers) ID() string { 3464 return "OperationDeserializer" 3465} 3466 3467func (m *awsAwsjson11_deserializeOpDescribeUsers) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3468 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3469) { 3470 out, metadata, err = next.HandleDeserialize(ctx, in) 3471 if err != nil { 3472 return out, metadata, err 3473 } 3474 3475 response, ok := out.RawResponse.(*smithyhttp.Response) 3476 if !ok { 3477 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3478 } 3479 3480 if response.StatusCode < 200 || response.StatusCode >= 300 { 3481 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeUsers(response, &metadata) 3482 } 3483 output := &DescribeUsersOutput{} 3484 out.Result = output 3485 3486 var buff [1024]byte 3487 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3488 3489 body := io.TeeReader(response.Body, ringBuffer) 3490 decoder := json.NewDecoder(body) 3491 decoder.UseNumber() 3492 var shape interface{} 3493 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3494 var snapshot bytes.Buffer 3495 io.Copy(&snapshot, ringBuffer) 3496 err = &smithy.DeserializationError{ 3497 Err: fmt.Errorf("failed to decode response body, %w", err), 3498 Snapshot: snapshot.Bytes(), 3499 } 3500 return out, metadata, err 3501 } 3502 3503 err = awsAwsjson11_deserializeOpDocumentDescribeUsersOutput(&output, shape) 3504 if err != nil { 3505 var snapshot bytes.Buffer 3506 io.Copy(&snapshot, ringBuffer) 3507 err = &smithy.DeserializationError{ 3508 Err: fmt.Errorf("failed to decode response body, %w", err), 3509 Snapshot: snapshot.Bytes(), 3510 } 3511 return out, metadata, err 3512 } 3513 3514 return out, metadata, err 3515} 3516 3517func awsAwsjson11_deserializeOpErrorDescribeUsers(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3518 var errorBuffer bytes.Buffer 3519 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3520 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3521 } 3522 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3523 3524 errorCode := "UnknownError" 3525 errorMessage := errorCode 3526 3527 code := response.Header.Get("X-Amzn-ErrorType") 3528 if len(code) != 0 { 3529 errorCode = restjson.SanitizeErrorCode(code) 3530 } 3531 3532 var buff [1024]byte 3533 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3534 3535 body := io.TeeReader(errorBody, ringBuffer) 3536 decoder := json.NewDecoder(body) 3537 decoder.UseNumber() 3538 code, message, err := restjson.GetErrorInfo(decoder) 3539 if err != nil { 3540 var snapshot bytes.Buffer 3541 io.Copy(&snapshot, ringBuffer) 3542 err = &smithy.DeserializationError{ 3543 Err: fmt.Errorf("failed to decode response body, %w", err), 3544 Snapshot: snapshot.Bytes(), 3545 } 3546 return err 3547 } 3548 3549 errorBody.Seek(0, io.SeekStart) 3550 if len(code) != 0 { 3551 errorCode = restjson.SanitizeErrorCode(code) 3552 } 3553 if len(message) != 0 { 3554 errorMessage = message 3555 } 3556 3557 switch { 3558 case strings.EqualFold("InvalidParameterCombinationException", errorCode): 3559 return awsAwsjson11_deserializeErrorInvalidParameterCombinationException(response, errorBody) 3560 3561 case strings.EqualFold("ResourceNotFoundException", errorCode): 3562 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 3563 3564 default: 3565 genericError := &smithy.GenericAPIError{ 3566 Code: errorCode, 3567 Message: errorMessage, 3568 } 3569 return genericError 3570 3571 } 3572} 3573 3574type awsAwsjson11_deserializeOpDescribeUserStackAssociations struct { 3575} 3576 3577func (*awsAwsjson11_deserializeOpDescribeUserStackAssociations) ID() string { 3578 return "OperationDeserializer" 3579} 3580 3581func (m *awsAwsjson11_deserializeOpDescribeUserStackAssociations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3582 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3583) { 3584 out, metadata, err = next.HandleDeserialize(ctx, in) 3585 if err != nil { 3586 return out, metadata, err 3587 } 3588 3589 response, ok := out.RawResponse.(*smithyhttp.Response) 3590 if !ok { 3591 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3592 } 3593 3594 if response.StatusCode < 200 || response.StatusCode >= 300 { 3595 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeUserStackAssociations(response, &metadata) 3596 } 3597 output := &DescribeUserStackAssociationsOutput{} 3598 out.Result = output 3599 3600 var buff [1024]byte 3601 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3602 3603 body := io.TeeReader(response.Body, ringBuffer) 3604 decoder := json.NewDecoder(body) 3605 decoder.UseNumber() 3606 var shape interface{} 3607 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3608 var snapshot bytes.Buffer 3609 io.Copy(&snapshot, ringBuffer) 3610 err = &smithy.DeserializationError{ 3611 Err: fmt.Errorf("failed to decode response body, %w", err), 3612 Snapshot: snapshot.Bytes(), 3613 } 3614 return out, metadata, err 3615 } 3616 3617 err = awsAwsjson11_deserializeOpDocumentDescribeUserStackAssociationsOutput(&output, shape) 3618 if err != nil { 3619 var snapshot bytes.Buffer 3620 io.Copy(&snapshot, ringBuffer) 3621 err = &smithy.DeserializationError{ 3622 Err: fmt.Errorf("failed to decode response body, %w", err), 3623 Snapshot: snapshot.Bytes(), 3624 } 3625 return out, metadata, err 3626 } 3627 3628 return out, metadata, err 3629} 3630 3631func awsAwsjson11_deserializeOpErrorDescribeUserStackAssociations(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3632 var errorBuffer bytes.Buffer 3633 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3634 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3635 } 3636 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3637 3638 errorCode := "UnknownError" 3639 errorMessage := errorCode 3640 3641 code := response.Header.Get("X-Amzn-ErrorType") 3642 if len(code) != 0 { 3643 errorCode = restjson.SanitizeErrorCode(code) 3644 } 3645 3646 var buff [1024]byte 3647 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3648 3649 body := io.TeeReader(errorBody, ringBuffer) 3650 decoder := json.NewDecoder(body) 3651 decoder.UseNumber() 3652 code, message, err := restjson.GetErrorInfo(decoder) 3653 if err != nil { 3654 var snapshot bytes.Buffer 3655 io.Copy(&snapshot, ringBuffer) 3656 err = &smithy.DeserializationError{ 3657 Err: fmt.Errorf("failed to decode response body, %w", err), 3658 Snapshot: snapshot.Bytes(), 3659 } 3660 return err 3661 } 3662 3663 errorBody.Seek(0, io.SeekStart) 3664 if len(code) != 0 { 3665 errorCode = restjson.SanitizeErrorCode(code) 3666 } 3667 if len(message) != 0 { 3668 errorMessage = message 3669 } 3670 3671 switch { 3672 case strings.EqualFold("InvalidParameterCombinationException", errorCode): 3673 return awsAwsjson11_deserializeErrorInvalidParameterCombinationException(response, errorBody) 3674 3675 case strings.EqualFold("OperationNotPermittedException", errorCode): 3676 return awsAwsjson11_deserializeErrorOperationNotPermittedException(response, errorBody) 3677 3678 default: 3679 genericError := &smithy.GenericAPIError{ 3680 Code: errorCode, 3681 Message: errorMessage, 3682 } 3683 return genericError 3684 3685 } 3686} 3687 3688type awsAwsjson11_deserializeOpDisableUser struct { 3689} 3690 3691func (*awsAwsjson11_deserializeOpDisableUser) ID() string { 3692 return "OperationDeserializer" 3693} 3694 3695func (m *awsAwsjson11_deserializeOpDisableUser) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3696 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3697) { 3698 out, metadata, err = next.HandleDeserialize(ctx, in) 3699 if err != nil { 3700 return out, metadata, err 3701 } 3702 3703 response, ok := out.RawResponse.(*smithyhttp.Response) 3704 if !ok { 3705 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3706 } 3707 3708 if response.StatusCode < 200 || response.StatusCode >= 300 { 3709 return out, metadata, awsAwsjson11_deserializeOpErrorDisableUser(response, &metadata) 3710 } 3711 output := &DisableUserOutput{} 3712 out.Result = output 3713 3714 var buff [1024]byte 3715 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3716 3717 body := io.TeeReader(response.Body, ringBuffer) 3718 decoder := json.NewDecoder(body) 3719 decoder.UseNumber() 3720 var shape interface{} 3721 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3722 var snapshot bytes.Buffer 3723 io.Copy(&snapshot, ringBuffer) 3724 err = &smithy.DeserializationError{ 3725 Err: fmt.Errorf("failed to decode response body, %w", err), 3726 Snapshot: snapshot.Bytes(), 3727 } 3728 return out, metadata, err 3729 } 3730 3731 err = awsAwsjson11_deserializeOpDocumentDisableUserOutput(&output, shape) 3732 if err != nil { 3733 var snapshot bytes.Buffer 3734 io.Copy(&snapshot, ringBuffer) 3735 err = &smithy.DeserializationError{ 3736 Err: fmt.Errorf("failed to decode response body, %w", err), 3737 Snapshot: snapshot.Bytes(), 3738 } 3739 return out, metadata, err 3740 } 3741 3742 return out, metadata, err 3743} 3744 3745func awsAwsjson11_deserializeOpErrorDisableUser(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3746 var errorBuffer bytes.Buffer 3747 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3748 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3749 } 3750 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3751 3752 errorCode := "UnknownError" 3753 errorMessage := errorCode 3754 3755 code := response.Header.Get("X-Amzn-ErrorType") 3756 if len(code) != 0 { 3757 errorCode = restjson.SanitizeErrorCode(code) 3758 } 3759 3760 var buff [1024]byte 3761 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3762 3763 body := io.TeeReader(errorBody, ringBuffer) 3764 decoder := json.NewDecoder(body) 3765 decoder.UseNumber() 3766 code, message, err := restjson.GetErrorInfo(decoder) 3767 if err != nil { 3768 var snapshot bytes.Buffer 3769 io.Copy(&snapshot, ringBuffer) 3770 err = &smithy.DeserializationError{ 3771 Err: fmt.Errorf("failed to decode response body, %w", err), 3772 Snapshot: snapshot.Bytes(), 3773 } 3774 return err 3775 } 3776 3777 errorBody.Seek(0, io.SeekStart) 3778 if len(code) != 0 { 3779 errorCode = restjson.SanitizeErrorCode(code) 3780 } 3781 if len(message) != 0 { 3782 errorMessage = message 3783 } 3784 3785 switch { 3786 case strings.EqualFold("ResourceNotFoundException", errorCode): 3787 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 3788 3789 default: 3790 genericError := &smithy.GenericAPIError{ 3791 Code: errorCode, 3792 Message: errorMessage, 3793 } 3794 return genericError 3795 3796 } 3797} 3798 3799type awsAwsjson11_deserializeOpDisassociateFleet struct { 3800} 3801 3802func (*awsAwsjson11_deserializeOpDisassociateFleet) ID() string { 3803 return "OperationDeserializer" 3804} 3805 3806func (m *awsAwsjson11_deserializeOpDisassociateFleet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3807 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3808) { 3809 out, metadata, err = next.HandleDeserialize(ctx, in) 3810 if err != nil { 3811 return out, metadata, err 3812 } 3813 3814 response, ok := out.RawResponse.(*smithyhttp.Response) 3815 if !ok { 3816 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3817 } 3818 3819 if response.StatusCode < 200 || response.StatusCode >= 300 { 3820 return out, metadata, awsAwsjson11_deserializeOpErrorDisassociateFleet(response, &metadata) 3821 } 3822 output := &DisassociateFleetOutput{} 3823 out.Result = output 3824 3825 var buff [1024]byte 3826 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3827 3828 body := io.TeeReader(response.Body, ringBuffer) 3829 decoder := json.NewDecoder(body) 3830 decoder.UseNumber() 3831 var shape interface{} 3832 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3833 var snapshot bytes.Buffer 3834 io.Copy(&snapshot, ringBuffer) 3835 err = &smithy.DeserializationError{ 3836 Err: fmt.Errorf("failed to decode response body, %w", err), 3837 Snapshot: snapshot.Bytes(), 3838 } 3839 return out, metadata, err 3840 } 3841 3842 err = awsAwsjson11_deserializeOpDocumentDisassociateFleetOutput(&output, shape) 3843 if err != nil { 3844 var snapshot bytes.Buffer 3845 io.Copy(&snapshot, ringBuffer) 3846 err = &smithy.DeserializationError{ 3847 Err: fmt.Errorf("failed to decode response body, %w", err), 3848 Snapshot: snapshot.Bytes(), 3849 } 3850 return out, metadata, err 3851 } 3852 3853 return out, metadata, err 3854} 3855 3856func awsAwsjson11_deserializeOpErrorDisassociateFleet(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3857 var errorBuffer bytes.Buffer 3858 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3859 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3860 } 3861 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3862 3863 errorCode := "UnknownError" 3864 errorMessage := errorCode 3865 3866 code := response.Header.Get("X-Amzn-ErrorType") 3867 if len(code) != 0 { 3868 errorCode = restjson.SanitizeErrorCode(code) 3869 } 3870 3871 var buff [1024]byte 3872 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3873 3874 body := io.TeeReader(errorBody, ringBuffer) 3875 decoder := json.NewDecoder(body) 3876 decoder.UseNumber() 3877 code, message, err := restjson.GetErrorInfo(decoder) 3878 if err != nil { 3879 var snapshot bytes.Buffer 3880 io.Copy(&snapshot, ringBuffer) 3881 err = &smithy.DeserializationError{ 3882 Err: fmt.Errorf("failed to decode response body, %w", err), 3883 Snapshot: snapshot.Bytes(), 3884 } 3885 return err 3886 } 3887 3888 errorBody.Seek(0, io.SeekStart) 3889 if len(code) != 0 { 3890 errorCode = restjson.SanitizeErrorCode(code) 3891 } 3892 if len(message) != 0 { 3893 errorMessage = message 3894 } 3895 3896 switch { 3897 case strings.EqualFold("ConcurrentModificationException", errorCode): 3898 return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody) 3899 3900 case strings.EqualFold("OperationNotPermittedException", errorCode): 3901 return awsAwsjson11_deserializeErrorOperationNotPermittedException(response, errorBody) 3902 3903 case strings.EqualFold("ResourceInUseException", errorCode): 3904 return awsAwsjson11_deserializeErrorResourceInUseException(response, errorBody) 3905 3906 case strings.EqualFold("ResourceNotFoundException", errorCode): 3907 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 3908 3909 default: 3910 genericError := &smithy.GenericAPIError{ 3911 Code: errorCode, 3912 Message: errorMessage, 3913 } 3914 return genericError 3915 3916 } 3917} 3918 3919type awsAwsjson11_deserializeOpEnableUser struct { 3920} 3921 3922func (*awsAwsjson11_deserializeOpEnableUser) ID() string { 3923 return "OperationDeserializer" 3924} 3925 3926func (m *awsAwsjson11_deserializeOpEnableUser) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3927 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3928) { 3929 out, metadata, err = next.HandleDeserialize(ctx, in) 3930 if err != nil { 3931 return out, metadata, err 3932 } 3933 3934 response, ok := out.RawResponse.(*smithyhttp.Response) 3935 if !ok { 3936 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3937 } 3938 3939 if response.StatusCode < 200 || response.StatusCode >= 300 { 3940 return out, metadata, awsAwsjson11_deserializeOpErrorEnableUser(response, &metadata) 3941 } 3942 output := &EnableUserOutput{} 3943 out.Result = output 3944 3945 var buff [1024]byte 3946 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3947 3948 body := io.TeeReader(response.Body, ringBuffer) 3949 decoder := json.NewDecoder(body) 3950 decoder.UseNumber() 3951 var shape interface{} 3952 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3953 var snapshot bytes.Buffer 3954 io.Copy(&snapshot, ringBuffer) 3955 err = &smithy.DeserializationError{ 3956 Err: fmt.Errorf("failed to decode response body, %w", err), 3957 Snapshot: snapshot.Bytes(), 3958 } 3959 return out, metadata, err 3960 } 3961 3962 err = awsAwsjson11_deserializeOpDocumentEnableUserOutput(&output, shape) 3963 if err != nil { 3964 var snapshot bytes.Buffer 3965 io.Copy(&snapshot, ringBuffer) 3966 err = &smithy.DeserializationError{ 3967 Err: fmt.Errorf("failed to decode response body, %w", err), 3968 Snapshot: snapshot.Bytes(), 3969 } 3970 return out, metadata, err 3971 } 3972 3973 return out, metadata, err 3974} 3975 3976func awsAwsjson11_deserializeOpErrorEnableUser(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3977 var errorBuffer bytes.Buffer 3978 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3979 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3980 } 3981 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3982 3983 errorCode := "UnknownError" 3984 errorMessage := errorCode 3985 3986 code := response.Header.Get("X-Amzn-ErrorType") 3987 if len(code) != 0 { 3988 errorCode = restjson.SanitizeErrorCode(code) 3989 } 3990 3991 var buff [1024]byte 3992 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3993 3994 body := io.TeeReader(errorBody, ringBuffer) 3995 decoder := json.NewDecoder(body) 3996 decoder.UseNumber() 3997 code, message, err := restjson.GetErrorInfo(decoder) 3998 if err != nil { 3999 var snapshot bytes.Buffer 4000 io.Copy(&snapshot, ringBuffer) 4001 err = &smithy.DeserializationError{ 4002 Err: fmt.Errorf("failed to decode response body, %w", err), 4003 Snapshot: snapshot.Bytes(), 4004 } 4005 return err 4006 } 4007 4008 errorBody.Seek(0, io.SeekStart) 4009 if len(code) != 0 { 4010 errorCode = restjson.SanitizeErrorCode(code) 4011 } 4012 if len(message) != 0 { 4013 errorMessage = message 4014 } 4015 4016 switch { 4017 case strings.EqualFold("InvalidAccountStatusException", errorCode): 4018 return awsAwsjson11_deserializeErrorInvalidAccountStatusException(response, errorBody) 4019 4020 case strings.EqualFold("ResourceNotFoundException", errorCode): 4021 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 4022 4023 default: 4024 genericError := &smithy.GenericAPIError{ 4025 Code: errorCode, 4026 Message: errorMessage, 4027 } 4028 return genericError 4029 4030 } 4031} 4032 4033type awsAwsjson11_deserializeOpExpireSession struct { 4034} 4035 4036func (*awsAwsjson11_deserializeOpExpireSession) ID() string { 4037 return "OperationDeserializer" 4038} 4039 4040func (m *awsAwsjson11_deserializeOpExpireSession) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4041 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4042) { 4043 out, metadata, err = next.HandleDeserialize(ctx, in) 4044 if err != nil { 4045 return out, metadata, err 4046 } 4047 4048 response, ok := out.RawResponse.(*smithyhttp.Response) 4049 if !ok { 4050 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4051 } 4052 4053 if response.StatusCode < 200 || response.StatusCode >= 300 { 4054 return out, metadata, awsAwsjson11_deserializeOpErrorExpireSession(response, &metadata) 4055 } 4056 output := &ExpireSessionOutput{} 4057 out.Result = output 4058 4059 var buff [1024]byte 4060 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4061 4062 body := io.TeeReader(response.Body, ringBuffer) 4063 decoder := json.NewDecoder(body) 4064 decoder.UseNumber() 4065 var shape interface{} 4066 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4067 var snapshot bytes.Buffer 4068 io.Copy(&snapshot, ringBuffer) 4069 err = &smithy.DeserializationError{ 4070 Err: fmt.Errorf("failed to decode response body, %w", err), 4071 Snapshot: snapshot.Bytes(), 4072 } 4073 return out, metadata, err 4074 } 4075 4076 err = awsAwsjson11_deserializeOpDocumentExpireSessionOutput(&output, shape) 4077 if err != nil { 4078 var snapshot bytes.Buffer 4079 io.Copy(&snapshot, ringBuffer) 4080 err = &smithy.DeserializationError{ 4081 Err: fmt.Errorf("failed to decode response body, %w", err), 4082 Snapshot: snapshot.Bytes(), 4083 } 4084 return out, metadata, err 4085 } 4086 4087 return out, metadata, err 4088} 4089 4090func awsAwsjson11_deserializeOpErrorExpireSession(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4091 var errorBuffer bytes.Buffer 4092 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4093 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4094 } 4095 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4096 4097 errorCode := "UnknownError" 4098 errorMessage := errorCode 4099 4100 code := response.Header.Get("X-Amzn-ErrorType") 4101 if len(code) != 0 { 4102 errorCode = restjson.SanitizeErrorCode(code) 4103 } 4104 4105 var buff [1024]byte 4106 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4107 4108 body := io.TeeReader(errorBody, ringBuffer) 4109 decoder := json.NewDecoder(body) 4110 decoder.UseNumber() 4111 code, message, err := restjson.GetErrorInfo(decoder) 4112 if err != nil { 4113 var snapshot bytes.Buffer 4114 io.Copy(&snapshot, ringBuffer) 4115 err = &smithy.DeserializationError{ 4116 Err: fmt.Errorf("failed to decode response body, %w", err), 4117 Snapshot: snapshot.Bytes(), 4118 } 4119 return err 4120 } 4121 4122 errorBody.Seek(0, io.SeekStart) 4123 if len(code) != 0 { 4124 errorCode = restjson.SanitizeErrorCode(code) 4125 } 4126 if len(message) != 0 { 4127 errorMessage = message 4128 } 4129 4130 switch { 4131 default: 4132 genericError := &smithy.GenericAPIError{ 4133 Code: errorCode, 4134 Message: errorMessage, 4135 } 4136 return genericError 4137 4138 } 4139} 4140 4141type awsAwsjson11_deserializeOpListAssociatedFleets struct { 4142} 4143 4144func (*awsAwsjson11_deserializeOpListAssociatedFleets) ID() string { 4145 return "OperationDeserializer" 4146} 4147 4148func (m *awsAwsjson11_deserializeOpListAssociatedFleets) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4149 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4150) { 4151 out, metadata, err = next.HandleDeserialize(ctx, in) 4152 if err != nil { 4153 return out, metadata, err 4154 } 4155 4156 response, ok := out.RawResponse.(*smithyhttp.Response) 4157 if !ok { 4158 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4159 } 4160 4161 if response.StatusCode < 200 || response.StatusCode >= 300 { 4162 return out, metadata, awsAwsjson11_deserializeOpErrorListAssociatedFleets(response, &metadata) 4163 } 4164 output := &ListAssociatedFleetsOutput{} 4165 out.Result = output 4166 4167 var buff [1024]byte 4168 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4169 4170 body := io.TeeReader(response.Body, ringBuffer) 4171 decoder := json.NewDecoder(body) 4172 decoder.UseNumber() 4173 var shape interface{} 4174 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4175 var snapshot bytes.Buffer 4176 io.Copy(&snapshot, ringBuffer) 4177 err = &smithy.DeserializationError{ 4178 Err: fmt.Errorf("failed to decode response body, %w", err), 4179 Snapshot: snapshot.Bytes(), 4180 } 4181 return out, metadata, err 4182 } 4183 4184 err = awsAwsjson11_deserializeOpDocumentListAssociatedFleetsOutput(&output, shape) 4185 if err != nil { 4186 var snapshot bytes.Buffer 4187 io.Copy(&snapshot, ringBuffer) 4188 err = &smithy.DeserializationError{ 4189 Err: fmt.Errorf("failed to decode response body, %w", err), 4190 Snapshot: snapshot.Bytes(), 4191 } 4192 return out, metadata, err 4193 } 4194 4195 return out, metadata, err 4196} 4197 4198func awsAwsjson11_deserializeOpErrorListAssociatedFleets(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4199 var errorBuffer bytes.Buffer 4200 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4201 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4202 } 4203 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4204 4205 errorCode := "UnknownError" 4206 errorMessage := errorCode 4207 4208 code := response.Header.Get("X-Amzn-ErrorType") 4209 if len(code) != 0 { 4210 errorCode = restjson.SanitizeErrorCode(code) 4211 } 4212 4213 var buff [1024]byte 4214 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4215 4216 body := io.TeeReader(errorBody, ringBuffer) 4217 decoder := json.NewDecoder(body) 4218 decoder.UseNumber() 4219 code, message, err := restjson.GetErrorInfo(decoder) 4220 if err != nil { 4221 var snapshot bytes.Buffer 4222 io.Copy(&snapshot, ringBuffer) 4223 err = &smithy.DeserializationError{ 4224 Err: fmt.Errorf("failed to decode response body, %w", err), 4225 Snapshot: snapshot.Bytes(), 4226 } 4227 return err 4228 } 4229 4230 errorBody.Seek(0, io.SeekStart) 4231 if len(code) != 0 { 4232 errorCode = restjson.SanitizeErrorCode(code) 4233 } 4234 if len(message) != 0 { 4235 errorMessage = message 4236 } 4237 4238 switch { 4239 default: 4240 genericError := &smithy.GenericAPIError{ 4241 Code: errorCode, 4242 Message: errorMessage, 4243 } 4244 return genericError 4245 4246 } 4247} 4248 4249type awsAwsjson11_deserializeOpListAssociatedStacks struct { 4250} 4251 4252func (*awsAwsjson11_deserializeOpListAssociatedStacks) ID() string { 4253 return "OperationDeserializer" 4254} 4255 4256func (m *awsAwsjson11_deserializeOpListAssociatedStacks) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4257 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4258) { 4259 out, metadata, err = next.HandleDeserialize(ctx, in) 4260 if err != nil { 4261 return out, metadata, err 4262 } 4263 4264 response, ok := out.RawResponse.(*smithyhttp.Response) 4265 if !ok { 4266 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4267 } 4268 4269 if response.StatusCode < 200 || response.StatusCode >= 300 { 4270 return out, metadata, awsAwsjson11_deserializeOpErrorListAssociatedStacks(response, &metadata) 4271 } 4272 output := &ListAssociatedStacksOutput{} 4273 out.Result = output 4274 4275 var buff [1024]byte 4276 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4277 4278 body := io.TeeReader(response.Body, ringBuffer) 4279 decoder := json.NewDecoder(body) 4280 decoder.UseNumber() 4281 var shape interface{} 4282 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4283 var snapshot bytes.Buffer 4284 io.Copy(&snapshot, ringBuffer) 4285 err = &smithy.DeserializationError{ 4286 Err: fmt.Errorf("failed to decode response body, %w", err), 4287 Snapshot: snapshot.Bytes(), 4288 } 4289 return out, metadata, err 4290 } 4291 4292 err = awsAwsjson11_deserializeOpDocumentListAssociatedStacksOutput(&output, shape) 4293 if err != nil { 4294 var snapshot bytes.Buffer 4295 io.Copy(&snapshot, ringBuffer) 4296 err = &smithy.DeserializationError{ 4297 Err: fmt.Errorf("failed to decode response body, %w", err), 4298 Snapshot: snapshot.Bytes(), 4299 } 4300 return out, metadata, err 4301 } 4302 4303 return out, metadata, err 4304} 4305 4306func awsAwsjson11_deserializeOpErrorListAssociatedStacks(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4307 var errorBuffer bytes.Buffer 4308 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4309 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4310 } 4311 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4312 4313 errorCode := "UnknownError" 4314 errorMessage := errorCode 4315 4316 code := response.Header.Get("X-Amzn-ErrorType") 4317 if len(code) != 0 { 4318 errorCode = restjson.SanitizeErrorCode(code) 4319 } 4320 4321 var buff [1024]byte 4322 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4323 4324 body := io.TeeReader(errorBody, ringBuffer) 4325 decoder := json.NewDecoder(body) 4326 decoder.UseNumber() 4327 code, message, err := restjson.GetErrorInfo(decoder) 4328 if err != nil { 4329 var snapshot bytes.Buffer 4330 io.Copy(&snapshot, ringBuffer) 4331 err = &smithy.DeserializationError{ 4332 Err: fmt.Errorf("failed to decode response body, %w", err), 4333 Snapshot: snapshot.Bytes(), 4334 } 4335 return err 4336 } 4337 4338 errorBody.Seek(0, io.SeekStart) 4339 if len(code) != 0 { 4340 errorCode = restjson.SanitizeErrorCode(code) 4341 } 4342 if len(message) != 0 { 4343 errorMessage = message 4344 } 4345 4346 switch { 4347 default: 4348 genericError := &smithy.GenericAPIError{ 4349 Code: errorCode, 4350 Message: errorMessage, 4351 } 4352 return genericError 4353 4354 } 4355} 4356 4357type awsAwsjson11_deserializeOpListTagsForResource struct { 4358} 4359 4360func (*awsAwsjson11_deserializeOpListTagsForResource) ID() string { 4361 return "OperationDeserializer" 4362} 4363 4364func (m *awsAwsjson11_deserializeOpListTagsForResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4365 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4366) { 4367 out, metadata, err = next.HandleDeserialize(ctx, in) 4368 if err != nil { 4369 return out, metadata, err 4370 } 4371 4372 response, ok := out.RawResponse.(*smithyhttp.Response) 4373 if !ok { 4374 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4375 } 4376 4377 if response.StatusCode < 200 || response.StatusCode >= 300 { 4378 return out, metadata, awsAwsjson11_deserializeOpErrorListTagsForResource(response, &metadata) 4379 } 4380 output := &ListTagsForResourceOutput{} 4381 out.Result = output 4382 4383 var buff [1024]byte 4384 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4385 4386 body := io.TeeReader(response.Body, ringBuffer) 4387 decoder := json.NewDecoder(body) 4388 decoder.UseNumber() 4389 var shape interface{} 4390 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4391 var snapshot bytes.Buffer 4392 io.Copy(&snapshot, ringBuffer) 4393 err = &smithy.DeserializationError{ 4394 Err: fmt.Errorf("failed to decode response body, %w", err), 4395 Snapshot: snapshot.Bytes(), 4396 } 4397 return out, metadata, err 4398 } 4399 4400 err = awsAwsjson11_deserializeOpDocumentListTagsForResourceOutput(&output, shape) 4401 if err != nil { 4402 var snapshot bytes.Buffer 4403 io.Copy(&snapshot, ringBuffer) 4404 err = &smithy.DeserializationError{ 4405 Err: fmt.Errorf("failed to decode response body, %w", err), 4406 Snapshot: snapshot.Bytes(), 4407 } 4408 return out, metadata, err 4409 } 4410 4411 return out, metadata, err 4412} 4413 4414func awsAwsjson11_deserializeOpErrorListTagsForResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4415 var errorBuffer bytes.Buffer 4416 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4417 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4418 } 4419 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4420 4421 errorCode := "UnknownError" 4422 errorMessage := errorCode 4423 4424 code := response.Header.Get("X-Amzn-ErrorType") 4425 if len(code) != 0 { 4426 errorCode = restjson.SanitizeErrorCode(code) 4427 } 4428 4429 var buff [1024]byte 4430 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4431 4432 body := io.TeeReader(errorBody, ringBuffer) 4433 decoder := json.NewDecoder(body) 4434 decoder.UseNumber() 4435 code, message, err := restjson.GetErrorInfo(decoder) 4436 if err != nil { 4437 var snapshot bytes.Buffer 4438 io.Copy(&snapshot, ringBuffer) 4439 err = &smithy.DeserializationError{ 4440 Err: fmt.Errorf("failed to decode response body, %w", err), 4441 Snapshot: snapshot.Bytes(), 4442 } 4443 return err 4444 } 4445 4446 errorBody.Seek(0, io.SeekStart) 4447 if len(code) != 0 { 4448 errorCode = restjson.SanitizeErrorCode(code) 4449 } 4450 if len(message) != 0 { 4451 errorMessage = message 4452 } 4453 4454 switch { 4455 case strings.EqualFold("ResourceNotFoundException", errorCode): 4456 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 4457 4458 default: 4459 genericError := &smithy.GenericAPIError{ 4460 Code: errorCode, 4461 Message: errorMessage, 4462 } 4463 return genericError 4464 4465 } 4466} 4467 4468type awsAwsjson11_deserializeOpStartFleet struct { 4469} 4470 4471func (*awsAwsjson11_deserializeOpStartFleet) ID() string { 4472 return "OperationDeserializer" 4473} 4474 4475func (m *awsAwsjson11_deserializeOpStartFleet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4476 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4477) { 4478 out, metadata, err = next.HandleDeserialize(ctx, in) 4479 if err != nil { 4480 return out, metadata, err 4481 } 4482 4483 response, ok := out.RawResponse.(*smithyhttp.Response) 4484 if !ok { 4485 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4486 } 4487 4488 if response.StatusCode < 200 || response.StatusCode >= 300 { 4489 return out, metadata, awsAwsjson11_deserializeOpErrorStartFleet(response, &metadata) 4490 } 4491 output := &StartFleetOutput{} 4492 out.Result = output 4493 4494 var buff [1024]byte 4495 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4496 4497 body := io.TeeReader(response.Body, ringBuffer) 4498 decoder := json.NewDecoder(body) 4499 decoder.UseNumber() 4500 var shape interface{} 4501 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4502 var snapshot bytes.Buffer 4503 io.Copy(&snapshot, ringBuffer) 4504 err = &smithy.DeserializationError{ 4505 Err: fmt.Errorf("failed to decode response body, %w", err), 4506 Snapshot: snapshot.Bytes(), 4507 } 4508 return out, metadata, err 4509 } 4510 4511 err = awsAwsjson11_deserializeOpDocumentStartFleetOutput(&output, shape) 4512 if err != nil { 4513 var snapshot bytes.Buffer 4514 io.Copy(&snapshot, ringBuffer) 4515 err = &smithy.DeserializationError{ 4516 Err: fmt.Errorf("failed to decode response body, %w", err), 4517 Snapshot: snapshot.Bytes(), 4518 } 4519 return out, metadata, err 4520 } 4521 4522 return out, metadata, err 4523} 4524 4525func awsAwsjson11_deserializeOpErrorStartFleet(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4526 var errorBuffer bytes.Buffer 4527 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4528 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4529 } 4530 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4531 4532 errorCode := "UnknownError" 4533 errorMessage := errorCode 4534 4535 code := response.Header.Get("X-Amzn-ErrorType") 4536 if len(code) != 0 { 4537 errorCode = restjson.SanitizeErrorCode(code) 4538 } 4539 4540 var buff [1024]byte 4541 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4542 4543 body := io.TeeReader(errorBody, ringBuffer) 4544 decoder := json.NewDecoder(body) 4545 decoder.UseNumber() 4546 code, message, err := restjson.GetErrorInfo(decoder) 4547 if err != nil { 4548 var snapshot bytes.Buffer 4549 io.Copy(&snapshot, ringBuffer) 4550 err = &smithy.DeserializationError{ 4551 Err: fmt.Errorf("failed to decode response body, %w", err), 4552 Snapshot: snapshot.Bytes(), 4553 } 4554 return err 4555 } 4556 4557 errorBody.Seek(0, io.SeekStart) 4558 if len(code) != 0 { 4559 errorCode = restjson.SanitizeErrorCode(code) 4560 } 4561 if len(message) != 0 { 4562 errorMessage = message 4563 } 4564 4565 switch { 4566 case strings.EqualFold("ConcurrentModificationException", errorCode): 4567 return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody) 4568 4569 case strings.EqualFold("InvalidAccountStatusException", errorCode): 4570 return awsAwsjson11_deserializeErrorInvalidAccountStatusException(response, errorBody) 4571 4572 case strings.EqualFold("InvalidRoleException", errorCode): 4573 return awsAwsjson11_deserializeErrorInvalidRoleException(response, errorBody) 4574 4575 case strings.EqualFold("LimitExceededException", errorCode): 4576 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 4577 4578 case strings.EqualFold("OperationNotPermittedException", errorCode): 4579 return awsAwsjson11_deserializeErrorOperationNotPermittedException(response, errorBody) 4580 4581 case strings.EqualFold("RequestLimitExceededException", errorCode): 4582 return awsAwsjson11_deserializeErrorRequestLimitExceededException(response, errorBody) 4583 4584 case strings.EqualFold("ResourceNotAvailableException", errorCode): 4585 return awsAwsjson11_deserializeErrorResourceNotAvailableException(response, errorBody) 4586 4587 case strings.EqualFold("ResourceNotFoundException", errorCode): 4588 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 4589 4590 default: 4591 genericError := &smithy.GenericAPIError{ 4592 Code: errorCode, 4593 Message: errorMessage, 4594 } 4595 return genericError 4596 4597 } 4598} 4599 4600type awsAwsjson11_deserializeOpStartImageBuilder struct { 4601} 4602 4603func (*awsAwsjson11_deserializeOpStartImageBuilder) ID() string { 4604 return "OperationDeserializer" 4605} 4606 4607func (m *awsAwsjson11_deserializeOpStartImageBuilder) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4608 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4609) { 4610 out, metadata, err = next.HandleDeserialize(ctx, in) 4611 if err != nil { 4612 return out, metadata, err 4613 } 4614 4615 response, ok := out.RawResponse.(*smithyhttp.Response) 4616 if !ok { 4617 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4618 } 4619 4620 if response.StatusCode < 200 || response.StatusCode >= 300 { 4621 return out, metadata, awsAwsjson11_deserializeOpErrorStartImageBuilder(response, &metadata) 4622 } 4623 output := &StartImageBuilderOutput{} 4624 out.Result = output 4625 4626 var buff [1024]byte 4627 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4628 4629 body := io.TeeReader(response.Body, ringBuffer) 4630 decoder := json.NewDecoder(body) 4631 decoder.UseNumber() 4632 var shape interface{} 4633 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4634 var snapshot bytes.Buffer 4635 io.Copy(&snapshot, ringBuffer) 4636 err = &smithy.DeserializationError{ 4637 Err: fmt.Errorf("failed to decode response body, %w", err), 4638 Snapshot: snapshot.Bytes(), 4639 } 4640 return out, metadata, err 4641 } 4642 4643 err = awsAwsjson11_deserializeOpDocumentStartImageBuilderOutput(&output, shape) 4644 if err != nil { 4645 var snapshot bytes.Buffer 4646 io.Copy(&snapshot, ringBuffer) 4647 err = &smithy.DeserializationError{ 4648 Err: fmt.Errorf("failed to decode response body, %w", err), 4649 Snapshot: snapshot.Bytes(), 4650 } 4651 return out, metadata, err 4652 } 4653 4654 return out, metadata, err 4655} 4656 4657func awsAwsjson11_deserializeOpErrorStartImageBuilder(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4658 var errorBuffer bytes.Buffer 4659 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4660 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4661 } 4662 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4663 4664 errorCode := "UnknownError" 4665 errorMessage := errorCode 4666 4667 code := response.Header.Get("X-Amzn-ErrorType") 4668 if len(code) != 0 { 4669 errorCode = restjson.SanitizeErrorCode(code) 4670 } 4671 4672 var buff [1024]byte 4673 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4674 4675 body := io.TeeReader(errorBody, ringBuffer) 4676 decoder := json.NewDecoder(body) 4677 decoder.UseNumber() 4678 code, message, err := restjson.GetErrorInfo(decoder) 4679 if err != nil { 4680 var snapshot bytes.Buffer 4681 io.Copy(&snapshot, ringBuffer) 4682 err = &smithy.DeserializationError{ 4683 Err: fmt.Errorf("failed to decode response body, %w", err), 4684 Snapshot: snapshot.Bytes(), 4685 } 4686 return err 4687 } 4688 4689 errorBody.Seek(0, io.SeekStart) 4690 if len(code) != 0 { 4691 errorCode = restjson.SanitizeErrorCode(code) 4692 } 4693 if len(message) != 0 { 4694 errorMessage = message 4695 } 4696 4697 switch { 4698 case strings.EqualFold("ConcurrentModificationException", errorCode): 4699 return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody) 4700 4701 case strings.EqualFold("IncompatibleImageException", errorCode): 4702 return awsAwsjson11_deserializeErrorIncompatibleImageException(response, errorBody) 4703 4704 case strings.EqualFold("InvalidAccountStatusException", errorCode): 4705 return awsAwsjson11_deserializeErrorInvalidAccountStatusException(response, errorBody) 4706 4707 case strings.EqualFold("ResourceNotAvailableException", errorCode): 4708 return awsAwsjson11_deserializeErrorResourceNotAvailableException(response, errorBody) 4709 4710 case strings.EqualFold("ResourceNotFoundException", errorCode): 4711 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 4712 4713 default: 4714 genericError := &smithy.GenericAPIError{ 4715 Code: errorCode, 4716 Message: errorMessage, 4717 } 4718 return genericError 4719 4720 } 4721} 4722 4723type awsAwsjson11_deserializeOpStopFleet struct { 4724} 4725 4726func (*awsAwsjson11_deserializeOpStopFleet) ID() string { 4727 return "OperationDeserializer" 4728} 4729 4730func (m *awsAwsjson11_deserializeOpStopFleet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4731 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4732) { 4733 out, metadata, err = next.HandleDeserialize(ctx, in) 4734 if err != nil { 4735 return out, metadata, err 4736 } 4737 4738 response, ok := out.RawResponse.(*smithyhttp.Response) 4739 if !ok { 4740 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4741 } 4742 4743 if response.StatusCode < 200 || response.StatusCode >= 300 { 4744 return out, metadata, awsAwsjson11_deserializeOpErrorStopFleet(response, &metadata) 4745 } 4746 output := &StopFleetOutput{} 4747 out.Result = output 4748 4749 var buff [1024]byte 4750 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4751 4752 body := io.TeeReader(response.Body, ringBuffer) 4753 decoder := json.NewDecoder(body) 4754 decoder.UseNumber() 4755 var shape interface{} 4756 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4757 var snapshot bytes.Buffer 4758 io.Copy(&snapshot, ringBuffer) 4759 err = &smithy.DeserializationError{ 4760 Err: fmt.Errorf("failed to decode response body, %w", err), 4761 Snapshot: snapshot.Bytes(), 4762 } 4763 return out, metadata, err 4764 } 4765 4766 err = awsAwsjson11_deserializeOpDocumentStopFleetOutput(&output, shape) 4767 if err != nil { 4768 var snapshot bytes.Buffer 4769 io.Copy(&snapshot, ringBuffer) 4770 err = &smithy.DeserializationError{ 4771 Err: fmt.Errorf("failed to decode response body, %w", err), 4772 Snapshot: snapshot.Bytes(), 4773 } 4774 return out, metadata, err 4775 } 4776 4777 return out, metadata, err 4778} 4779 4780func awsAwsjson11_deserializeOpErrorStopFleet(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4781 var errorBuffer bytes.Buffer 4782 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4783 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4784 } 4785 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4786 4787 errorCode := "UnknownError" 4788 errorMessage := errorCode 4789 4790 code := response.Header.Get("X-Amzn-ErrorType") 4791 if len(code) != 0 { 4792 errorCode = restjson.SanitizeErrorCode(code) 4793 } 4794 4795 var buff [1024]byte 4796 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4797 4798 body := io.TeeReader(errorBody, ringBuffer) 4799 decoder := json.NewDecoder(body) 4800 decoder.UseNumber() 4801 code, message, err := restjson.GetErrorInfo(decoder) 4802 if err != nil { 4803 var snapshot bytes.Buffer 4804 io.Copy(&snapshot, ringBuffer) 4805 err = &smithy.DeserializationError{ 4806 Err: fmt.Errorf("failed to decode response body, %w", err), 4807 Snapshot: snapshot.Bytes(), 4808 } 4809 return err 4810 } 4811 4812 errorBody.Seek(0, io.SeekStart) 4813 if len(code) != 0 { 4814 errorCode = restjson.SanitizeErrorCode(code) 4815 } 4816 if len(message) != 0 { 4817 errorMessage = message 4818 } 4819 4820 switch { 4821 case strings.EqualFold("ConcurrentModificationException", errorCode): 4822 return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody) 4823 4824 case strings.EqualFold("ResourceNotFoundException", errorCode): 4825 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 4826 4827 default: 4828 genericError := &smithy.GenericAPIError{ 4829 Code: errorCode, 4830 Message: errorMessage, 4831 } 4832 return genericError 4833 4834 } 4835} 4836 4837type awsAwsjson11_deserializeOpStopImageBuilder struct { 4838} 4839 4840func (*awsAwsjson11_deserializeOpStopImageBuilder) ID() string { 4841 return "OperationDeserializer" 4842} 4843 4844func (m *awsAwsjson11_deserializeOpStopImageBuilder) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4845 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4846) { 4847 out, metadata, err = next.HandleDeserialize(ctx, in) 4848 if err != nil { 4849 return out, metadata, err 4850 } 4851 4852 response, ok := out.RawResponse.(*smithyhttp.Response) 4853 if !ok { 4854 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4855 } 4856 4857 if response.StatusCode < 200 || response.StatusCode >= 300 { 4858 return out, metadata, awsAwsjson11_deserializeOpErrorStopImageBuilder(response, &metadata) 4859 } 4860 output := &StopImageBuilderOutput{} 4861 out.Result = output 4862 4863 var buff [1024]byte 4864 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4865 4866 body := io.TeeReader(response.Body, ringBuffer) 4867 decoder := json.NewDecoder(body) 4868 decoder.UseNumber() 4869 var shape interface{} 4870 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4871 var snapshot bytes.Buffer 4872 io.Copy(&snapshot, ringBuffer) 4873 err = &smithy.DeserializationError{ 4874 Err: fmt.Errorf("failed to decode response body, %w", err), 4875 Snapshot: snapshot.Bytes(), 4876 } 4877 return out, metadata, err 4878 } 4879 4880 err = awsAwsjson11_deserializeOpDocumentStopImageBuilderOutput(&output, shape) 4881 if err != nil { 4882 var snapshot bytes.Buffer 4883 io.Copy(&snapshot, ringBuffer) 4884 err = &smithy.DeserializationError{ 4885 Err: fmt.Errorf("failed to decode response body, %w", err), 4886 Snapshot: snapshot.Bytes(), 4887 } 4888 return out, metadata, err 4889 } 4890 4891 return out, metadata, err 4892} 4893 4894func awsAwsjson11_deserializeOpErrorStopImageBuilder(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4895 var errorBuffer bytes.Buffer 4896 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4897 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4898 } 4899 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4900 4901 errorCode := "UnknownError" 4902 errorMessage := errorCode 4903 4904 code := response.Header.Get("X-Amzn-ErrorType") 4905 if len(code) != 0 { 4906 errorCode = restjson.SanitizeErrorCode(code) 4907 } 4908 4909 var buff [1024]byte 4910 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4911 4912 body := io.TeeReader(errorBody, ringBuffer) 4913 decoder := json.NewDecoder(body) 4914 decoder.UseNumber() 4915 code, message, err := restjson.GetErrorInfo(decoder) 4916 if err != nil { 4917 var snapshot bytes.Buffer 4918 io.Copy(&snapshot, ringBuffer) 4919 err = &smithy.DeserializationError{ 4920 Err: fmt.Errorf("failed to decode response body, %w", err), 4921 Snapshot: snapshot.Bytes(), 4922 } 4923 return err 4924 } 4925 4926 errorBody.Seek(0, io.SeekStart) 4927 if len(code) != 0 { 4928 errorCode = restjson.SanitizeErrorCode(code) 4929 } 4930 if len(message) != 0 { 4931 errorMessage = message 4932 } 4933 4934 switch { 4935 case strings.EqualFold("ConcurrentModificationException", errorCode): 4936 return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody) 4937 4938 case strings.EqualFold("OperationNotPermittedException", errorCode): 4939 return awsAwsjson11_deserializeErrorOperationNotPermittedException(response, errorBody) 4940 4941 case strings.EqualFold("ResourceNotFoundException", errorCode): 4942 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 4943 4944 default: 4945 genericError := &smithy.GenericAPIError{ 4946 Code: errorCode, 4947 Message: errorMessage, 4948 } 4949 return genericError 4950 4951 } 4952} 4953 4954type awsAwsjson11_deserializeOpTagResource struct { 4955} 4956 4957func (*awsAwsjson11_deserializeOpTagResource) ID() string { 4958 return "OperationDeserializer" 4959} 4960 4961func (m *awsAwsjson11_deserializeOpTagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4962 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4963) { 4964 out, metadata, err = next.HandleDeserialize(ctx, in) 4965 if err != nil { 4966 return out, metadata, err 4967 } 4968 4969 response, ok := out.RawResponse.(*smithyhttp.Response) 4970 if !ok { 4971 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4972 } 4973 4974 if response.StatusCode < 200 || response.StatusCode >= 300 { 4975 return out, metadata, awsAwsjson11_deserializeOpErrorTagResource(response, &metadata) 4976 } 4977 output := &TagResourceOutput{} 4978 out.Result = output 4979 4980 var buff [1024]byte 4981 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4982 4983 body := io.TeeReader(response.Body, ringBuffer) 4984 decoder := json.NewDecoder(body) 4985 decoder.UseNumber() 4986 var shape interface{} 4987 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4988 var snapshot bytes.Buffer 4989 io.Copy(&snapshot, ringBuffer) 4990 err = &smithy.DeserializationError{ 4991 Err: fmt.Errorf("failed to decode response body, %w", err), 4992 Snapshot: snapshot.Bytes(), 4993 } 4994 return out, metadata, err 4995 } 4996 4997 err = awsAwsjson11_deserializeOpDocumentTagResourceOutput(&output, shape) 4998 if err != nil { 4999 var snapshot bytes.Buffer 5000 io.Copy(&snapshot, ringBuffer) 5001 err = &smithy.DeserializationError{ 5002 Err: fmt.Errorf("failed to decode response body, %w", err), 5003 Snapshot: snapshot.Bytes(), 5004 } 5005 return out, metadata, err 5006 } 5007 5008 return out, metadata, err 5009} 5010 5011func awsAwsjson11_deserializeOpErrorTagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5012 var errorBuffer bytes.Buffer 5013 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5014 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5015 } 5016 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5017 5018 errorCode := "UnknownError" 5019 errorMessage := errorCode 5020 5021 code := response.Header.Get("X-Amzn-ErrorType") 5022 if len(code) != 0 { 5023 errorCode = restjson.SanitizeErrorCode(code) 5024 } 5025 5026 var buff [1024]byte 5027 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5028 5029 body := io.TeeReader(errorBody, ringBuffer) 5030 decoder := json.NewDecoder(body) 5031 decoder.UseNumber() 5032 code, message, err := restjson.GetErrorInfo(decoder) 5033 if err != nil { 5034 var snapshot bytes.Buffer 5035 io.Copy(&snapshot, ringBuffer) 5036 err = &smithy.DeserializationError{ 5037 Err: fmt.Errorf("failed to decode response body, %w", err), 5038 Snapshot: snapshot.Bytes(), 5039 } 5040 return err 5041 } 5042 5043 errorBody.Seek(0, io.SeekStart) 5044 if len(code) != 0 { 5045 errorCode = restjson.SanitizeErrorCode(code) 5046 } 5047 if len(message) != 0 { 5048 errorMessage = message 5049 } 5050 5051 switch { 5052 case strings.EqualFold("InvalidAccountStatusException", errorCode): 5053 return awsAwsjson11_deserializeErrorInvalidAccountStatusException(response, errorBody) 5054 5055 case strings.EqualFold("LimitExceededException", errorCode): 5056 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 5057 5058 case strings.EqualFold("ResourceNotFoundException", errorCode): 5059 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 5060 5061 default: 5062 genericError := &smithy.GenericAPIError{ 5063 Code: errorCode, 5064 Message: errorMessage, 5065 } 5066 return genericError 5067 5068 } 5069} 5070 5071type awsAwsjson11_deserializeOpUntagResource struct { 5072} 5073 5074func (*awsAwsjson11_deserializeOpUntagResource) ID() string { 5075 return "OperationDeserializer" 5076} 5077 5078func (m *awsAwsjson11_deserializeOpUntagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5079 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5080) { 5081 out, metadata, err = next.HandleDeserialize(ctx, in) 5082 if err != nil { 5083 return out, metadata, err 5084 } 5085 5086 response, ok := out.RawResponse.(*smithyhttp.Response) 5087 if !ok { 5088 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5089 } 5090 5091 if response.StatusCode < 200 || response.StatusCode >= 300 { 5092 return out, metadata, awsAwsjson11_deserializeOpErrorUntagResource(response, &metadata) 5093 } 5094 output := &UntagResourceOutput{} 5095 out.Result = output 5096 5097 var buff [1024]byte 5098 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5099 5100 body := io.TeeReader(response.Body, ringBuffer) 5101 decoder := json.NewDecoder(body) 5102 decoder.UseNumber() 5103 var shape interface{} 5104 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5105 var snapshot bytes.Buffer 5106 io.Copy(&snapshot, ringBuffer) 5107 err = &smithy.DeserializationError{ 5108 Err: fmt.Errorf("failed to decode response body, %w", err), 5109 Snapshot: snapshot.Bytes(), 5110 } 5111 return out, metadata, err 5112 } 5113 5114 err = awsAwsjson11_deserializeOpDocumentUntagResourceOutput(&output, shape) 5115 if err != nil { 5116 var snapshot bytes.Buffer 5117 io.Copy(&snapshot, ringBuffer) 5118 err = &smithy.DeserializationError{ 5119 Err: fmt.Errorf("failed to decode response body, %w", err), 5120 Snapshot: snapshot.Bytes(), 5121 } 5122 return out, metadata, err 5123 } 5124 5125 return out, metadata, err 5126} 5127 5128func awsAwsjson11_deserializeOpErrorUntagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5129 var errorBuffer bytes.Buffer 5130 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5131 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5132 } 5133 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5134 5135 errorCode := "UnknownError" 5136 errorMessage := errorCode 5137 5138 code := response.Header.Get("X-Amzn-ErrorType") 5139 if len(code) != 0 { 5140 errorCode = restjson.SanitizeErrorCode(code) 5141 } 5142 5143 var buff [1024]byte 5144 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5145 5146 body := io.TeeReader(errorBody, ringBuffer) 5147 decoder := json.NewDecoder(body) 5148 decoder.UseNumber() 5149 code, message, err := restjson.GetErrorInfo(decoder) 5150 if err != nil { 5151 var snapshot bytes.Buffer 5152 io.Copy(&snapshot, ringBuffer) 5153 err = &smithy.DeserializationError{ 5154 Err: fmt.Errorf("failed to decode response body, %w", err), 5155 Snapshot: snapshot.Bytes(), 5156 } 5157 return err 5158 } 5159 5160 errorBody.Seek(0, io.SeekStart) 5161 if len(code) != 0 { 5162 errorCode = restjson.SanitizeErrorCode(code) 5163 } 5164 if len(message) != 0 { 5165 errorMessage = message 5166 } 5167 5168 switch { 5169 case strings.EqualFold("ResourceNotFoundException", errorCode): 5170 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 5171 5172 default: 5173 genericError := &smithy.GenericAPIError{ 5174 Code: errorCode, 5175 Message: errorMessage, 5176 } 5177 return genericError 5178 5179 } 5180} 5181 5182type awsAwsjson11_deserializeOpUpdateDirectoryConfig struct { 5183} 5184 5185func (*awsAwsjson11_deserializeOpUpdateDirectoryConfig) ID() string { 5186 return "OperationDeserializer" 5187} 5188 5189func (m *awsAwsjson11_deserializeOpUpdateDirectoryConfig) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5190 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5191) { 5192 out, metadata, err = next.HandleDeserialize(ctx, in) 5193 if err != nil { 5194 return out, metadata, err 5195 } 5196 5197 response, ok := out.RawResponse.(*smithyhttp.Response) 5198 if !ok { 5199 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5200 } 5201 5202 if response.StatusCode < 200 || response.StatusCode >= 300 { 5203 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateDirectoryConfig(response, &metadata) 5204 } 5205 output := &UpdateDirectoryConfigOutput{} 5206 out.Result = output 5207 5208 var buff [1024]byte 5209 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5210 5211 body := io.TeeReader(response.Body, ringBuffer) 5212 decoder := json.NewDecoder(body) 5213 decoder.UseNumber() 5214 var shape interface{} 5215 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5216 var snapshot bytes.Buffer 5217 io.Copy(&snapshot, ringBuffer) 5218 err = &smithy.DeserializationError{ 5219 Err: fmt.Errorf("failed to decode response body, %w", err), 5220 Snapshot: snapshot.Bytes(), 5221 } 5222 return out, metadata, err 5223 } 5224 5225 err = awsAwsjson11_deserializeOpDocumentUpdateDirectoryConfigOutput(&output, shape) 5226 if err != nil { 5227 var snapshot bytes.Buffer 5228 io.Copy(&snapshot, ringBuffer) 5229 err = &smithy.DeserializationError{ 5230 Err: fmt.Errorf("failed to decode response body, %w", err), 5231 Snapshot: snapshot.Bytes(), 5232 } 5233 return out, metadata, err 5234 } 5235 5236 return out, metadata, err 5237} 5238 5239func awsAwsjson11_deserializeOpErrorUpdateDirectoryConfig(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5240 var errorBuffer bytes.Buffer 5241 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5242 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5243 } 5244 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5245 5246 errorCode := "UnknownError" 5247 errorMessage := errorCode 5248 5249 code := response.Header.Get("X-Amzn-ErrorType") 5250 if len(code) != 0 { 5251 errorCode = restjson.SanitizeErrorCode(code) 5252 } 5253 5254 var buff [1024]byte 5255 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5256 5257 body := io.TeeReader(errorBody, ringBuffer) 5258 decoder := json.NewDecoder(body) 5259 decoder.UseNumber() 5260 code, message, err := restjson.GetErrorInfo(decoder) 5261 if err != nil { 5262 var snapshot bytes.Buffer 5263 io.Copy(&snapshot, ringBuffer) 5264 err = &smithy.DeserializationError{ 5265 Err: fmt.Errorf("failed to decode response body, %w", err), 5266 Snapshot: snapshot.Bytes(), 5267 } 5268 return err 5269 } 5270 5271 errorBody.Seek(0, io.SeekStart) 5272 if len(code) != 0 { 5273 errorCode = restjson.SanitizeErrorCode(code) 5274 } 5275 if len(message) != 0 { 5276 errorMessage = message 5277 } 5278 5279 switch { 5280 case strings.EqualFold("ConcurrentModificationException", errorCode): 5281 return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody) 5282 5283 case strings.EqualFold("InvalidRoleException", errorCode): 5284 return awsAwsjson11_deserializeErrorInvalidRoleException(response, errorBody) 5285 5286 case strings.EqualFold("OperationNotPermittedException", errorCode): 5287 return awsAwsjson11_deserializeErrorOperationNotPermittedException(response, errorBody) 5288 5289 case strings.EqualFold("ResourceInUseException", errorCode): 5290 return awsAwsjson11_deserializeErrorResourceInUseException(response, errorBody) 5291 5292 case strings.EqualFold("ResourceNotFoundException", errorCode): 5293 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 5294 5295 default: 5296 genericError := &smithy.GenericAPIError{ 5297 Code: errorCode, 5298 Message: errorMessage, 5299 } 5300 return genericError 5301 5302 } 5303} 5304 5305type awsAwsjson11_deserializeOpUpdateFleet struct { 5306} 5307 5308func (*awsAwsjson11_deserializeOpUpdateFleet) ID() string { 5309 return "OperationDeserializer" 5310} 5311 5312func (m *awsAwsjson11_deserializeOpUpdateFleet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5313 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5314) { 5315 out, metadata, err = next.HandleDeserialize(ctx, in) 5316 if err != nil { 5317 return out, metadata, err 5318 } 5319 5320 response, ok := out.RawResponse.(*smithyhttp.Response) 5321 if !ok { 5322 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5323 } 5324 5325 if response.StatusCode < 200 || response.StatusCode >= 300 { 5326 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateFleet(response, &metadata) 5327 } 5328 output := &UpdateFleetOutput{} 5329 out.Result = output 5330 5331 var buff [1024]byte 5332 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5333 5334 body := io.TeeReader(response.Body, ringBuffer) 5335 decoder := json.NewDecoder(body) 5336 decoder.UseNumber() 5337 var shape interface{} 5338 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5339 var snapshot bytes.Buffer 5340 io.Copy(&snapshot, ringBuffer) 5341 err = &smithy.DeserializationError{ 5342 Err: fmt.Errorf("failed to decode response body, %w", err), 5343 Snapshot: snapshot.Bytes(), 5344 } 5345 return out, metadata, err 5346 } 5347 5348 err = awsAwsjson11_deserializeOpDocumentUpdateFleetOutput(&output, shape) 5349 if err != nil { 5350 var snapshot bytes.Buffer 5351 io.Copy(&snapshot, ringBuffer) 5352 err = &smithy.DeserializationError{ 5353 Err: fmt.Errorf("failed to decode response body, %w", err), 5354 Snapshot: snapshot.Bytes(), 5355 } 5356 return out, metadata, err 5357 } 5358 5359 return out, metadata, err 5360} 5361 5362func awsAwsjson11_deserializeOpErrorUpdateFleet(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5363 var errorBuffer bytes.Buffer 5364 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5365 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5366 } 5367 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5368 5369 errorCode := "UnknownError" 5370 errorMessage := errorCode 5371 5372 code := response.Header.Get("X-Amzn-ErrorType") 5373 if len(code) != 0 { 5374 errorCode = restjson.SanitizeErrorCode(code) 5375 } 5376 5377 var buff [1024]byte 5378 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5379 5380 body := io.TeeReader(errorBody, ringBuffer) 5381 decoder := json.NewDecoder(body) 5382 decoder.UseNumber() 5383 code, message, err := restjson.GetErrorInfo(decoder) 5384 if err != nil { 5385 var snapshot bytes.Buffer 5386 io.Copy(&snapshot, ringBuffer) 5387 err = &smithy.DeserializationError{ 5388 Err: fmt.Errorf("failed to decode response body, %w", err), 5389 Snapshot: snapshot.Bytes(), 5390 } 5391 return err 5392 } 5393 5394 errorBody.Seek(0, io.SeekStart) 5395 if len(code) != 0 { 5396 errorCode = restjson.SanitizeErrorCode(code) 5397 } 5398 if len(message) != 0 { 5399 errorMessage = message 5400 } 5401 5402 switch { 5403 case strings.EqualFold("ConcurrentModificationException", errorCode): 5404 return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody) 5405 5406 case strings.EqualFold("IncompatibleImageException", errorCode): 5407 return awsAwsjson11_deserializeErrorIncompatibleImageException(response, errorBody) 5408 5409 case strings.EqualFold("InvalidAccountStatusException", errorCode): 5410 return awsAwsjson11_deserializeErrorInvalidAccountStatusException(response, errorBody) 5411 5412 case strings.EqualFold("InvalidParameterCombinationException", errorCode): 5413 return awsAwsjson11_deserializeErrorInvalidParameterCombinationException(response, errorBody) 5414 5415 case strings.EqualFold("InvalidRoleException", errorCode): 5416 return awsAwsjson11_deserializeErrorInvalidRoleException(response, errorBody) 5417 5418 case strings.EqualFold("LimitExceededException", errorCode): 5419 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 5420 5421 case strings.EqualFold("OperationNotPermittedException", errorCode): 5422 return awsAwsjson11_deserializeErrorOperationNotPermittedException(response, errorBody) 5423 5424 case strings.EqualFold("RequestLimitExceededException", errorCode): 5425 return awsAwsjson11_deserializeErrorRequestLimitExceededException(response, errorBody) 5426 5427 case strings.EqualFold("ResourceInUseException", errorCode): 5428 return awsAwsjson11_deserializeErrorResourceInUseException(response, errorBody) 5429 5430 case strings.EqualFold("ResourceNotAvailableException", errorCode): 5431 return awsAwsjson11_deserializeErrorResourceNotAvailableException(response, errorBody) 5432 5433 case strings.EqualFold("ResourceNotFoundException", errorCode): 5434 return awsAwsjson11_deserializeErrorResourceNotFoundException(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_deserializeOpUpdateImagePermissions struct { 5447} 5448 5449func (*awsAwsjson11_deserializeOpUpdateImagePermissions) ID() string { 5450 return "OperationDeserializer" 5451} 5452 5453func (m *awsAwsjson11_deserializeOpUpdateImagePermissions) 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_deserializeOpErrorUpdateImagePermissions(response, &metadata) 5468 } 5469 output := &UpdateImagePermissionsOutput{} 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_deserializeOpDocumentUpdateImagePermissionsOutput(&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_deserializeOpErrorUpdateImagePermissions(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("LimitExceededException", errorCode): 5545 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 5546 5547 case strings.EqualFold("ResourceNotAvailableException", errorCode): 5548 return awsAwsjson11_deserializeErrorResourceNotAvailableException(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_deserializeOpUpdateStack struct { 5564} 5565 5566func (*awsAwsjson11_deserializeOpUpdateStack) ID() string { 5567 return "OperationDeserializer" 5568} 5569 5570func (m *awsAwsjson11_deserializeOpUpdateStack) 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_deserializeOpErrorUpdateStack(response, &metadata) 5585 } 5586 output := &UpdateStackOutput{} 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_deserializeOpDocumentUpdateStackOutput(&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_deserializeOpErrorUpdateStack(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("ConcurrentModificationException", errorCode): 5662 return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody) 5663 5664 case strings.EqualFold("IncompatibleImageException", errorCode): 5665 return awsAwsjson11_deserializeErrorIncompatibleImageException(response, errorBody) 5666 5667 case strings.EqualFold("InvalidAccountStatusException", errorCode): 5668 return awsAwsjson11_deserializeErrorInvalidAccountStatusException(response, errorBody) 5669 5670 case strings.EqualFold("InvalidParameterCombinationException", errorCode): 5671 return awsAwsjson11_deserializeErrorInvalidParameterCombinationException(response, errorBody) 5672 5673 case strings.EqualFold("InvalidRoleException", errorCode): 5674 return awsAwsjson11_deserializeErrorInvalidRoleException(response, errorBody) 5675 5676 case strings.EqualFold("LimitExceededException", errorCode): 5677 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 5678 5679 case strings.EqualFold("OperationNotPermittedException", errorCode): 5680 return awsAwsjson11_deserializeErrorOperationNotPermittedException(response, errorBody) 5681 5682 case strings.EqualFold("ResourceInUseException", errorCode): 5683 return awsAwsjson11_deserializeErrorResourceInUseException(response, errorBody) 5684 5685 case strings.EqualFold("ResourceNotFoundException", errorCode): 5686 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 5687 5688 default: 5689 genericError := &smithy.GenericAPIError{ 5690 Code: errorCode, 5691 Message: errorMessage, 5692 } 5693 return genericError 5694 5695 } 5696} 5697 5698func awsAwsjson11_deserializeErrorConcurrentModificationException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 5699 var buff [1024]byte 5700 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5701 5702 body := io.TeeReader(errorBody, ringBuffer) 5703 decoder := json.NewDecoder(body) 5704 decoder.UseNumber() 5705 var shape interface{} 5706 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5707 var snapshot bytes.Buffer 5708 io.Copy(&snapshot, ringBuffer) 5709 err = &smithy.DeserializationError{ 5710 Err: fmt.Errorf("failed to decode response body, %w", err), 5711 Snapshot: snapshot.Bytes(), 5712 } 5713 return err 5714 } 5715 5716 output := &types.ConcurrentModificationException{} 5717 err := awsAwsjson11_deserializeDocumentConcurrentModificationException(&output, shape) 5718 5719 if err != nil { 5720 var snapshot bytes.Buffer 5721 io.Copy(&snapshot, ringBuffer) 5722 err = &smithy.DeserializationError{ 5723 Err: fmt.Errorf("failed to decode response body, %w", err), 5724 Snapshot: snapshot.Bytes(), 5725 } 5726 return err 5727 } 5728 5729 errorBody.Seek(0, io.SeekStart) 5730 return output 5731} 5732 5733func awsAwsjson11_deserializeErrorIncompatibleImageException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 5734 var buff [1024]byte 5735 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5736 5737 body := io.TeeReader(errorBody, ringBuffer) 5738 decoder := json.NewDecoder(body) 5739 decoder.UseNumber() 5740 var shape interface{} 5741 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5742 var snapshot bytes.Buffer 5743 io.Copy(&snapshot, ringBuffer) 5744 err = &smithy.DeserializationError{ 5745 Err: fmt.Errorf("failed to decode response body, %w", err), 5746 Snapshot: snapshot.Bytes(), 5747 } 5748 return err 5749 } 5750 5751 output := &types.IncompatibleImageException{} 5752 err := awsAwsjson11_deserializeDocumentIncompatibleImageException(&output, shape) 5753 5754 if err != nil { 5755 var snapshot bytes.Buffer 5756 io.Copy(&snapshot, ringBuffer) 5757 err = &smithy.DeserializationError{ 5758 Err: fmt.Errorf("failed to decode response body, %w", err), 5759 Snapshot: snapshot.Bytes(), 5760 } 5761 return err 5762 } 5763 5764 errorBody.Seek(0, io.SeekStart) 5765 return output 5766} 5767 5768func awsAwsjson11_deserializeErrorInvalidAccountStatusException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 5769 var buff [1024]byte 5770 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5771 5772 body := io.TeeReader(errorBody, ringBuffer) 5773 decoder := json.NewDecoder(body) 5774 decoder.UseNumber() 5775 var shape interface{} 5776 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5777 var snapshot bytes.Buffer 5778 io.Copy(&snapshot, ringBuffer) 5779 err = &smithy.DeserializationError{ 5780 Err: fmt.Errorf("failed to decode response body, %w", err), 5781 Snapshot: snapshot.Bytes(), 5782 } 5783 return err 5784 } 5785 5786 output := &types.InvalidAccountStatusException{} 5787 err := awsAwsjson11_deserializeDocumentInvalidAccountStatusException(&output, shape) 5788 5789 if err != nil { 5790 var snapshot bytes.Buffer 5791 io.Copy(&snapshot, ringBuffer) 5792 err = &smithy.DeserializationError{ 5793 Err: fmt.Errorf("failed to decode response body, %w", err), 5794 Snapshot: snapshot.Bytes(), 5795 } 5796 return err 5797 } 5798 5799 errorBody.Seek(0, io.SeekStart) 5800 return output 5801} 5802 5803func awsAwsjson11_deserializeErrorInvalidParameterCombinationException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 5804 var buff [1024]byte 5805 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5806 5807 body := io.TeeReader(errorBody, ringBuffer) 5808 decoder := json.NewDecoder(body) 5809 decoder.UseNumber() 5810 var shape interface{} 5811 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5812 var snapshot bytes.Buffer 5813 io.Copy(&snapshot, ringBuffer) 5814 err = &smithy.DeserializationError{ 5815 Err: fmt.Errorf("failed to decode response body, %w", err), 5816 Snapshot: snapshot.Bytes(), 5817 } 5818 return err 5819 } 5820 5821 output := &types.InvalidParameterCombinationException{} 5822 err := awsAwsjson11_deserializeDocumentInvalidParameterCombinationException(&output, shape) 5823 5824 if err != nil { 5825 var snapshot bytes.Buffer 5826 io.Copy(&snapshot, ringBuffer) 5827 err = &smithy.DeserializationError{ 5828 Err: fmt.Errorf("failed to decode response body, %w", err), 5829 Snapshot: snapshot.Bytes(), 5830 } 5831 return err 5832 } 5833 5834 errorBody.Seek(0, io.SeekStart) 5835 return output 5836} 5837 5838func awsAwsjson11_deserializeErrorInvalidRoleException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 5839 var buff [1024]byte 5840 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5841 5842 body := io.TeeReader(errorBody, ringBuffer) 5843 decoder := json.NewDecoder(body) 5844 decoder.UseNumber() 5845 var shape interface{} 5846 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5847 var snapshot bytes.Buffer 5848 io.Copy(&snapshot, ringBuffer) 5849 err = &smithy.DeserializationError{ 5850 Err: fmt.Errorf("failed to decode response body, %w", err), 5851 Snapshot: snapshot.Bytes(), 5852 } 5853 return err 5854 } 5855 5856 output := &types.InvalidRoleException{} 5857 err := awsAwsjson11_deserializeDocumentInvalidRoleException(&output, shape) 5858 5859 if err != nil { 5860 var snapshot bytes.Buffer 5861 io.Copy(&snapshot, ringBuffer) 5862 err = &smithy.DeserializationError{ 5863 Err: fmt.Errorf("failed to decode response body, %w", err), 5864 Snapshot: snapshot.Bytes(), 5865 } 5866 return err 5867 } 5868 5869 errorBody.Seek(0, io.SeekStart) 5870 return output 5871} 5872 5873func awsAwsjson11_deserializeErrorLimitExceededException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 5874 var buff [1024]byte 5875 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5876 5877 body := io.TeeReader(errorBody, ringBuffer) 5878 decoder := json.NewDecoder(body) 5879 decoder.UseNumber() 5880 var shape interface{} 5881 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5882 var snapshot bytes.Buffer 5883 io.Copy(&snapshot, ringBuffer) 5884 err = &smithy.DeserializationError{ 5885 Err: fmt.Errorf("failed to decode response body, %w", err), 5886 Snapshot: snapshot.Bytes(), 5887 } 5888 return err 5889 } 5890 5891 output := &types.LimitExceededException{} 5892 err := awsAwsjson11_deserializeDocumentLimitExceededException(&output, shape) 5893 5894 if err != nil { 5895 var snapshot bytes.Buffer 5896 io.Copy(&snapshot, ringBuffer) 5897 err = &smithy.DeserializationError{ 5898 Err: fmt.Errorf("failed to decode response body, %w", err), 5899 Snapshot: snapshot.Bytes(), 5900 } 5901 return err 5902 } 5903 5904 errorBody.Seek(0, io.SeekStart) 5905 return output 5906} 5907 5908func awsAwsjson11_deserializeErrorOperationNotPermittedException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 5909 var buff [1024]byte 5910 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5911 5912 body := io.TeeReader(errorBody, ringBuffer) 5913 decoder := json.NewDecoder(body) 5914 decoder.UseNumber() 5915 var shape interface{} 5916 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5917 var snapshot bytes.Buffer 5918 io.Copy(&snapshot, ringBuffer) 5919 err = &smithy.DeserializationError{ 5920 Err: fmt.Errorf("failed to decode response body, %w", err), 5921 Snapshot: snapshot.Bytes(), 5922 } 5923 return err 5924 } 5925 5926 output := &types.OperationNotPermittedException{} 5927 err := awsAwsjson11_deserializeDocumentOperationNotPermittedException(&output, shape) 5928 5929 if err != nil { 5930 var snapshot bytes.Buffer 5931 io.Copy(&snapshot, ringBuffer) 5932 err = &smithy.DeserializationError{ 5933 Err: fmt.Errorf("failed to decode response body, %w", err), 5934 Snapshot: snapshot.Bytes(), 5935 } 5936 return err 5937 } 5938 5939 errorBody.Seek(0, io.SeekStart) 5940 return output 5941} 5942 5943func awsAwsjson11_deserializeErrorRequestLimitExceededException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 5944 var buff [1024]byte 5945 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5946 5947 body := io.TeeReader(errorBody, ringBuffer) 5948 decoder := json.NewDecoder(body) 5949 decoder.UseNumber() 5950 var shape interface{} 5951 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5952 var snapshot bytes.Buffer 5953 io.Copy(&snapshot, ringBuffer) 5954 err = &smithy.DeserializationError{ 5955 Err: fmt.Errorf("failed to decode response body, %w", err), 5956 Snapshot: snapshot.Bytes(), 5957 } 5958 return err 5959 } 5960 5961 output := &types.RequestLimitExceededException{} 5962 err := awsAwsjson11_deserializeDocumentRequestLimitExceededException(&output, shape) 5963 5964 if err != nil { 5965 var snapshot bytes.Buffer 5966 io.Copy(&snapshot, ringBuffer) 5967 err = &smithy.DeserializationError{ 5968 Err: fmt.Errorf("failed to decode response body, %w", err), 5969 Snapshot: snapshot.Bytes(), 5970 } 5971 return err 5972 } 5973 5974 errorBody.Seek(0, io.SeekStart) 5975 return output 5976} 5977 5978func awsAwsjson11_deserializeErrorResourceAlreadyExistsException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 5979 var buff [1024]byte 5980 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5981 5982 body := io.TeeReader(errorBody, ringBuffer) 5983 decoder := json.NewDecoder(body) 5984 decoder.UseNumber() 5985 var shape interface{} 5986 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5987 var snapshot bytes.Buffer 5988 io.Copy(&snapshot, ringBuffer) 5989 err = &smithy.DeserializationError{ 5990 Err: fmt.Errorf("failed to decode response body, %w", err), 5991 Snapshot: snapshot.Bytes(), 5992 } 5993 return err 5994 } 5995 5996 output := &types.ResourceAlreadyExistsException{} 5997 err := awsAwsjson11_deserializeDocumentResourceAlreadyExistsException(&output, shape) 5998 5999 if err != nil { 6000 var snapshot bytes.Buffer 6001 io.Copy(&snapshot, ringBuffer) 6002 err = &smithy.DeserializationError{ 6003 Err: fmt.Errorf("failed to decode response body, %w", err), 6004 Snapshot: snapshot.Bytes(), 6005 } 6006 return err 6007 } 6008 6009 errorBody.Seek(0, io.SeekStart) 6010 return output 6011} 6012 6013func awsAwsjson11_deserializeErrorResourceInUseException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 6014 var buff [1024]byte 6015 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6016 6017 body := io.TeeReader(errorBody, ringBuffer) 6018 decoder := json.NewDecoder(body) 6019 decoder.UseNumber() 6020 var shape interface{} 6021 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6022 var snapshot bytes.Buffer 6023 io.Copy(&snapshot, ringBuffer) 6024 err = &smithy.DeserializationError{ 6025 Err: fmt.Errorf("failed to decode response body, %w", err), 6026 Snapshot: snapshot.Bytes(), 6027 } 6028 return err 6029 } 6030 6031 output := &types.ResourceInUseException{} 6032 err := awsAwsjson11_deserializeDocumentResourceInUseException(&output, shape) 6033 6034 if err != nil { 6035 var snapshot bytes.Buffer 6036 io.Copy(&snapshot, ringBuffer) 6037 err = &smithy.DeserializationError{ 6038 Err: fmt.Errorf("failed to decode response body, %w", err), 6039 Snapshot: snapshot.Bytes(), 6040 } 6041 return err 6042 } 6043 6044 errorBody.Seek(0, io.SeekStart) 6045 return output 6046} 6047 6048func awsAwsjson11_deserializeErrorResourceNotAvailableException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 6049 var buff [1024]byte 6050 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6051 6052 body := io.TeeReader(errorBody, ringBuffer) 6053 decoder := json.NewDecoder(body) 6054 decoder.UseNumber() 6055 var shape interface{} 6056 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6057 var snapshot bytes.Buffer 6058 io.Copy(&snapshot, ringBuffer) 6059 err = &smithy.DeserializationError{ 6060 Err: fmt.Errorf("failed to decode response body, %w", err), 6061 Snapshot: snapshot.Bytes(), 6062 } 6063 return err 6064 } 6065 6066 output := &types.ResourceNotAvailableException{} 6067 err := awsAwsjson11_deserializeDocumentResourceNotAvailableException(&output, shape) 6068 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 err 6077 } 6078 6079 errorBody.Seek(0, io.SeekStart) 6080 return output 6081} 6082 6083func awsAwsjson11_deserializeErrorResourceNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 6084 var buff [1024]byte 6085 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6086 6087 body := io.TeeReader(errorBody, ringBuffer) 6088 decoder := json.NewDecoder(body) 6089 decoder.UseNumber() 6090 var shape interface{} 6091 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6092 var snapshot bytes.Buffer 6093 io.Copy(&snapshot, ringBuffer) 6094 err = &smithy.DeserializationError{ 6095 Err: fmt.Errorf("failed to decode response body, %w", err), 6096 Snapshot: snapshot.Bytes(), 6097 } 6098 return err 6099 } 6100 6101 output := &types.ResourceNotFoundException{} 6102 err := awsAwsjson11_deserializeDocumentResourceNotFoundException(&output, shape) 6103 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 return output 6116} 6117 6118func awsAwsjson11_deserializeDocumentAccessEndpoint(v **types.AccessEndpoint, value interface{}) error { 6119 if v == nil { 6120 return fmt.Errorf("unexpected nil of type %T", v) 6121 } 6122 if value == nil { 6123 return nil 6124 } 6125 6126 shape, ok := value.(map[string]interface{}) 6127 if !ok { 6128 return fmt.Errorf("unexpected JSON type %v", value) 6129 } 6130 6131 var sv *types.AccessEndpoint 6132 if *v == nil { 6133 sv = &types.AccessEndpoint{} 6134 } else { 6135 sv = *v 6136 } 6137 6138 for key, value := range shape { 6139 switch key { 6140 case "EndpointType": 6141 if value != nil { 6142 jtv, ok := value.(string) 6143 if !ok { 6144 return fmt.Errorf("expected AccessEndpointType to be of type string, got %T instead", value) 6145 } 6146 sv.EndpointType = types.AccessEndpointType(jtv) 6147 } 6148 6149 case "VpceId": 6150 if value != nil { 6151 jtv, ok := value.(string) 6152 if !ok { 6153 return fmt.Errorf("expected String to be of type string, got %T instead", value) 6154 } 6155 sv.VpceId = ptr.String(jtv) 6156 } 6157 6158 default: 6159 _, _ = key, value 6160 6161 } 6162 } 6163 *v = sv 6164 return nil 6165} 6166 6167func awsAwsjson11_deserializeDocumentAccessEndpointList(v *[]types.AccessEndpoint, value interface{}) error { 6168 if v == nil { 6169 return fmt.Errorf("unexpected nil of type %T", v) 6170 } 6171 if value == nil { 6172 return nil 6173 } 6174 6175 shape, ok := value.([]interface{}) 6176 if !ok { 6177 return fmt.Errorf("unexpected JSON type %v", value) 6178 } 6179 6180 var cv []types.AccessEndpoint 6181 if *v == nil { 6182 cv = []types.AccessEndpoint{} 6183 } else { 6184 cv = *v 6185 } 6186 6187 for _, value := range shape { 6188 var col types.AccessEndpoint 6189 destAddr := &col 6190 if err := awsAwsjson11_deserializeDocumentAccessEndpoint(&destAddr, value); err != nil { 6191 return err 6192 } 6193 col = *destAddr 6194 cv = append(cv, col) 6195 6196 } 6197 *v = cv 6198 return nil 6199} 6200 6201func awsAwsjson11_deserializeDocumentApplication(v **types.Application, value interface{}) error { 6202 if v == nil { 6203 return fmt.Errorf("unexpected nil of type %T", v) 6204 } 6205 if value == nil { 6206 return nil 6207 } 6208 6209 shape, ok := value.(map[string]interface{}) 6210 if !ok { 6211 return fmt.Errorf("unexpected JSON type %v", value) 6212 } 6213 6214 var sv *types.Application 6215 if *v == nil { 6216 sv = &types.Application{} 6217 } else { 6218 sv = *v 6219 } 6220 6221 for key, value := range shape { 6222 switch key { 6223 case "DisplayName": 6224 if value != nil { 6225 jtv, ok := value.(string) 6226 if !ok { 6227 return fmt.Errorf("expected String to be of type string, got %T instead", value) 6228 } 6229 sv.DisplayName = ptr.String(jtv) 6230 } 6231 6232 case "Enabled": 6233 if value != nil { 6234 jtv, ok := value.(bool) 6235 if !ok { 6236 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 6237 } 6238 sv.Enabled = jtv 6239 } 6240 6241 case "IconURL": 6242 if value != nil { 6243 jtv, ok := value.(string) 6244 if !ok { 6245 return fmt.Errorf("expected String to be of type string, got %T instead", value) 6246 } 6247 sv.IconURL = ptr.String(jtv) 6248 } 6249 6250 case "LaunchParameters": 6251 if value != nil { 6252 jtv, ok := value.(string) 6253 if !ok { 6254 return fmt.Errorf("expected String to be of type string, got %T instead", value) 6255 } 6256 sv.LaunchParameters = ptr.String(jtv) 6257 } 6258 6259 case "LaunchPath": 6260 if value != nil { 6261 jtv, ok := value.(string) 6262 if !ok { 6263 return fmt.Errorf("expected String to be of type string, got %T instead", value) 6264 } 6265 sv.LaunchPath = ptr.String(jtv) 6266 } 6267 6268 case "Metadata": 6269 if err := awsAwsjson11_deserializeDocumentMetadata(&sv.Metadata, value); err != nil { 6270 return err 6271 } 6272 6273 case "Name": 6274 if value != nil { 6275 jtv, ok := value.(string) 6276 if !ok { 6277 return fmt.Errorf("expected String to be of type string, got %T instead", value) 6278 } 6279 sv.Name = ptr.String(jtv) 6280 } 6281 6282 default: 6283 _, _ = key, value 6284 6285 } 6286 } 6287 *v = sv 6288 return nil 6289} 6290 6291func awsAwsjson11_deserializeDocumentApplications(v *[]types.Application, value interface{}) error { 6292 if v == nil { 6293 return fmt.Errorf("unexpected nil of type %T", v) 6294 } 6295 if value == nil { 6296 return nil 6297 } 6298 6299 shape, ok := value.([]interface{}) 6300 if !ok { 6301 return fmt.Errorf("unexpected JSON type %v", value) 6302 } 6303 6304 var cv []types.Application 6305 if *v == nil { 6306 cv = []types.Application{} 6307 } else { 6308 cv = *v 6309 } 6310 6311 for _, value := range shape { 6312 var col types.Application 6313 destAddr := &col 6314 if err := awsAwsjson11_deserializeDocumentApplication(&destAddr, value); err != nil { 6315 return err 6316 } 6317 col = *destAddr 6318 cv = append(cv, col) 6319 6320 } 6321 *v = cv 6322 return nil 6323} 6324 6325func awsAwsjson11_deserializeDocumentApplicationSettingsResponse(v **types.ApplicationSettingsResponse, value interface{}) error { 6326 if v == nil { 6327 return fmt.Errorf("unexpected nil of type %T", v) 6328 } 6329 if value == nil { 6330 return nil 6331 } 6332 6333 shape, ok := value.(map[string]interface{}) 6334 if !ok { 6335 return fmt.Errorf("unexpected JSON type %v", value) 6336 } 6337 6338 var sv *types.ApplicationSettingsResponse 6339 if *v == nil { 6340 sv = &types.ApplicationSettingsResponse{} 6341 } else { 6342 sv = *v 6343 } 6344 6345 for key, value := range shape { 6346 switch key { 6347 case "Enabled": 6348 if value != nil { 6349 jtv, ok := value.(bool) 6350 if !ok { 6351 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 6352 } 6353 sv.Enabled = jtv 6354 } 6355 6356 case "S3BucketName": 6357 if value != nil { 6358 jtv, ok := value.(string) 6359 if !ok { 6360 return fmt.Errorf("expected String to be of type string, got %T instead", value) 6361 } 6362 sv.S3BucketName = ptr.String(jtv) 6363 } 6364 6365 case "SettingsGroup": 6366 if value != nil { 6367 jtv, ok := value.(string) 6368 if !ok { 6369 return fmt.Errorf("expected SettingsGroup to be of type string, got %T instead", value) 6370 } 6371 sv.SettingsGroup = ptr.String(jtv) 6372 } 6373 6374 default: 6375 _, _ = key, value 6376 6377 } 6378 } 6379 *v = sv 6380 return nil 6381} 6382 6383func awsAwsjson11_deserializeDocumentComputeCapacityStatus(v **types.ComputeCapacityStatus, value interface{}) error { 6384 if v == nil { 6385 return fmt.Errorf("unexpected nil of type %T", v) 6386 } 6387 if value == nil { 6388 return nil 6389 } 6390 6391 shape, ok := value.(map[string]interface{}) 6392 if !ok { 6393 return fmt.Errorf("unexpected JSON type %v", value) 6394 } 6395 6396 var sv *types.ComputeCapacityStatus 6397 if *v == nil { 6398 sv = &types.ComputeCapacityStatus{} 6399 } else { 6400 sv = *v 6401 } 6402 6403 for key, value := range shape { 6404 switch key { 6405 case "Available": 6406 if value != nil { 6407 jtv, ok := value.(json.Number) 6408 if !ok { 6409 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 6410 } 6411 i64, err := jtv.Int64() 6412 if err != nil { 6413 return err 6414 } 6415 sv.Available = ptr.Int32(int32(i64)) 6416 } 6417 6418 case "Desired": 6419 if value != nil { 6420 jtv, ok := value.(json.Number) 6421 if !ok { 6422 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 6423 } 6424 i64, err := jtv.Int64() 6425 if err != nil { 6426 return err 6427 } 6428 sv.Desired = ptr.Int32(int32(i64)) 6429 } 6430 6431 case "InUse": 6432 if value != nil { 6433 jtv, ok := value.(json.Number) 6434 if !ok { 6435 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 6436 } 6437 i64, err := jtv.Int64() 6438 if err != nil { 6439 return err 6440 } 6441 sv.InUse = ptr.Int32(int32(i64)) 6442 } 6443 6444 case "Running": 6445 if value != nil { 6446 jtv, ok := value.(json.Number) 6447 if !ok { 6448 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 6449 } 6450 i64, err := jtv.Int64() 6451 if err != nil { 6452 return err 6453 } 6454 sv.Running = ptr.Int32(int32(i64)) 6455 } 6456 6457 default: 6458 _, _ = key, value 6459 6460 } 6461 } 6462 *v = sv 6463 return nil 6464} 6465 6466func awsAwsjson11_deserializeDocumentConcurrentModificationException(v **types.ConcurrentModificationException, value interface{}) error { 6467 if v == nil { 6468 return fmt.Errorf("unexpected nil of type %T", v) 6469 } 6470 if value == nil { 6471 return nil 6472 } 6473 6474 shape, ok := value.(map[string]interface{}) 6475 if !ok { 6476 return fmt.Errorf("unexpected JSON type %v", value) 6477 } 6478 6479 var sv *types.ConcurrentModificationException 6480 if *v == nil { 6481 sv = &types.ConcurrentModificationException{} 6482 } else { 6483 sv = *v 6484 } 6485 6486 for key, value := range shape { 6487 switch key { 6488 case "Message": 6489 if value != nil { 6490 jtv, ok := value.(string) 6491 if !ok { 6492 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 6493 } 6494 sv.Message = ptr.String(jtv) 6495 } 6496 6497 default: 6498 _, _ = key, value 6499 6500 } 6501 } 6502 *v = sv 6503 return nil 6504} 6505 6506func awsAwsjson11_deserializeDocumentDirectoryConfig(v **types.DirectoryConfig, value interface{}) error { 6507 if v == nil { 6508 return fmt.Errorf("unexpected nil of type %T", v) 6509 } 6510 if value == nil { 6511 return nil 6512 } 6513 6514 shape, ok := value.(map[string]interface{}) 6515 if !ok { 6516 return fmt.Errorf("unexpected JSON type %v", value) 6517 } 6518 6519 var sv *types.DirectoryConfig 6520 if *v == nil { 6521 sv = &types.DirectoryConfig{} 6522 } else { 6523 sv = *v 6524 } 6525 6526 for key, value := range shape { 6527 switch key { 6528 case "CreatedTime": 6529 if value != nil { 6530 jtv, ok := value.(json.Number) 6531 if !ok { 6532 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 6533 } 6534 f64, err := jtv.Float64() 6535 if err != nil { 6536 return err 6537 } 6538 sv.CreatedTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 6539 } 6540 6541 case "DirectoryName": 6542 if value != nil { 6543 jtv, ok := value.(string) 6544 if !ok { 6545 return fmt.Errorf("expected DirectoryName to be of type string, got %T instead", value) 6546 } 6547 sv.DirectoryName = ptr.String(jtv) 6548 } 6549 6550 case "OrganizationalUnitDistinguishedNames": 6551 if err := awsAwsjson11_deserializeDocumentOrganizationalUnitDistinguishedNamesList(&sv.OrganizationalUnitDistinguishedNames, value); err != nil { 6552 return err 6553 } 6554 6555 case "ServiceAccountCredentials": 6556 if err := awsAwsjson11_deserializeDocumentServiceAccountCredentials(&sv.ServiceAccountCredentials, value); err != nil { 6557 return err 6558 } 6559 6560 default: 6561 _, _ = key, value 6562 6563 } 6564 } 6565 *v = sv 6566 return nil 6567} 6568 6569func awsAwsjson11_deserializeDocumentDirectoryConfigList(v *[]types.DirectoryConfig, value interface{}) error { 6570 if v == nil { 6571 return fmt.Errorf("unexpected nil of type %T", v) 6572 } 6573 if value == nil { 6574 return nil 6575 } 6576 6577 shape, ok := value.([]interface{}) 6578 if !ok { 6579 return fmt.Errorf("unexpected JSON type %v", value) 6580 } 6581 6582 var cv []types.DirectoryConfig 6583 if *v == nil { 6584 cv = []types.DirectoryConfig{} 6585 } else { 6586 cv = *v 6587 } 6588 6589 for _, value := range shape { 6590 var col types.DirectoryConfig 6591 destAddr := &col 6592 if err := awsAwsjson11_deserializeDocumentDirectoryConfig(&destAddr, value); err != nil { 6593 return err 6594 } 6595 col = *destAddr 6596 cv = append(cv, col) 6597 6598 } 6599 *v = cv 6600 return nil 6601} 6602 6603func awsAwsjson11_deserializeDocumentDomainJoinInfo(v **types.DomainJoinInfo, value interface{}) error { 6604 if v == nil { 6605 return fmt.Errorf("unexpected nil of type %T", v) 6606 } 6607 if value == nil { 6608 return nil 6609 } 6610 6611 shape, ok := value.(map[string]interface{}) 6612 if !ok { 6613 return fmt.Errorf("unexpected JSON type %v", value) 6614 } 6615 6616 var sv *types.DomainJoinInfo 6617 if *v == nil { 6618 sv = &types.DomainJoinInfo{} 6619 } else { 6620 sv = *v 6621 } 6622 6623 for key, value := range shape { 6624 switch key { 6625 case "DirectoryName": 6626 if value != nil { 6627 jtv, ok := value.(string) 6628 if !ok { 6629 return fmt.Errorf("expected DirectoryName to be of type string, got %T instead", value) 6630 } 6631 sv.DirectoryName = ptr.String(jtv) 6632 } 6633 6634 case "OrganizationalUnitDistinguishedName": 6635 if value != nil { 6636 jtv, ok := value.(string) 6637 if !ok { 6638 return fmt.Errorf("expected OrganizationalUnitDistinguishedName to be of type string, got %T instead", value) 6639 } 6640 sv.OrganizationalUnitDistinguishedName = ptr.String(jtv) 6641 } 6642 6643 default: 6644 _, _ = key, value 6645 6646 } 6647 } 6648 *v = sv 6649 return nil 6650} 6651 6652func awsAwsjson11_deserializeDocumentDomainList(v *[]string, value interface{}) error { 6653 if v == nil { 6654 return fmt.Errorf("unexpected nil of type %T", v) 6655 } 6656 if value == nil { 6657 return nil 6658 } 6659 6660 shape, ok := value.([]interface{}) 6661 if !ok { 6662 return fmt.Errorf("unexpected JSON type %v", value) 6663 } 6664 6665 var cv []string 6666 if *v == nil { 6667 cv = []string{} 6668 } else { 6669 cv = *v 6670 } 6671 6672 for _, value := range shape { 6673 var col string 6674 if value != nil { 6675 jtv, ok := value.(string) 6676 if !ok { 6677 return fmt.Errorf("expected Domain to be of type string, got %T instead", value) 6678 } 6679 col = jtv 6680 } 6681 cv = append(cv, col) 6682 6683 } 6684 *v = cv 6685 return nil 6686} 6687 6688func awsAwsjson11_deserializeDocumentEmbedHostDomains(v *[]string, value interface{}) error { 6689 if v == nil { 6690 return fmt.Errorf("unexpected nil of type %T", v) 6691 } 6692 if value == nil { 6693 return nil 6694 } 6695 6696 shape, ok := value.([]interface{}) 6697 if !ok { 6698 return fmt.Errorf("unexpected JSON type %v", value) 6699 } 6700 6701 var cv []string 6702 if *v == nil { 6703 cv = []string{} 6704 } else { 6705 cv = *v 6706 } 6707 6708 for _, value := range shape { 6709 var col string 6710 if value != nil { 6711 jtv, ok := value.(string) 6712 if !ok { 6713 return fmt.Errorf("expected EmbedHostDomain to be of type string, got %T instead", value) 6714 } 6715 col = jtv 6716 } 6717 cv = append(cv, col) 6718 6719 } 6720 *v = cv 6721 return nil 6722} 6723 6724func awsAwsjson11_deserializeDocumentFleet(v **types.Fleet, value interface{}) error { 6725 if v == nil { 6726 return fmt.Errorf("unexpected nil of type %T", v) 6727 } 6728 if value == nil { 6729 return nil 6730 } 6731 6732 shape, ok := value.(map[string]interface{}) 6733 if !ok { 6734 return fmt.Errorf("unexpected JSON type %v", value) 6735 } 6736 6737 var sv *types.Fleet 6738 if *v == nil { 6739 sv = &types.Fleet{} 6740 } else { 6741 sv = *v 6742 } 6743 6744 for key, value := range shape { 6745 switch key { 6746 case "Arn": 6747 if value != nil { 6748 jtv, ok := value.(string) 6749 if !ok { 6750 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 6751 } 6752 sv.Arn = ptr.String(jtv) 6753 } 6754 6755 case "ComputeCapacityStatus": 6756 if err := awsAwsjson11_deserializeDocumentComputeCapacityStatus(&sv.ComputeCapacityStatus, value); err != nil { 6757 return err 6758 } 6759 6760 case "CreatedTime": 6761 if value != nil { 6762 jtv, ok := value.(json.Number) 6763 if !ok { 6764 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 6765 } 6766 f64, err := jtv.Float64() 6767 if err != nil { 6768 return err 6769 } 6770 sv.CreatedTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 6771 } 6772 6773 case "Description": 6774 if value != nil { 6775 jtv, ok := value.(string) 6776 if !ok { 6777 return fmt.Errorf("expected String to be of type string, got %T instead", value) 6778 } 6779 sv.Description = ptr.String(jtv) 6780 } 6781 6782 case "DisconnectTimeoutInSeconds": 6783 if value != nil { 6784 jtv, ok := value.(json.Number) 6785 if !ok { 6786 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 6787 } 6788 i64, err := jtv.Int64() 6789 if err != nil { 6790 return err 6791 } 6792 sv.DisconnectTimeoutInSeconds = ptr.Int32(int32(i64)) 6793 } 6794 6795 case "DisplayName": 6796 if value != nil { 6797 jtv, ok := value.(string) 6798 if !ok { 6799 return fmt.Errorf("expected String to be of type string, got %T instead", value) 6800 } 6801 sv.DisplayName = ptr.String(jtv) 6802 } 6803 6804 case "DomainJoinInfo": 6805 if err := awsAwsjson11_deserializeDocumentDomainJoinInfo(&sv.DomainJoinInfo, value); err != nil { 6806 return err 6807 } 6808 6809 case "EnableDefaultInternetAccess": 6810 if value != nil { 6811 jtv, ok := value.(bool) 6812 if !ok { 6813 return fmt.Errorf("expected BooleanObject to be of type *bool, got %T instead", value) 6814 } 6815 sv.EnableDefaultInternetAccess = ptr.Bool(jtv) 6816 } 6817 6818 case "FleetErrors": 6819 if err := awsAwsjson11_deserializeDocumentFleetErrors(&sv.FleetErrors, value); err != nil { 6820 return err 6821 } 6822 6823 case "FleetType": 6824 if value != nil { 6825 jtv, ok := value.(string) 6826 if !ok { 6827 return fmt.Errorf("expected FleetType to be of type string, got %T instead", value) 6828 } 6829 sv.FleetType = types.FleetType(jtv) 6830 } 6831 6832 case "IamRoleArn": 6833 if value != nil { 6834 jtv, ok := value.(string) 6835 if !ok { 6836 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 6837 } 6838 sv.IamRoleArn = ptr.String(jtv) 6839 } 6840 6841 case "IdleDisconnectTimeoutInSeconds": 6842 if value != nil { 6843 jtv, ok := value.(json.Number) 6844 if !ok { 6845 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 6846 } 6847 i64, err := jtv.Int64() 6848 if err != nil { 6849 return err 6850 } 6851 sv.IdleDisconnectTimeoutInSeconds = ptr.Int32(int32(i64)) 6852 } 6853 6854 case "ImageArn": 6855 if value != nil { 6856 jtv, ok := value.(string) 6857 if !ok { 6858 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 6859 } 6860 sv.ImageArn = ptr.String(jtv) 6861 } 6862 6863 case "ImageName": 6864 if value != nil { 6865 jtv, ok := value.(string) 6866 if !ok { 6867 return fmt.Errorf("expected String to be of type string, got %T instead", value) 6868 } 6869 sv.ImageName = ptr.String(jtv) 6870 } 6871 6872 case "InstanceType": 6873 if value != nil { 6874 jtv, ok := value.(string) 6875 if !ok { 6876 return fmt.Errorf("expected String to be of type string, got %T instead", value) 6877 } 6878 sv.InstanceType = ptr.String(jtv) 6879 } 6880 6881 case "MaxUserDurationInSeconds": 6882 if value != nil { 6883 jtv, ok := value.(json.Number) 6884 if !ok { 6885 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 6886 } 6887 i64, err := jtv.Int64() 6888 if err != nil { 6889 return err 6890 } 6891 sv.MaxUserDurationInSeconds = ptr.Int32(int32(i64)) 6892 } 6893 6894 case "Name": 6895 if value != nil { 6896 jtv, ok := value.(string) 6897 if !ok { 6898 return fmt.Errorf("expected String to be of type string, got %T instead", value) 6899 } 6900 sv.Name = ptr.String(jtv) 6901 } 6902 6903 case "State": 6904 if value != nil { 6905 jtv, ok := value.(string) 6906 if !ok { 6907 return fmt.Errorf("expected FleetState to be of type string, got %T instead", value) 6908 } 6909 sv.State = types.FleetState(jtv) 6910 } 6911 6912 case "StreamView": 6913 if value != nil { 6914 jtv, ok := value.(string) 6915 if !ok { 6916 return fmt.Errorf("expected StreamView to be of type string, got %T instead", value) 6917 } 6918 sv.StreamView = types.StreamView(jtv) 6919 } 6920 6921 case "VpcConfig": 6922 if err := awsAwsjson11_deserializeDocumentVpcConfig(&sv.VpcConfig, value); err != nil { 6923 return err 6924 } 6925 6926 default: 6927 _, _ = key, value 6928 6929 } 6930 } 6931 *v = sv 6932 return nil 6933} 6934 6935func awsAwsjson11_deserializeDocumentFleetError(v **types.FleetError, value interface{}) error { 6936 if v == nil { 6937 return fmt.Errorf("unexpected nil of type %T", v) 6938 } 6939 if value == nil { 6940 return nil 6941 } 6942 6943 shape, ok := value.(map[string]interface{}) 6944 if !ok { 6945 return fmt.Errorf("unexpected JSON type %v", value) 6946 } 6947 6948 var sv *types.FleetError 6949 if *v == nil { 6950 sv = &types.FleetError{} 6951 } else { 6952 sv = *v 6953 } 6954 6955 for key, value := range shape { 6956 switch key { 6957 case "ErrorCode": 6958 if value != nil { 6959 jtv, ok := value.(string) 6960 if !ok { 6961 return fmt.Errorf("expected FleetErrorCode to be of type string, got %T instead", value) 6962 } 6963 sv.ErrorCode = types.FleetErrorCode(jtv) 6964 } 6965 6966 case "ErrorMessage": 6967 if value != nil { 6968 jtv, ok := value.(string) 6969 if !ok { 6970 return fmt.Errorf("expected String to be of type string, got %T instead", value) 6971 } 6972 sv.ErrorMessage = ptr.String(jtv) 6973 } 6974 6975 default: 6976 _, _ = key, value 6977 6978 } 6979 } 6980 *v = sv 6981 return nil 6982} 6983 6984func awsAwsjson11_deserializeDocumentFleetErrors(v *[]types.FleetError, value interface{}) error { 6985 if v == nil { 6986 return fmt.Errorf("unexpected nil of type %T", v) 6987 } 6988 if value == nil { 6989 return nil 6990 } 6991 6992 shape, ok := value.([]interface{}) 6993 if !ok { 6994 return fmt.Errorf("unexpected JSON type %v", value) 6995 } 6996 6997 var cv []types.FleetError 6998 if *v == nil { 6999 cv = []types.FleetError{} 7000 } else { 7001 cv = *v 7002 } 7003 7004 for _, value := range shape { 7005 var col types.FleetError 7006 destAddr := &col 7007 if err := awsAwsjson11_deserializeDocumentFleetError(&destAddr, value); err != nil { 7008 return err 7009 } 7010 col = *destAddr 7011 cv = append(cv, col) 7012 7013 } 7014 *v = cv 7015 return nil 7016} 7017 7018func awsAwsjson11_deserializeDocumentFleetList(v *[]types.Fleet, value interface{}) error { 7019 if v == nil { 7020 return fmt.Errorf("unexpected nil of type %T", v) 7021 } 7022 if value == nil { 7023 return nil 7024 } 7025 7026 shape, ok := value.([]interface{}) 7027 if !ok { 7028 return fmt.Errorf("unexpected JSON type %v", value) 7029 } 7030 7031 var cv []types.Fleet 7032 if *v == nil { 7033 cv = []types.Fleet{} 7034 } else { 7035 cv = *v 7036 } 7037 7038 for _, value := range shape { 7039 var col types.Fleet 7040 destAddr := &col 7041 if err := awsAwsjson11_deserializeDocumentFleet(&destAddr, value); err != nil { 7042 return err 7043 } 7044 col = *destAddr 7045 cv = append(cv, col) 7046 7047 } 7048 *v = cv 7049 return nil 7050} 7051 7052func awsAwsjson11_deserializeDocumentImage(v **types.Image, value interface{}) error { 7053 if v == nil { 7054 return fmt.Errorf("unexpected nil of type %T", v) 7055 } 7056 if value == nil { 7057 return nil 7058 } 7059 7060 shape, ok := value.(map[string]interface{}) 7061 if !ok { 7062 return fmt.Errorf("unexpected JSON type %v", value) 7063 } 7064 7065 var sv *types.Image 7066 if *v == nil { 7067 sv = &types.Image{} 7068 } else { 7069 sv = *v 7070 } 7071 7072 for key, value := range shape { 7073 switch key { 7074 case "Applications": 7075 if err := awsAwsjson11_deserializeDocumentApplications(&sv.Applications, value); err != nil { 7076 return err 7077 } 7078 7079 case "AppstreamAgentVersion": 7080 if value != nil { 7081 jtv, ok := value.(string) 7082 if !ok { 7083 return fmt.Errorf("expected AppstreamAgentVersion to be of type string, got %T instead", value) 7084 } 7085 sv.AppstreamAgentVersion = ptr.String(jtv) 7086 } 7087 7088 case "Arn": 7089 if value != nil { 7090 jtv, ok := value.(string) 7091 if !ok { 7092 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 7093 } 7094 sv.Arn = ptr.String(jtv) 7095 } 7096 7097 case "BaseImageArn": 7098 if value != nil { 7099 jtv, ok := value.(string) 7100 if !ok { 7101 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 7102 } 7103 sv.BaseImageArn = ptr.String(jtv) 7104 } 7105 7106 case "CreatedTime": 7107 if value != nil { 7108 jtv, ok := value.(json.Number) 7109 if !ok { 7110 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 7111 } 7112 f64, err := jtv.Float64() 7113 if err != nil { 7114 return err 7115 } 7116 sv.CreatedTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 7117 } 7118 7119 case "Description": 7120 if value != nil { 7121 jtv, ok := value.(string) 7122 if !ok { 7123 return fmt.Errorf("expected String to be of type string, got %T instead", value) 7124 } 7125 sv.Description = ptr.String(jtv) 7126 } 7127 7128 case "DisplayName": 7129 if value != nil { 7130 jtv, ok := value.(string) 7131 if !ok { 7132 return fmt.Errorf("expected String to be of type string, got %T instead", value) 7133 } 7134 sv.DisplayName = ptr.String(jtv) 7135 } 7136 7137 case "ImageBuilderName": 7138 if value != nil { 7139 jtv, ok := value.(string) 7140 if !ok { 7141 return fmt.Errorf("expected String to be of type string, got %T instead", value) 7142 } 7143 sv.ImageBuilderName = ptr.String(jtv) 7144 } 7145 7146 case "ImageBuilderSupported": 7147 if value != nil { 7148 jtv, ok := value.(bool) 7149 if !ok { 7150 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 7151 } 7152 sv.ImageBuilderSupported = jtv 7153 } 7154 7155 case "ImageErrors": 7156 if err := awsAwsjson11_deserializeDocumentResourceErrors(&sv.ImageErrors, value); err != nil { 7157 return err 7158 } 7159 7160 case "ImagePermissions": 7161 if err := awsAwsjson11_deserializeDocumentImagePermissions(&sv.ImagePermissions, value); err != nil { 7162 return err 7163 } 7164 7165 case "Name": 7166 if value != nil { 7167 jtv, ok := value.(string) 7168 if !ok { 7169 return fmt.Errorf("expected String to be of type string, got %T instead", value) 7170 } 7171 sv.Name = ptr.String(jtv) 7172 } 7173 7174 case "Platform": 7175 if value != nil { 7176 jtv, ok := value.(string) 7177 if !ok { 7178 return fmt.Errorf("expected PlatformType to be of type string, got %T instead", value) 7179 } 7180 sv.Platform = types.PlatformType(jtv) 7181 } 7182 7183 case "PublicBaseImageReleasedDate": 7184 if value != nil { 7185 jtv, ok := value.(json.Number) 7186 if !ok { 7187 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 7188 } 7189 f64, err := jtv.Float64() 7190 if err != nil { 7191 return err 7192 } 7193 sv.PublicBaseImageReleasedDate = ptr.Time(smithytime.ParseEpochSeconds(f64)) 7194 } 7195 7196 case "State": 7197 if value != nil { 7198 jtv, ok := value.(string) 7199 if !ok { 7200 return fmt.Errorf("expected ImageState to be of type string, got %T instead", value) 7201 } 7202 sv.State = types.ImageState(jtv) 7203 } 7204 7205 case "StateChangeReason": 7206 if err := awsAwsjson11_deserializeDocumentImageStateChangeReason(&sv.StateChangeReason, value); err != nil { 7207 return err 7208 } 7209 7210 case "Visibility": 7211 if value != nil { 7212 jtv, ok := value.(string) 7213 if !ok { 7214 return fmt.Errorf("expected VisibilityType to be of type string, got %T instead", value) 7215 } 7216 sv.Visibility = types.VisibilityType(jtv) 7217 } 7218 7219 default: 7220 _, _ = key, value 7221 7222 } 7223 } 7224 *v = sv 7225 return nil 7226} 7227 7228func awsAwsjson11_deserializeDocumentImageBuilder(v **types.ImageBuilder, value interface{}) error { 7229 if v == nil { 7230 return fmt.Errorf("unexpected nil of type %T", v) 7231 } 7232 if value == nil { 7233 return nil 7234 } 7235 7236 shape, ok := value.(map[string]interface{}) 7237 if !ok { 7238 return fmt.Errorf("unexpected JSON type %v", value) 7239 } 7240 7241 var sv *types.ImageBuilder 7242 if *v == nil { 7243 sv = &types.ImageBuilder{} 7244 } else { 7245 sv = *v 7246 } 7247 7248 for key, value := range shape { 7249 switch key { 7250 case "AccessEndpoints": 7251 if err := awsAwsjson11_deserializeDocumentAccessEndpointList(&sv.AccessEndpoints, value); err != nil { 7252 return err 7253 } 7254 7255 case "AppstreamAgentVersion": 7256 if value != nil { 7257 jtv, ok := value.(string) 7258 if !ok { 7259 return fmt.Errorf("expected AppstreamAgentVersion to be of type string, got %T instead", value) 7260 } 7261 sv.AppstreamAgentVersion = ptr.String(jtv) 7262 } 7263 7264 case "Arn": 7265 if value != nil { 7266 jtv, ok := value.(string) 7267 if !ok { 7268 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 7269 } 7270 sv.Arn = ptr.String(jtv) 7271 } 7272 7273 case "CreatedTime": 7274 if value != nil { 7275 jtv, ok := value.(json.Number) 7276 if !ok { 7277 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 7278 } 7279 f64, err := jtv.Float64() 7280 if err != nil { 7281 return err 7282 } 7283 sv.CreatedTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 7284 } 7285 7286 case "Description": 7287 if value != nil { 7288 jtv, ok := value.(string) 7289 if !ok { 7290 return fmt.Errorf("expected String to be of type string, got %T instead", value) 7291 } 7292 sv.Description = ptr.String(jtv) 7293 } 7294 7295 case "DisplayName": 7296 if value != nil { 7297 jtv, ok := value.(string) 7298 if !ok { 7299 return fmt.Errorf("expected String to be of type string, got %T instead", value) 7300 } 7301 sv.DisplayName = ptr.String(jtv) 7302 } 7303 7304 case "DomainJoinInfo": 7305 if err := awsAwsjson11_deserializeDocumentDomainJoinInfo(&sv.DomainJoinInfo, value); err != nil { 7306 return err 7307 } 7308 7309 case "EnableDefaultInternetAccess": 7310 if value != nil { 7311 jtv, ok := value.(bool) 7312 if !ok { 7313 return fmt.Errorf("expected BooleanObject to be of type *bool, got %T instead", value) 7314 } 7315 sv.EnableDefaultInternetAccess = ptr.Bool(jtv) 7316 } 7317 7318 case "IamRoleArn": 7319 if value != nil { 7320 jtv, ok := value.(string) 7321 if !ok { 7322 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 7323 } 7324 sv.IamRoleArn = ptr.String(jtv) 7325 } 7326 7327 case "ImageArn": 7328 if value != nil { 7329 jtv, ok := value.(string) 7330 if !ok { 7331 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 7332 } 7333 sv.ImageArn = ptr.String(jtv) 7334 } 7335 7336 case "ImageBuilderErrors": 7337 if err := awsAwsjson11_deserializeDocumentResourceErrors(&sv.ImageBuilderErrors, value); err != nil { 7338 return err 7339 } 7340 7341 case "InstanceType": 7342 if value != nil { 7343 jtv, ok := value.(string) 7344 if !ok { 7345 return fmt.Errorf("expected String to be of type string, got %T instead", value) 7346 } 7347 sv.InstanceType = ptr.String(jtv) 7348 } 7349 7350 case "Name": 7351 if value != nil { 7352 jtv, ok := value.(string) 7353 if !ok { 7354 return fmt.Errorf("expected String to be of type string, got %T instead", value) 7355 } 7356 sv.Name = ptr.String(jtv) 7357 } 7358 7359 case "NetworkAccessConfiguration": 7360 if err := awsAwsjson11_deserializeDocumentNetworkAccessConfiguration(&sv.NetworkAccessConfiguration, value); err != nil { 7361 return err 7362 } 7363 7364 case "Platform": 7365 if value != nil { 7366 jtv, ok := value.(string) 7367 if !ok { 7368 return fmt.Errorf("expected PlatformType to be of type string, got %T instead", value) 7369 } 7370 sv.Platform = types.PlatformType(jtv) 7371 } 7372 7373 case "State": 7374 if value != nil { 7375 jtv, ok := value.(string) 7376 if !ok { 7377 return fmt.Errorf("expected ImageBuilderState to be of type string, got %T instead", value) 7378 } 7379 sv.State = types.ImageBuilderState(jtv) 7380 } 7381 7382 case "StateChangeReason": 7383 if err := awsAwsjson11_deserializeDocumentImageBuilderStateChangeReason(&sv.StateChangeReason, value); err != nil { 7384 return err 7385 } 7386 7387 case "VpcConfig": 7388 if err := awsAwsjson11_deserializeDocumentVpcConfig(&sv.VpcConfig, value); err != nil { 7389 return err 7390 } 7391 7392 default: 7393 _, _ = key, value 7394 7395 } 7396 } 7397 *v = sv 7398 return nil 7399} 7400 7401func awsAwsjson11_deserializeDocumentImageBuilderList(v *[]types.ImageBuilder, value interface{}) error { 7402 if v == nil { 7403 return fmt.Errorf("unexpected nil of type %T", v) 7404 } 7405 if value == nil { 7406 return nil 7407 } 7408 7409 shape, ok := value.([]interface{}) 7410 if !ok { 7411 return fmt.Errorf("unexpected JSON type %v", value) 7412 } 7413 7414 var cv []types.ImageBuilder 7415 if *v == nil { 7416 cv = []types.ImageBuilder{} 7417 } else { 7418 cv = *v 7419 } 7420 7421 for _, value := range shape { 7422 var col types.ImageBuilder 7423 destAddr := &col 7424 if err := awsAwsjson11_deserializeDocumentImageBuilder(&destAddr, value); err != nil { 7425 return err 7426 } 7427 col = *destAddr 7428 cv = append(cv, col) 7429 7430 } 7431 *v = cv 7432 return nil 7433} 7434 7435func awsAwsjson11_deserializeDocumentImageBuilderStateChangeReason(v **types.ImageBuilderStateChangeReason, value interface{}) error { 7436 if v == nil { 7437 return fmt.Errorf("unexpected nil of type %T", v) 7438 } 7439 if value == nil { 7440 return nil 7441 } 7442 7443 shape, ok := value.(map[string]interface{}) 7444 if !ok { 7445 return fmt.Errorf("unexpected JSON type %v", value) 7446 } 7447 7448 var sv *types.ImageBuilderStateChangeReason 7449 if *v == nil { 7450 sv = &types.ImageBuilderStateChangeReason{} 7451 } else { 7452 sv = *v 7453 } 7454 7455 for key, value := range shape { 7456 switch key { 7457 case "Code": 7458 if value != nil { 7459 jtv, ok := value.(string) 7460 if !ok { 7461 return fmt.Errorf("expected ImageBuilderStateChangeReasonCode to be of type string, got %T instead", value) 7462 } 7463 sv.Code = types.ImageBuilderStateChangeReasonCode(jtv) 7464 } 7465 7466 case "Message": 7467 if value != nil { 7468 jtv, ok := value.(string) 7469 if !ok { 7470 return fmt.Errorf("expected String to be of type string, got %T instead", value) 7471 } 7472 sv.Message = ptr.String(jtv) 7473 } 7474 7475 default: 7476 _, _ = key, value 7477 7478 } 7479 } 7480 *v = sv 7481 return nil 7482} 7483 7484func awsAwsjson11_deserializeDocumentImageList(v *[]types.Image, value interface{}) error { 7485 if v == nil { 7486 return fmt.Errorf("unexpected nil of type %T", v) 7487 } 7488 if value == nil { 7489 return nil 7490 } 7491 7492 shape, ok := value.([]interface{}) 7493 if !ok { 7494 return fmt.Errorf("unexpected JSON type %v", value) 7495 } 7496 7497 var cv []types.Image 7498 if *v == nil { 7499 cv = []types.Image{} 7500 } else { 7501 cv = *v 7502 } 7503 7504 for _, value := range shape { 7505 var col types.Image 7506 destAddr := &col 7507 if err := awsAwsjson11_deserializeDocumentImage(&destAddr, value); err != nil { 7508 return err 7509 } 7510 col = *destAddr 7511 cv = append(cv, col) 7512 7513 } 7514 *v = cv 7515 return nil 7516} 7517 7518func awsAwsjson11_deserializeDocumentImagePermissions(v **types.ImagePermissions, value interface{}) error { 7519 if v == nil { 7520 return fmt.Errorf("unexpected nil of type %T", v) 7521 } 7522 if value == nil { 7523 return nil 7524 } 7525 7526 shape, ok := value.(map[string]interface{}) 7527 if !ok { 7528 return fmt.Errorf("unexpected JSON type %v", value) 7529 } 7530 7531 var sv *types.ImagePermissions 7532 if *v == nil { 7533 sv = &types.ImagePermissions{} 7534 } else { 7535 sv = *v 7536 } 7537 7538 for key, value := range shape { 7539 switch key { 7540 case "allowFleet": 7541 if value != nil { 7542 jtv, ok := value.(bool) 7543 if !ok { 7544 return fmt.Errorf("expected BooleanObject to be of type *bool, got %T instead", value) 7545 } 7546 sv.AllowFleet = ptr.Bool(jtv) 7547 } 7548 7549 case "allowImageBuilder": 7550 if value != nil { 7551 jtv, ok := value.(bool) 7552 if !ok { 7553 return fmt.Errorf("expected BooleanObject to be of type *bool, got %T instead", value) 7554 } 7555 sv.AllowImageBuilder = ptr.Bool(jtv) 7556 } 7557 7558 default: 7559 _, _ = key, value 7560 7561 } 7562 } 7563 *v = sv 7564 return nil 7565} 7566 7567func awsAwsjson11_deserializeDocumentImageStateChangeReason(v **types.ImageStateChangeReason, value interface{}) error { 7568 if v == nil { 7569 return fmt.Errorf("unexpected nil of type %T", v) 7570 } 7571 if value == nil { 7572 return nil 7573 } 7574 7575 shape, ok := value.(map[string]interface{}) 7576 if !ok { 7577 return fmt.Errorf("unexpected JSON type %v", value) 7578 } 7579 7580 var sv *types.ImageStateChangeReason 7581 if *v == nil { 7582 sv = &types.ImageStateChangeReason{} 7583 } else { 7584 sv = *v 7585 } 7586 7587 for key, value := range shape { 7588 switch key { 7589 case "Code": 7590 if value != nil { 7591 jtv, ok := value.(string) 7592 if !ok { 7593 return fmt.Errorf("expected ImageStateChangeReasonCode to be of type string, got %T instead", value) 7594 } 7595 sv.Code = types.ImageStateChangeReasonCode(jtv) 7596 } 7597 7598 case "Message": 7599 if value != nil { 7600 jtv, ok := value.(string) 7601 if !ok { 7602 return fmt.Errorf("expected String to be of type string, got %T instead", value) 7603 } 7604 sv.Message = ptr.String(jtv) 7605 } 7606 7607 default: 7608 _, _ = key, value 7609 7610 } 7611 } 7612 *v = sv 7613 return nil 7614} 7615 7616func awsAwsjson11_deserializeDocumentIncompatibleImageException(v **types.IncompatibleImageException, value interface{}) error { 7617 if v == nil { 7618 return fmt.Errorf("unexpected nil of type %T", v) 7619 } 7620 if value == nil { 7621 return nil 7622 } 7623 7624 shape, ok := value.(map[string]interface{}) 7625 if !ok { 7626 return fmt.Errorf("unexpected JSON type %v", value) 7627 } 7628 7629 var sv *types.IncompatibleImageException 7630 if *v == nil { 7631 sv = &types.IncompatibleImageException{} 7632 } else { 7633 sv = *v 7634 } 7635 7636 for key, value := range shape { 7637 switch key { 7638 case "Message": 7639 if value != nil { 7640 jtv, ok := value.(string) 7641 if !ok { 7642 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 7643 } 7644 sv.Message = ptr.String(jtv) 7645 } 7646 7647 default: 7648 _, _ = key, value 7649 7650 } 7651 } 7652 *v = sv 7653 return nil 7654} 7655 7656func awsAwsjson11_deserializeDocumentInvalidAccountStatusException(v **types.InvalidAccountStatusException, value interface{}) error { 7657 if v == nil { 7658 return fmt.Errorf("unexpected nil of type %T", v) 7659 } 7660 if value == nil { 7661 return nil 7662 } 7663 7664 shape, ok := value.(map[string]interface{}) 7665 if !ok { 7666 return fmt.Errorf("unexpected JSON type %v", value) 7667 } 7668 7669 var sv *types.InvalidAccountStatusException 7670 if *v == nil { 7671 sv = &types.InvalidAccountStatusException{} 7672 } else { 7673 sv = *v 7674 } 7675 7676 for key, value := range shape { 7677 switch key { 7678 case "Message": 7679 if value != nil { 7680 jtv, ok := value.(string) 7681 if !ok { 7682 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 7683 } 7684 sv.Message = ptr.String(jtv) 7685 } 7686 7687 default: 7688 _, _ = key, value 7689 7690 } 7691 } 7692 *v = sv 7693 return nil 7694} 7695 7696func awsAwsjson11_deserializeDocumentInvalidParameterCombinationException(v **types.InvalidParameterCombinationException, value interface{}) error { 7697 if v == nil { 7698 return fmt.Errorf("unexpected nil of type %T", v) 7699 } 7700 if value == nil { 7701 return nil 7702 } 7703 7704 shape, ok := value.(map[string]interface{}) 7705 if !ok { 7706 return fmt.Errorf("unexpected JSON type %v", value) 7707 } 7708 7709 var sv *types.InvalidParameterCombinationException 7710 if *v == nil { 7711 sv = &types.InvalidParameterCombinationException{} 7712 } else { 7713 sv = *v 7714 } 7715 7716 for key, value := range shape { 7717 switch key { 7718 case "Message": 7719 if value != nil { 7720 jtv, ok := value.(string) 7721 if !ok { 7722 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 7723 } 7724 sv.Message = ptr.String(jtv) 7725 } 7726 7727 default: 7728 _, _ = key, value 7729 7730 } 7731 } 7732 *v = sv 7733 return nil 7734} 7735 7736func awsAwsjson11_deserializeDocumentInvalidRoleException(v **types.InvalidRoleException, value interface{}) error { 7737 if v == nil { 7738 return fmt.Errorf("unexpected nil of type %T", v) 7739 } 7740 if value == nil { 7741 return nil 7742 } 7743 7744 shape, ok := value.(map[string]interface{}) 7745 if !ok { 7746 return fmt.Errorf("unexpected JSON type %v", value) 7747 } 7748 7749 var sv *types.InvalidRoleException 7750 if *v == nil { 7751 sv = &types.InvalidRoleException{} 7752 } else { 7753 sv = *v 7754 } 7755 7756 for key, value := range shape { 7757 switch key { 7758 case "Message": 7759 if value != nil { 7760 jtv, ok := value.(string) 7761 if !ok { 7762 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 7763 } 7764 sv.Message = ptr.String(jtv) 7765 } 7766 7767 default: 7768 _, _ = key, value 7769 7770 } 7771 } 7772 *v = sv 7773 return nil 7774} 7775 7776func awsAwsjson11_deserializeDocumentLastReportGenerationExecutionError(v **types.LastReportGenerationExecutionError, value interface{}) error { 7777 if v == nil { 7778 return fmt.Errorf("unexpected nil of type %T", v) 7779 } 7780 if value == nil { 7781 return nil 7782 } 7783 7784 shape, ok := value.(map[string]interface{}) 7785 if !ok { 7786 return fmt.Errorf("unexpected JSON type %v", value) 7787 } 7788 7789 var sv *types.LastReportGenerationExecutionError 7790 if *v == nil { 7791 sv = &types.LastReportGenerationExecutionError{} 7792 } else { 7793 sv = *v 7794 } 7795 7796 for key, value := range shape { 7797 switch key { 7798 case "ErrorCode": 7799 if value != nil { 7800 jtv, ok := value.(string) 7801 if !ok { 7802 return fmt.Errorf("expected UsageReportExecutionErrorCode to be of type string, got %T instead", value) 7803 } 7804 sv.ErrorCode = types.UsageReportExecutionErrorCode(jtv) 7805 } 7806 7807 case "ErrorMessage": 7808 if value != nil { 7809 jtv, ok := value.(string) 7810 if !ok { 7811 return fmt.Errorf("expected String to be of type string, got %T instead", value) 7812 } 7813 sv.ErrorMessage = ptr.String(jtv) 7814 } 7815 7816 default: 7817 _, _ = key, value 7818 7819 } 7820 } 7821 *v = sv 7822 return nil 7823} 7824 7825func awsAwsjson11_deserializeDocumentLastReportGenerationExecutionErrors(v *[]types.LastReportGenerationExecutionError, value interface{}) error { 7826 if v == nil { 7827 return fmt.Errorf("unexpected nil of type %T", v) 7828 } 7829 if value == nil { 7830 return nil 7831 } 7832 7833 shape, ok := value.([]interface{}) 7834 if !ok { 7835 return fmt.Errorf("unexpected JSON type %v", value) 7836 } 7837 7838 var cv []types.LastReportGenerationExecutionError 7839 if *v == nil { 7840 cv = []types.LastReportGenerationExecutionError{} 7841 } else { 7842 cv = *v 7843 } 7844 7845 for _, value := range shape { 7846 var col types.LastReportGenerationExecutionError 7847 destAddr := &col 7848 if err := awsAwsjson11_deserializeDocumentLastReportGenerationExecutionError(&destAddr, value); err != nil { 7849 return err 7850 } 7851 col = *destAddr 7852 cv = append(cv, col) 7853 7854 } 7855 *v = cv 7856 return nil 7857} 7858 7859func awsAwsjson11_deserializeDocumentLimitExceededException(v **types.LimitExceededException, value interface{}) error { 7860 if v == nil { 7861 return fmt.Errorf("unexpected nil of type %T", v) 7862 } 7863 if value == nil { 7864 return nil 7865 } 7866 7867 shape, ok := value.(map[string]interface{}) 7868 if !ok { 7869 return fmt.Errorf("unexpected JSON type %v", value) 7870 } 7871 7872 var sv *types.LimitExceededException 7873 if *v == nil { 7874 sv = &types.LimitExceededException{} 7875 } else { 7876 sv = *v 7877 } 7878 7879 for key, value := range shape { 7880 switch key { 7881 case "Message": 7882 if value != nil { 7883 jtv, ok := value.(string) 7884 if !ok { 7885 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 7886 } 7887 sv.Message = ptr.String(jtv) 7888 } 7889 7890 default: 7891 _, _ = key, value 7892 7893 } 7894 } 7895 *v = sv 7896 return nil 7897} 7898 7899func awsAwsjson11_deserializeDocumentMetadata(v *map[string]string, value interface{}) error { 7900 if v == nil { 7901 return fmt.Errorf("unexpected nil of type %T", v) 7902 } 7903 if value == nil { 7904 return nil 7905 } 7906 7907 shape, ok := value.(map[string]interface{}) 7908 if !ok { 7909 return fmt.Errorf("unexpected JSON type %v", value) 7910 } 7911 7912 var mv map[string]string 7913 if *v == nil { 7914 mv = map[string]string{} 7915 } else { 7916 mv = *v 7917 } 7918 7919 for key, value := range shape { 7920 var parsedVal string 7921 if value != nil { 7922 jtv, ok := value.(string) 7923 if !ok { 7924 return fmt.Errorf("expected String to be of type string, got %T instead", value) 7925 } 7926 parsedVal = jtv 7927 } 7928 mv[key] = parsedVal 7929 7930 } 7931 *v = mv 7932 return nil 7933} 7934 7935func awsAwsjson11_deserializeDocumentNetworkAccessConfiguration(v **types.NetworkAccessConfiguration, value interface{}) error { 7936 if v == nil { 7937 return fmt.Errorf("unexpected nil of type %T", v) 7938 } 7939 if value == nil { 7940 return nil 7941 } 7942 7943 shape, ok := value.(map[string]interface{}) 7944 if !ok { 7945 return fmt.Errorf("unexpected JSON type %v", value) 7946 } 7947 7948 var sv *types.NetworkAccessConfiguration 7949 if *v == nil { 7950 sv = &types.NetworkAccessConfiguration{} 7951 } else { 7952 sv = *v 7953 } 7954 7955 for key, value := range shape { 7956 switch key { 7957 case "EniId": 7958 if value != nil { 7959 jtv, ok := value.(string) 7960 if !ok { 7961 return fmt.Errorf("expected String to be of type string, got %T instead", value) 7962 } 7963 sv.EniId = ptr.String(jtv) 7964 } 7965 7966 case "EniPrivateIpAddress": 7967 if value != nil { 7968 jtv, ok := value.(string) 7969 if !ok { 7970 return fmt.Errorf("expected String to be of type string, got %T instead", value) 7971 } 7972 sv.EniPrivateIpAddress = ptr.String(jtv) 7973 } 7974 7975 default: 7976 _, _ = key, value 7977 7978 } 7979 } 7980 *v = sv 7981 return nil 7982} 7983 7984func awsAwsjson11_deserializeDocumentOperationNotPermittedException(v **types.OperationNotPermittedException, value interface{}) error { 7985 if v == nil { 7986 return fmt.Errorf("unexpected nil of type %T", v) 7987 } 7988 if value == nil { 7989 return nil 7990 } 7991 7992 shape, ok := value.(map[string]interface{}) 7993 if !ok { 7994 return fmt.Errorf("unexpected JSON type %v", value) 7995 } 7996 7997 var sv *types.OperationNotPermittedException 7998 if *v == nil { 7999 sv = &types.OperationNotPermittedException{} 8000 } else { 8001 sv = *v 8002 } 8003 8004 for key, value := range shape { 8005 switch key { 8006 case "Message": 8007 if value != nil { 8008 jtv, ok := value.(string) 8009 if !ok { 8010 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 8011 } 8012 sv.Message = ptr.String(jtv) 8013 } 8014 8015 default: 8016 _, _ = key, value 8017 8018 } 8019 } 8020 *v = sv 8021 return nil 8022} 8023 8024func awsAwsjson11_deserializeDocumentOrganizationalUnitDistinguishedNamesList(v *[]string, value interface{}) error { 8025 if v == nil { 8026 return fmt.Errorf("unexpected nil of type %T", v) 8027 } 8028 if value == nil { 8029 return nil 8030 } 8031 8032 shape, ok := value.([]interface{}) 8033 if !ok { 8034 return fmt.Errorf("unexpected JSON type %v", value) 8035 } 8036 8037 var cv []string 8038 if *v == nil { 8039 cv = []string{} 8040 } else { 8041 cv = *v 8042 } 8043 8044 for _, value := range shape { 8045 var col string 8046 if value != nil { 8047 jtv, ok := value.(string) 8048 if !ok { 8049 return fmt.Errorf("expected OrganizationalUnitDistinguishedName to be of type string, got %T instead", value) 8050 } 8051 col = jtv 8052 } 8053 cv = append(cv, col) 8054 8055 } 8056 *v = cv 8057 return nil 8058} 8059 8060func awsAwsjson11_deserializeDocumentRequestLimitExceededException(v **types.RequestLimitExceededException, value interface{}) error { 8061 if v == nil { 8062 return fmt.Errorf("unexpected nil of type %T", v) 8063 } 8064 if value == nil { 8065 return nil 8066 } 8067 8068 shape, ok := value.(map[string]interface{}) 8069 if !ok { 8070 return fmt.Errorf("unexpected JSON type %v", value) 8071 } 8072 8073 var sv *types.RequestLimitExceededException 8074 if *v == nil { 8075 sv = &types.RequestLimitExceededException{} 8076 } else { 8077 sv = *v 8078 } 8079 8080 for key, value := range shape { 8081 switch key { 8082 case "Message": 8083 if value != nil { 8084 jtv, ok := value.(string) 8085 if !ok { 8086 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 8087 } 8088 sv.Message = ptr.String(jtv) 8089 } 8090 8091 default: 8092 _, _ = key, value 8093 8094 } 8095 } 8096 *v = sv 8097 return nil 8098} 8099 8100func awsAwsjson11_deserializeDocumentResourceAlreadyExistsException(v **types.ResourceAlreadyExistsException, value interface{}) error { 8101 if v == nil { 8102 return fmt.Errorf("unexpected nil of type %T", v) 8103 } 8104 if value == nil { 8105 return nil 8106 } 8107 8108 shape, ok := value.(map[string]interface{}) 8109 if !ok { 8110 return fmt.Errorf("unexpected JSON type %v", value) 8111 } 8112 8113 var sv *types.ResourceAlreadyExistsException 8114 if *v == nil { 8115 sv = &types.ResourceAlreadyExistsException{} 8116 } else { 8117 sv = *v 8118 } 8119 8120 for key, value := range shape { 8121 switch key { 8122 case "Message": 8123 if value != nil { 8124 jtv, ok := value.(string) 8125 if !ok { 8126 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 8127 } 8128 sv.Message = ptr.String(jtv) 8129 } 8130 8131 default: 8132 _, _ = key, value 8133 8134 } 8135 } 8136 *v = sv 8137 return nil 8138} 8139 8140func awsAwsjson11_deserializeDocumentResourceError(v **types.ResourceError, value interface{}) error { 8141 if v == nil { 8142 return fmt.Errorf("unexpected nil of type %T", v) 8143 } 8144 if value == nil { 8145 return nil 8146 } 8147 8148 shape, ok := value.(map[string]interface{}) 8149 if !ok { 8150 return fmt.Errorf("unexpected JSON type %v", value) 8151 } 8152 8153 var sv *types.ResourceError 8154 if *v == nil { 8155 sv = &types.ResourceError{} 8156 } else { 8157 sv = *v 8158 } 8159 8160 for key, value := range shape { 8161 switch key { 8162 case "ErrorCode": 8163 if value != nil { 8164 jtv, ok := value.(string) 8165 if !ok { 8166 return fmt.Errorf("expected FleetErrorCode to be of type string, got %T instead", value) 8167 } 8168 sv.ErrorCode = types.FleetErrorCode(jtv) 8169 } 8170 8171 case "ErrorMessage": 8172 if value != nil { 8173 jtv, ok := value.(string) 8174 if !ok { 8175 return fmt.Errorf("expected String to be of type string, got %T instead", value) 8176 } 8177 sv.ErrorMessage = ptr.String(jtv) 8178 } 8179 8180 case "ErrorTimestamp": 8181 if value != nil { 8182 jtv, ok := value.(json.Number) 8183 if !ok { 8184 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 8185 } 8186 f64, err := jtv.Float64() 8187 if err != nil { 8188 return err 8189 } 8190 sv.ErrorTimestamp = ptr.Time(smithytime.ParseEpochSeconds(f64)) 8191 } 8192 8193 default: 8194 _, _ = key, value 8195 8196 } 8197 } 8198 *v = sv 8199 return nil 8200} 8201 8202func awsAwsjson11_deserializeDocumentResourceErrors(v *[]types.ResourceError, value interface{}) error { 8203 if v == nil { 8204 return fmt.Errorf("unexpected nil of type %T", v) 8205 } 8206 if value == nil { 8207 return nil 8208 } 8209 8210 shape, ok := value.([]interface{}) 8211 if !ok { 8212 return fmt.Errorf("unexpected JSON type %v", value) 8213 } 8214 8215 var cv []types.ResourceError 8216 if *v == nil { 8217 cv = []types.ResourceError{} 8218 } else { 8219 cv = *v 8220 } 8221 8222 for _, value := range shape { 8223 var col types.ResourceError 8224 destAddr := &col 8225 if err := awsAwsjson11_deserializeDocumentResourceError(&destAddr, value); err != nil { 8226 return err 8227 } 8228 col = *destAddr 8229 cv = append(cv, col) 8230 8231 } 8232 *v = cv 8233 return nil 8234} 8235 8236func awsAwsjson11_deserializeDocumentResourceInUseException(v **types.ResourceInUseException, value interface{}) error { 8237 if v == nil { 8238 return fmt.Errorf("unexpected nil of type %T", v) 8239 } 8240 if value == nil { 8241 return nil 8242 } 8243 8244 shape, ok := value.(map[string]interface{}) 8245 if !ok { 8246 return fmt.Errorf("unexpected JSON type %v", value) 8247 } 8248 8249 var sv *types.ResourceInUseException 8250 if *v == nil { 8251 sv = &types.ResourceInUseException{} 8252 } else { 8253 sv = *v 8254 } 8255 8256 for key, value := range shape { 8257 switch key { 8258 case "Message": 8259 if value != nil { 8260 jtv, ok := value.(string) 8261 if !ok { 8262 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 8263 } 8264 sv.Message = ptr.String(jtv) 8265 } 8266 8267 default: 8268 _, _ = key, value 8269 8270 } 8271 } 8272 *v = sv 8273 return nil 8274} 8275 8276func awsAwsjson11_deserializeDocumentResourceNotAvailableException(v **types.ResourceNotAvailableException, value interface{}) error { 8277 if v == nil { 8278 return fmt.Errorf("unexpected nil of type %T", v) 8279 } 8280 if value == nil { 8281 return nil 8282 } 8283 8284 shape, ok := value.(map[string]interface{}) 8285 if !ok { 8286 return fmt.Errorf("unexpected JSON type %v", value) 8287 } 8288 8289 var sv *types.ResourceNotAvailableException 8290 if *v == nil { 8291 sv = &types.ResourceNotAvailableException{} 8292 } else { 8293 sv = *v 8294 } 8295 8296 for key, value := range shape { 8297 switch key { 8298 case "Message": 8299 if value != nil { 8300 jtv, ok := value.(string) 8301 if !ok { 8302 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 8303 } 8304 sv.Message = ptr.String(jtv) 8305 } 8306 8307 default: 8308 _, _ = key, value 8309 8310 } 8311 } 8312 *v = sv 8313 return nil 8314} 8315 8316func awsAwsjson11_deserializeDocumentResourceNotFoundException(v **types.ResourceNotFoundException, value interface{}) error { 8317 if v == nil { 8318 return fmt.Errorf("unexpected nil of type %T", v) 8319 } 8320 if value == nil { 8321 return nil 8322 } 8323 8324 shape, ok := value.(map[string]interface{}) 8325 if !ok { 8326 return fmt.Errorf("unexpected JSON type %v", value) 8327 } 8328 8329 var sv *types.ResourceNotFoundException 8330 if *v == nil { 8331 sv = &types.ResourceNotFoundException{} 8332 } else { 8333 sv = *v 8334 } 8335 8336 for key, value := range shape { 8337 switch key { 8338 case "Message": 8339 if value != nil { 8340 jtv, ok := value.(string) 8341 if !ok { 8342 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 8343 } 8344 sv.Message = ptr.String(jtv) 8345 } 8346 8347 default: 8348 _, _ = key, value 8349 8350 } 8351 } 8352 *v = sv 8353 return nil 8354} 8355 8356func awsAwsjson11_deserializeDocumentSecurityGroupIdList(v *[]string, value interface{}) error { 8357 if v == nil { 8358 return fmt.Errorf("unexpected nil of type %T", v) 8359 } 8360 if value == nil { 8361 return nil 8362 } 8363 8364 shape, ok := value.([]interface{}) 8365 if !ok { 8366 return fmt.Errorf("unexpected JSON type %v", value) 8367 } 8368 8369 var cv []string 8370 if *v == nil { 8371 cv = []string{} 8372 } else { 8373 cv = *v 8374 } 8375 8376 for _, value := range shape { 8377 var col string 8378 if value != nil { 8379 jtv, ok := value.(string) 8380 if !ok { 8381 return fmt.Errorf("expected String to be of type string, got %T instead", value) 8382 } 8383 col = jtv 8384 } 8385 cv = append(cv, col) 8386 8387 } 8388 *v = cv 8389 return nil 8390} 8391 8392func awsAwsjson11_deserializeDocumentServiceAccountCredentials(v **types.ServiceAccountCredentials, value interface{}) error { 8393 if v == nil { 8394 return fmt.Errorf("unexpected nil of type %T", v) 8395 } 8396 if value == nil { 8397 return nil 8398 } 8399 8400 shape, ok := value.(map[string]interface{}) 8401 if !ok { 8402 return fmt.Errorf("unexpected JSON type %v", value) 8403 } 8404 8405 var sv *types.ServiceAccountCredentials 8406 if *v == nil { 8407 sv = &types.ServiceAccountCredentials{} 8408 } else { 8409 sv = *v 8410 } 8411 8412 for key, value := range shape { 8413 switch key { 8414 case "AccountName": 8415 if value != nil { 8416 jtv, ok := value.(string) 8417 if !ok { 8418 return fmt.Errorf("expected AccountName to be of type string, got %T instead", value) 8419 } 8420 sv.AccountName = ptr.String(jtv) 8421 } 8422 8423 case "AccountPassword": 8424 if value != nil { 8425 jtv, ok := value.(string) 8426 if !ok { 8427 return fmt.Errorf("expected AccountPassword to be of type string, got %T instead", value) 8428 } 8429 sv.AccountPassword = ptr.String(jtv) 8430 } 8431 8432 default: 8433 _, _ = key, value 8434 8435 } 8436 } 8437 *v = sv 8438 return nil 8439} 8440 8441func awsAwsjson11_deserializeDocumentSession(v **types.Session, value interface{}) error { 8442 if v == nil { 8443 return fmt.Errorf("unexpected nil of type %T", v) 8444 } 8445 if value == nil { 8446 return nil 8447 } 8448 8449 shape, ok := value.(map[string]interface{}) 8450 if !ok { 8451 return fmt.Errorf("unexpected JSON type %v", value) 8452 } 8453 8454 var sv *types.Session 8455 if *v == nil { 8456 sv = &types.Session{} 8457 } else { 8458 sv = *v 8459 } 8460 8461 for key, value := range shape { 8462 switch key { 8463 case "AuthenticationType": 8464 if value != nil { 8465 jtv, ok := value.(string) 8466 if !ok { 8467 return fmt.Errorf("expected AuthenticationType to be of type string, got %T instead", value) 8468 } 8469 sv.AuthenticationType = types.AuthenticationType(jtv) 8470 } 8471 8472 case "ConnectionState": 8473 if value != nil { 8474 jtv, ok := value.(string) 8475 if !ok { 8476 return fmt.Errorf("expected SessionConnectionState to be of type string, got %T instead", value) 8477 } 8478 sv.ConnectionState = types.SessionConnectionState(jtv) 8479 } 8480 8481 case "FleetName": 8482 if value != nil { 8483 jtv, ok := value.(string) 8484 if !ok { 8485 return fmt.Errorf("expected String to be of type string, got %T instead", value) 8486 } 8487 sv.FleetName = ptr.String(jtv) 8488 } 8489 8490 case "Id": 8491 if value != nil { 8492 jtv, ok := value.(string) 8493 if !ok { 8494 return fmt.Errorf("expected String to be of type string, got %T instead", value) 8495 } 8496 sv.Id = ptr.String(jtv) 8497 } 8498 8499 case "MaxExpirationTime": 8500 if value != nil { 8501 jtv, ok := value.(json.Number) 8502 if !ok { 8503 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 8504 } 8505 f64, err := jtv.Float64() 8506 if err != nil { 8507 return err 8508 } 8509 sv.MaxExpirationTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 8510 } 8511 8512 case "NetworkAccessConfiguration": 8513 if err := awsAwsjson11_deserializeDocumentNetworkAccessConfiguration(&sv.NetworkAccessConfiguration, value); err != nil { 8514 return err 8515 } 8516 8517 case "StackName": 8518 if value != nil { 8519 jtv, ok := value.(string) 8520 if !ok { 8521 return fmt.Errorf("expected String to be of type string, got %T instead", value) 8522 } 8523 sv.StackName = ptr.String(jtv) 8524 } 8525 8526 case "StartTime": 8527 if value != nil { 8528 jtv, ok := value.(json.Number) 8529 if !ok { 8530 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 8531 } 8532 f64, err := jtv.Float64() 8533 if err != nil { 8534 return err 8535 } 8536 sv.StartTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 8537 } 8538 8539 case "State": 8540 if value != nil { 8541 jtv, ok := value.(string) 8542 if !ok { 8543 return fmt.Errorf("expected SessionState to be of type string, got %T instead", value) 8544 } 8545 sv.State = types.SessionState(jtv) 8546 } 8547 8548 case "UserId": 8549 if value != nil { 8550 jtv, ok := value.(string) 8551 if !ok { 8552 return fmt.Errorf("expected UserId to be of type string, got %T instead", value) 8553 } 8554 sv.UserId = ptr.String(jtv) 8555 } 8556 8557 default: 8558 _, _ = key, value 8559 8560 } 8561 } 8562 *v = sv 8563 return nil 8564} 8565 8566func awsAwsjson11_deserializeDocumentSessionList(v *[]types.Session, value interface{}) error { 8567 if v == nil { 8568 return fmt.Errorf("unexpected nil of type %T", v) 8569 } 8570 if value == nil { 8571 return nil 8572 } 8573 8574 shape, ok := value.([]interface{}) 8575 if !ok { 8576 return fmt.Errorf("unexpected JSON type %v", value) 8577 } 8578 8579 var cv []types.Session 8580 if *v == nil { 8581 cv = []types.Session{} 8582 } else { 8583 cv = *v 8584 } 8585 8586 for _, value := range shape { 8587 var col types.Session 8588 destAddr := &col 8589 if err := awsAwsjson11_deserializeDocumentSession(&destAddr, value); err != nil { 8590 return err 8591 } 8592 col = *destAddr 8593 cv = append(cv, col) 8594 8595 } 8596 *v = cv 8597 return nil 8598} 8599 8600func awsAwsjson11_deserializeDocumentSharedImagePermissions(v **types.SharedImagePermissions, value interface{}) error { 8601 if v == nil { 8602 return fmt.Errorf("unexpected nil of type %T", v) 8603 } 8604 if value == nil { 8605 return nil 8606 } 8607 8608 shape, ok := value.(map[string]interface{}) 8609 if !ok { 8610 return fmt.Errorf("unexpected JSON type %v", value) 8611 } 8612 8613 var sv *types.SharedImagePermissions 8614 if *v == nil { 8615 sv = &types.SharedImagePermissions{} 8616 } else { 8617 sv = *v 8618 } 8619 8620 for key, value := range shape { 8621 switch key { 8622 case "imagePermissions": 8623 if err := awsAwsjson11_deserializeDocumentImagePermissions(&sv.ImagePermissions, value); err != nil { 8624 return err 8625 } 8626 8627 case "sharedAccountId": 8628 if value != nil { 8629 jtv, ok := value.(string) 8630 if !ok { 8631 return fmt.Errorf("expected AwsAccountId to be of type string, got %T instead", value) 8632 } 8633 sv.SharedAccountId = ptr.String(jtv) 8634 } 8635 8636 default: 8637 _, _ = key, value 8638 8639 } 8640 } 8641 *v = sv 8642 return nil 8643} 8644 8645func awsAwsjson11_deserializeDocumentSharedImagePermissionsList(v *[]types.SharedImagePermissions, value interface{}) error { 8646 if v == nil { 8647 return fmt.Errorf("unexpected nil of type %T", v) 8648 } 8649 if value == nil { 8650 return nil 8651 } 8652 8653 shape, ok := value.([]interface{}) 8654 if !ok { 8655 return fmt.Errorf("unexpected JSON type %v", value) 8656 } 8657 8658 var cv []types.SharedImagePermissions 8659 if *v == nil { 8660 cv = []types.SharedImagePermissions{} 8661 } else { 8662 cv = *v 8663 } 8664 8665 for _, value := range shape { 8666 var col types.SharedImagePermissions 8667 destAddr := &col 8668 if err := awsAwsjson11_deserializeDocumentSharedImagePermissions(&destAddr, value); err != nil { 8669 return err 8670 } 8671 col = *destAddr 8672 cv = append(cv, col) 8673 8674 } 8675 *v = cv 8676 return nil 8677} 8678 8679func awsAwsjson11_deserializeDocumentStack(v **types.Stack, value interface{}) error { 8680 if v == nil { 8681 return fmt.Errorf("unexpected nil of type %T", v) 8682 } 8683 if value == nil { 8684 return nil 8685 } 8686 8687 shape, ok := value.(map[string]interface{}) 8688 if !ok { 8689 return fmt.Errorf("unexpected JSON type %v", value) 8690 } 8691 8692 var sv *types.Stack 8693 if *v == nil { 8694 sv = &types.Stack{} 8695 } else { 8696 sv = *v 8697 } 8698 8699 for key, value := range shape { 8700 switch key { 8701 case "AccessEndpoints": 8702 if err := awsAwsjson11_deserializeDocumentAccessEndpointList(&sv.AccessEndpoints, value); err != nil { 8703 return err 8704 } 8705 8706 case "ApplicationSettings": 8707 if err := awsAwsjson11_deserializeDocumentApplicationSettingsResponse(&sv.ApplicationSettings, value); err != nil { 8708 return err 8709 } 8710 8711 case "Arn": 8712 if value != nil { 8713 jtv, ok := value.(string) 8714 if !ok { 8715 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 8716 } 8717 sv.Arn = ptr.String(jtv) 8718 } 8719 8720 case "CreatedTime": 8721 if value != nil { 8722 jtv, ok := value.(json.Number) 8723 if !ok { 8724 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 8725 } 8726 f64, err := jtv.Float64() 8727 if err != nil { 8728 return err 8729 } 8730 sv.CreatedTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 8731 } 8732 8733 case "Description": 8734 if value != nil { 8735 jtv, ok := value.(string) 8736 if !ok { 8737 return fmt.Errorf("expected String to be of type string, got %T instead", value) 8738 } 8739 sv.Description = ptr.String(jtv) 8740 } 8741 8742 case "DisplayName": 8743 if value != nil { 8744 jtv, ok := value.(string) 8745 if !ok { 8746 return fmt.Errorf("expected String to be of type string, got %T instead", value) 8747 } 8748 sv.DisplayName = ptr.String(jtv) 8749 } 8750 8751 case "EmbedHostDomains": 8752 if err := awsAwsjson11_deserializeDocumentEmbedHostDomains(&sv.EmbedHostDomains, value); err != nil { 8753 return err 8754 } 8755 8756 case "FeedbackURL": 8757 if value != nil { 8758 jtv, ok := value.(string) 8759 if !ok { 8760 return fmt.Errorf("expected FeedbackURL to be of type string, got %T instead", value) 8761 } 8762 sv.FeedbackURL = ptr.String(jtv) 8763 } 8764 8765 case "Name": 8766 if value != nil { 8767 jtv, ok := value.(string) 8768 if !ok { 8769 return fmt.Errorf("expected String to be of type string, got %T instead", value) 8770 } 8771 sv.Name = ptr.String(jtv) 8772 } 8773 8774 case "RedirectURL": 8775 if value != nil { 8776 jtv, ok := value.(string) 8777 if !ok { 8778 return fmt.Errorf("expected RedirectURL to be of type string, got %T instead", value) 8779 } 8780 sv.RedirectURL = ptr.String(jtv) 8781 } 8782 8783 case "StackErrors": 8784 if err := awsAwsjson11_deserializeDocumentStackErrors(&sv.StackErrors, value); err != nil { 8785 return err 8786 } 8787 8788 case "StorageConnectors": 8789 if err := awsAwsjson11_deserializeDocumentStorageConnectorList(&sv.StorageConnectors, value); err != nil { 8790 return err 8791 } 8792 8793 case "UserSettings": 8794 if err := awsAwsjson11_deserializeDocumentUserSettingList(&sv.UserSettings, value); err != nil { 8795 return err 8796 } 8797 8798 default: 8799 _, _ = key, value 8800 8801 } 8802 } 8803 *v = sv 8804 return nil 8805} 8806 8807func awsAwsjson11_deserializeDocumentStackError(v **types.StackError, value interface{}) error { 8808 if v == nil { 8809 return fmt.Errorf("unexpected nil of type %T", v) 8810 } 8811 if value == nil { 8812 return nil 8813 } 8814 8815 shape, ok := value.(map[string]interface{}) 8816 if !ok { 8817 return fmt.Errorf("unexpected JSON type %v", value) 8818 } 8819 8820 var sv *types.StackError 8821 if *v == nil { 8822 sv = &types.StackError{} 8823 } else { 8824 sv = *v 8825 } 8826 8827 for key, value := range shape { 8828 switch key { 8829 case "ErrorCode": 8830 if value != nil { 8831 jtv, ok := value.(string) 8832 if !ok { 8833 return fmt.Errorf("expected StackErrorCode to be of type string, got %T instead", value) 8834 } 8835 sv.ErrorCode = types.StackErrorCode(jtv) 8836 } 8837 8838 case "ErrorMessage": 8839 if value != nil { 8840 jtv, ok := value.(string) 8841 if !ok { 8842 return fmt.Errorf("expected String to be of type string, got %T instead", value) 8843 } 8844 sv.ErrorMessage = ptr.String(jtv) 8845 } 8846 8847 default: 8848 _, _ = key, value 8849 8850 } 8851 } 8852 *v = sv 8853 return nil 8854} 8855 8856func awsAwsjson11_deserializeDocumentStackErrors(v *[]types.StackError, value interface{}) error { 8857 if v == nil { 8858 return fmt.Errorf("unexpected nil of type %T", v) 8859 } 8860 if value == nil { 8861 return nil 8862 } 8863 8864 shape, ok := value.([]interface{}) 8865 if !ok { 8866 return fmt.Errorf("unexpected JSON type %v", value) 8867 } 8868 8869 var cv []types.StackError 8870 if *v == nil { 8871 cv = []types.StackError{} 8872 } else { 8873 cv = *v 8874 } 8875 8876 for _, value := range shape { 8877 var col types.StackError 8878 destAddr := &col 8879 if err := awsAwsjson11_deserializeDocumentStackError(&destAddr, value); err != nil { 8880 return err 8881 } 8882 col = *destAddr 8883 cv = append(cv, col) 8884 8885 } 8886 *v = cv 8887 return nil 8888} 8889 8890func awsAwsjson11_deserializeDocumentStackList(v *[]types.Stack, value interface{}) error { 8891 if v == nil { 8892 return fmt.Errorf("unexpected nil of type %T", v) 8893 } 8894 if value == nil { 8895 return nil 8896 } 8897 8898 shape, ok := value.([]interface{}) 8899 if !ok { 8900 return fmt.Errorf("unexpected JSON type %v", value) 8901 } 8902 8903 var cv []types.Stack 8904 if *v == nil { 8905 cv = []types.Stack{} 8906 } else { 8907 cv = *v 8908 } 8909 8910 for _, value := range shape { 8911 var col types.Stack 8912 destAddr := &col 8913 if err := awsAwsjson11_deserializeDocumentStack(&destAddr, value); err != nil { 8914 return err 8915 } 8916 col = *destAddr 8917 cv = append(cv, col) 8918 8919 } 8920 *v = cv 8921 return nil 8922} 8923 8924func awsAwsjson11_deserializeDocumentStorageConnector(v **types.StorageConnector, value interface{}) error { 8925 if v == nil { 8926 return fmt.Errorf("unexpected nil of type %T", v) 8927 } 8928 if value == nil { 8929 return nil 8930 } 8931 8932 shape, ok := value.(map[string]interface{}) 8933 if !ok { 8934 return fmt.Errorf("unexpected JSON type %v", value) 8935 } 8936 8937 var sv *types.StorageConnector 8938 if *v == nil { 8939 sv = &types.StorageConnector{} 8940 } else { 8941 sv = *v 8942 } 8943 8944 for key, value := range shape { 8945 switch key { 8946 case "ConnectorType": 8947 if value != nil { 8948 jtv, ok := value.(string) 8949 if !ok { 8950 return fmt.Errorf("expected StorageConnectorType to be of type string, got %T instead", value) 8951 } 8952 sv.ConnectorType = types.StorageConnectorType(jtv) 8953 } 8954 8955 case "Domains": 8956 if err := awsAwsjson11_deserializeDocumentDomainList(&sv.Domains, value); err != nil { 8957 return err 8958 } 8959 8960 case "ResourceIdentifier": 8961 if value != nil { 8962 jtv, ok := value.(string) 8963 if !ok { 8964 return fmt.Errorf("expected ResourceIdentifier to be of type string, got %T instead", value) 8965 } 8966 sv.ResourceIdentifier = ptr.String(jtv) 8967 } 8968 8969 default: 8970 _, _ = key, value 8971 8972 } 8973 } 8974 *v = sv 8975 return nil 8976} 8977 8978func awsAwsjson11_deserializeDocumentStorageConnectorList(v *[]types.StorageConnector, value interface{}) error { 8979 if v == nil { 8980 return fmt.Errorf("unexpected nil of type %T", v) 8981 } 8982 if value == nil { 8983 return nil 8984 } 8985 8986 shape, ok := value.([]interface{}) 8987 if !ok { 8988 return fmt.Errorf("unexpected JSON type %v", value) 8989 } 8990 8991 var cv []types.StorageConnector 8992 if *v == nil { 8993 cv = []types.StorageConnector{} 8994 } else { 8995 cv = *v 8996 } 8997 8998 for _, value := range shape { 8999 var col types.StorageConnector 9000 destAddr := &col 9001 if err := awsAwsjson11_deserializeDocumentStorageConnector(&destAddr, value); err != nil { 9002 return err 9003 } 9004 col = *destAddr 9005 cv = append(cv, col) 9006 9007 } 9008 *v = cv 9009 return nil 9010} 9011 9012func awsAwsjson11_deserializeDocumentStringList(v *[]string, value interface{}) error { 9013 if v == nil { 9014 return fmt.Errorf("unexpected nil of type %T", v) 9015 } 9016 if value == nil { 9017 return nil 9018 } 9019 9020 shape, ok := value.([]interface{}) 9021 if !ok { 9022 return fmt.Errorf("unexpected JSON type %v", value) 9023 } 9024 9025 var cv []string 9026 if *v == nil { 9027 cv = []string{} 9028 } else { 9029 cv = *v 9030 } 9031 9032 for _, value := range shape { 9033 var col string 9034 if value != nil { 9035 jtv, ok := value.(string) 9036 if !ok { 9037 return fmt.Errorf("expected String to be of type string, got %T instead", value) 9038 } 9039 col = jtv 9040 } 9041 cv = append(cv, col) 9042 9043 } 9044 *v = cv 9045 return nil 9046} 9047 9048func awsAwsjson11_deserializeDocumentSubnetIdList(v *[]string, value interface{}) error { 9049 if v == nil { 9050 return fmt.Errorf("unexpected nil of type %T", v) 9051 } 9052 if value == nil { 9053 return nil 9054 } 9055 9056 shape, ok := value.([]interface{}) 9057 if !ok { 9058 return fmt.Errorf("unexpected JSON type %v", value) 9059 } 9060 9061 var cv []string 9062 if *v == nil { 9063 cv = []string{} 9064 } else { 9065 cv = *v 9066 } 9067 9068 for _, value := range shape { 9069 var col string 9070 if value != nil { 9071 jtv, ok := value.(string) 9072 if !ok { 9073 return fmt.Errorf("expected String to be of type string, got %T instead", value) 9074 } 9075 col = jtv 9076 } 9077 cv = append(cv, col) 9078 9079 } 9080 *v = cv 9081 return nil 9082} 9083 9084func awsAwsjson11_deserializeDocumentTags(v *map[string]string, value interface{}) error { 9085 if v == nil { 9086 return fmt.Errorf("unexpected nil of type %T", v) 9087 } 9088 if value == nil { 9089 return nil 9090 } 9091 9092 shape, ok := value.(map[string]interface{}) 9093 if !ok { 9094 return fmt.Errorf("unexpected JSON type %v", value) 9095 } 9096 9097 var mv map[string]string 9098 if *v == nil { 9099 mv = map[string]string{} 9100 } else { 9101 mv = *v 9102 } 9103 9104 for key, value := range shape { 9105 var parsedVal string 9106 if value != nil { 9107 jtv, ok := value.(string) 9108 if !ok { 9109 return fmt.Errorf("expected TagValue to be of type string, got %T instead", value) 9110 } 9111 parsedVal = jtv 9112 } 9113 mv[key] = parsedVal 9114 9115 } 9116 *v = mv 9117 return nil 9118} 9119 9120func awsAwsjson11_deserializeDocumentUsageReportSubscription(v **types.UsageReportSubscription, value interface{}) error { 9121 if v == nil { 9122 return fmt.Errorf("unexpected nil of type %T", v) 9123 } 9124 if value == nil { 9125 return nil 9126 } 9127 9128 shape, ok := value.(map[string]interface{}) 9129 if !ok { 9130 return fmt.Errorf("unexpected JSON type %v", value) 9131 } 9132 9133 var sv *types.UsageReportSubscription 9134 if *v == nil { 9135 sv = &types.UsageReportSubscription{} 9136 } else { 9137 sv = *v 9138 } 9139 9140 for key, value := range shape { 9141 switch key { 9142 case "LastGeneratedReportDate": 9143 if value != nil { 9144 jtv, ok := value.(json.Number) 9145 if !ok { 9146 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 9147 } 9148 f64, err := jtv.Float64() 9149 if err != nil { 9150 return err 9151 } 9152 sv.LastGeneratedReportDate = ptr.Time(smithytime.ParseEpochSeconds(f64)) 9153 } 9154 9155 case "S3BucketName": 9156 if value != nil { 9157 jtv, ok := value.(string) 9158 if !ok { 9159 return fmt.Errorf("expected String to be of type string, got %T instead", value) 9160 } 9161 sv.S3BucketName = ptr.String(jtv) 9162 } 9163 9164 case "Schedule": 9165 if value != nil { 9166 jtv, ok := value.(string) 9167 if !ok { 9168 return fmt.Errorf("expected UsageReportSchedule to be of type string, got %T instead", value) 9169 } 9170 sv.Schedule = types.UsageReportSchedule(jtv) 9171 } 9172 9173 case "SubscriptionErrors": 9174 if err := awsAwsjson11_deserializeDocumentLastReportGenerationExecutionErrors(&sv.SubscriptionErrors, value); err != nil { 9175 return err 9176 } 9177 9178 default: 9179 _, _ = key, value 9180 9181 } 9182 } 9183 *v = sv 9184 return nil 9185} 9186 9187func awsAwsjson11_deserializeDocumentUsageReportSubscriptionList(v *[]types.UsageReportSubscription, value interface{}) error { 9188 if v == nil { 9189 return fmt.Errorf("unexpected nil of type %T", v) 9190 } 9191 if value == nil { 9192 return nil 9193 } 9194 9195 shape, ok := value.([]interface{}) 9196 if !ok { 9197 return fmt.Errorf("unexpected JSON type %v", value) 9198 } 9199 9200 var cv []types.UsageReportSubscription 9201 if *v == nil { 9202 cv = []types.UsageReportSubscription{} 9203 } else { 9204 cv = *v 9205 } 9206 9207 for _, value := range shape { 9208 var col types.UsageReportSubscription 9209 destAddr := &col 9210 if err := awsAwsjson11_deserializeDocumentUsageReportSubscription(&destAddr, value); err != nil { 9211 return err 9212 } 9213 col = *destAddr 9214 cv = append(cv, col) 9215 9216 } 9217 *v = cv 9218 return nil 9219} 9220 9221func awsAwsjson11_deserializeDocumentUser(v **types.User, value interface{}) error { 9222 if v == nil { 9223 return fmt.Errorf("unexpected nil of type %T", v) 9224 } 9225 if value == nil { 9226 return nil 9227 } 9228 9229 shape, ok := value.(map[string]interface{}) 9230 if !ok { 9231 return fmt.Errorf("unexpected JSON type %v", value) 9232 } 9233 9234 var sv *types.User 9235 if *v == nil { 9236 sv = &types.User{} 9237 } else { 9238 sv = *v 9239 } 9240 9241 for key, value := range shape { 9242 switch key { 9243 case "Arn": 9244 if value != nil { 9245 jtv, ok := value.(string) 9246 if !ok { 9247 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 9248 } 9249 sv.Arn = ptr.String(jtv) 9250 } 9251 9252 case "AuthenticationType": 9253 if value != nil { 9254 jtv, ok := value.(string) 9255 if !ok { 9256 return fmt.Errorf("expected AuthenticationType to be of type string, got %T instead", value) 9257 } 9258 sv.AuthenticationType = types.AuthenticationType(jtv) 9259 } 9260 9261 case "CreatedTime": 9262 if value != nil { 9263 jtv, ok := value.(json.Number) 9264 if !ok { 9265 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 9266 } 9267 f64, err := jtv.Float64() 9268 if err != nil { 9269 return err 9270 } 9271 sv.CreatedTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 9272 } 9273 9274 case "Enabled": 9275 if value != nil { 9276 jtv, ok := value.(bool) 9277 if !ok { 9278 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 9279 } 9280 sv.Enabled = jtv 9281 } 9282 9283 case "FirstName": 9284 if value != nil { 9285 jtv, ok := value.(string) 9286 if !ok { 9287 return fmt.Errorf("expected UserAttributeValue to be of type string, got %T instead", value) 9288 } 9289 sv.FirstName = ptr.String(jtv) 9290 } 9291 9292 case "LastName": 9293 if value != nil { 9294 jtv, ok := value.(string) 9295 if !ok { 9296 return fmt.Errorf("expected UserAttributeValue to be of type string, got %T instead", value) 9297 } 9298 sv.LastName = ptr.String(jtv) 9299 } 9300 9301 case "Status": 9302 if value != nil { 9303 jtv, ok := value.(string) 9304 if !ok { 9305 return fmt.Errorf("expected String to be of type string, got %T instead", value) 9306 } 9307 sv.Status = ptr.String(jtv) 9308 } 9309 9310 case "UserName": 9311 if value != nil { 9312 jtv, ok := value.(string) 9313 if !ok { 9314 return fmt.Errorf("expected Username to be of type string, got %T instead", value) 9315 } 9316 sv.UserName = ptr.String(jtv) 9317 } 9318 9319 default: 9320 _, _ = key, value 9321 9322 } 9323 } 9324 *v = sv 9325 return nil 9326} 9327 9328func awsAwsjson11_deserializeDocumentUserList(v *[]types.User, value interface{}) error { 9329 if v == nil { 9330 return fmt.Errorf("unexpected nil of type %T", v) 9331 } 9332 if value == nil { 9333 return nil 9334 } 9335 9336 shape, ok := value.([]interface{}) 9337 if !ok { 9338 return fmt.Errorf("unexpected JSON type %v", value) 9339 } 9340 9341 var cv []types.User 9342 if *v == nil { 9343 cv = []types.User{} 9344 } else { 9345 cv = *v 9346 } 9347 9348 for _, value := range shape { 9349 var col types.User 9350 destAddr := &col 9351 if err := awsAwsjson11_deserializeDocumentUser(&destAddr, value); err != nil { 9352 return err 9353 } 9354 col = *destAddr 9355 cv = append(cv, col) 9356 9357 } 9358 *v = cv 9359 return nil 9360} 9361 9362func awsAwsjson11_deserializeDocumentUserSetting(v **types.UserSetting, value interface{}) error { 9363 if v == nil { 9364 return fmt.Errorf("unexpected nil of type %T", v) 9365 } 9366 if value == nil { 9367 return nil 9368 } 9369 9370 shape, ok := value.(map[string]interface{}) 9371 if !ok { 9372 return fmt.Errorf("unexpected JSON type %v", value) 9373 } 9374 9375 var sv *types.UserSetting 9376 if *v == nil { 9377 sv = &types.UserSetting{} 9378 } else { 9379 sv = *v 9380 } 9381 9382 for key, value := range shape { 9383 switch key { 9384 case "Action": 9385 if value != nil { 9386 jtv, ok := value.(string) 9387 if !ok { 9388 return fmt.Errorf("expected Action to be of type string, got %T instead", value) 9389 } 9390 sv.Action = types.Action(jtv) 9391 } 9392 9393 case "Permission": 9394 if value != nil { 9395 jtv, ok := value.(string) 9396 if !ok { 9397 return fmt.Errorf("expected Permission to be of type string, got %T instead", value) 9398 } 9399 sv.Permission = types.Permission(jtv) 9400 } 9401 9402 default: 9403 _, _ = key, value 9404 9405 } 9406 } 9407 *v = sv 9408 return nil 9409} 9410 9411func awsAwsjson11_deserializeDocumentUserSettingList(v *[]types.UserSetting, value interface{}) error { 9412 if v == nil { 9413 return fmt.Errorf("unexpected nil of type %T", v) 9414 } 9415 if value == nil { 9416 return nil 9417 } 9418 9419 shape, ok := value.([]interface{}) 9420 if !ok { 9421 return fmt.Errorf("unexpected JSON type %v", value) 9422 } 9423 9424 var cv []types.UserSetting 9425 if *v == nil { 9426 cv = []types.UserSetting{} 9427 } else { 9428 cv = *v 9429 } 9430 9431 for _, value := range shape { 9432 var col types.UserSetting 9433 destAddr := &col 9434 if err := awsAwsjson11_deserializeDocumentUserSetting(&destAddr, value); err != nil { 9435 return err 9436 } 9437 col = *destAddr 9438 cv = append(cv, col) 9439 9440 } 9441 *v = cv 9442 return nil 9443} 9444 9445func awsAwsjson11_deserializeDocumentUserStackAssociation(v **types.UserStackAssociation, value interface{}) error { 9446 if v == nil { 9447 return fmt.Errorf("unexpected nil of type %T", v) 9448 } 9449 if value == nil { 9450 return nil 9451 } 9452 9453 shape, ok := value.(map[string]interface{}) 9454 if !ok { 9455 return fmt.Errorf("unexpected JSON type %v", value) 9456 } 9457 9458 var sv *types.UserStackAssociation 9459 if *v == nil { 9460 sv = &types.UserStackAssociation{} 9461 } else { 9462 sv = *v 9463 } 9464 9465 for key, value := range shape { 9466 switch key { 9467 case "AuthenticationType": 9468 if value != nil { 9469 jtv, ok := value.(string) 9470 if !ok { 9471 return fmt.Errorf("expected AuthenticationType to be of type string, got %T instead", value) 9472 } 9473 sv.AuthenticationType = types.AuthenticationType(jtv) 9474 } 9475 9476 case "SendEmailNotification": 9477 if value != nil { 9478 jtv, ok := value.(bool) 9479 if !ok { 9480 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 9481 } 9482 sv.SendEmailNotification = jtv 9483 } 9484 9485 case "StackName": 9486 if value != nil { 9487 jtv, ok := value.(string) 9488 if !ok { 9489 return fmt.Errorf("expected String to be of type string, got %T instead", value) 9490 } 9491 sv.StackName = ptr.String(jtv) 9492 } 9493 9494 case "UserName": 9495 if value != nil { 9496 jtv, ok := value.(string) 9497 if !ok { 9498 return fmt.Errorf("expected Username to be of type string, got %T instead", value) 9499 } 9500 sv.UserName = ptr.String(jtv) 9501 } 9502 9503 default: 9504 _, _ = key, value 9505 9506 } 9507 } 9508 *v = sv 9509 return nil 9510} 9511 9512func awsAwsjson11_deserializeDocumentUserStackAssociationError(v **types.UserStackAssociationError, value interface{}) error { 9513 if v == nil { 9514 return fmt.Errorf("unexpected nil of type %T", v) 9515 } 9516 if value == nil { 9517 return nil 9518 } 9519 9520 shape, ok := value.(map[string]interface{}) 9521 if !ok { 9522 return fmt.Errorf("unexpected JSON type %v", value) 9523 } 9524 9525 var sv *types.UserStackAssociationError 9526 if *v == nil { 9527 sv = &types.UserStackAssociationError{} 9528 } else { 9529 sv = *v 9530 } 9531 9532 for key, value := range shape { 9533 switch key { 9534 case "ErrorCode": 9535 if value != nil { 9536 jtv, ok := value.(string) 9537 if !ok { 9538 return fmt.Errorf("expected UserStackAssociationErrorCode to be of type string, got %T instead", value) 9539 } 9540 sv.ErrorCode = types.UserStackAssociationErrorCode(jtv) 9541 } 9542 9543 case "ErrorMessage": 9544 if value != nil { 9545 jtv, ok := value.(string) 9546 if !ok { 9547 return fmt.Errorf("expected String to be of type string, got %T instead", value) 9548 } 9549 sv.ErrorMessage = ptr.String(jtv) 9550 } 9551 9552 case "UserStackAssociation": 9553 if err := awsAwsjson11_deserializeDocumentUserStackAssociation(&sv.UserStackAssociation, value); err != nil { 9554 return err 9555 } 9556 9557 default: 9558 _, _ = key, value 9559 9560 } 9561 } 9562 *v = sv 9563 return nil 9564} 9565 9566func awsAwsjson11_deserializeDocumentUserStackAssociationErrorList(v *[]types.UserStackAssociationError, value interface{}) error { 9567 if v == nil { 9568 return fmt.Errorf("unexpected nil of type %T", v) 9569 } 9570 if value == nil { 9571 return nil 9572 } 9573 9574 shape, ok := value.([]interface{}) 9575 if !ok { 9576 return fmt.Errorf("unexpected JSON type %v", value) 9577 } 9578 9579 var cv []types.UserStackAssociationError 9580 if *v == nil { 9581 cv = []types.UserStackAssociationError{} 9582 } else { 9583 cv = *v 9584 } 9585 9586 for _, value := range shape { 9587 var col types.UserStackAssociationError 9588 destAddr := &col 9589 if err := awsAwsjson11_deserializeDocumentUserStackAssociationError(&destAddr, value); err != nil { 9590 return err 9591 } 9592 col = *destAddr 9593 cv = append(cv, col) 9594 9595 } 9596 *v = cv 9597 return nil 9598} 9599 9600func awsAwsjson11_deserializeDocumentUserStackAssociationList(v *[]types.UserStackAssociation, value interface{}) error { 9601 if v == nil { 9602 return fmt.Errorf("unexpected nil of type %T", v) 9603 } 9604 if value == nil { 9605 return nil 9606 } 9607 9608 shape, ok := value.([]interface{}) 9609 if !ok { 9610 return fmt.Errorf("unexpected JSON type %v", value) 9611 } 9612 9613 var cv []types.UserStackAssociation 9614 if *v == nil { 9615 cv = []types.UserStackAssociation{} 9616 } else { 9617 cv = *v 9618 } 9619 9620 for _, value := range shape { 9621 var col types.UserStackAssociation 9622 destAddr := &col 9623 if err := awsAwsjson11_deserializeDocumentUserStackAssociation(&destAddr, value); err != nil { 9624 return err 9625 } 9626 col = *destAddr 9627 cv = append(cv, col) 9628 9629 } 9630 *v = cv 9631 return nil 9632} 9633 9634func awsAwsjson11_deserializeDocumentVpcConfig(v **types.VpcConfig, value interface{}) error { 9635 if v == nil { 9636 return fmt.Errorf("unexpected nil of type %T", v) 9637 } 9638 if value == nil { 9639 return nil 9640 } 9641 9642 shape, ok := value.(map[string]interface{}) 9643 if !ok { 9644 return fmt.Errorf("unexpected JSON type %v", value) 9645 } 9646 9647 var sv *types.VpcConfig 9648 if *v == nil { 9649 sv = &types.VpcConfig{} 9650 } else { 9651 sv = *v 9652 } 9653 9654 for key, value := range shape { 9655 switch key { 9656 case "SecurityGroupIds": 9657 if err := awsAwsjson11_deserializeDocumentSecurityGroupIdList(&sv.SecurityGroupIds, value); err != nil { 9658 return err 9659 } 9660 9661 case "SubnetIds": 9662 if err := awsAwsjson11_deserializeDocumentSubnetIdList(&sv.SubnetIds, value); err != nil { 9663 return err 9664 } 9665 9666 default: 9667 _, _ = key, value 9668 9669 } 9670 } 9671 *v = sv 9672 return nil 9673} 9674 9675func awsAwsjson11_deserializeOpDocumentAssociateFleetOutput(v **AssociateFleetOutput, value interface{}) error { 9676 if v == nil { 9677 return fmt.Errorf("unexpected nil of type %T", v) 9678 } 9679 if value == nil { 9680 return nil 9681 } 9682 9683 shape, ok := value.(map[string]interface{}) 9684 if !ok { 9685 return fmt.Errorf("unexpected JSON type %v", value) 9686 } 9687 9688 var sv *AssociateFleetOutput 9689 if *v == nil { 9690 sv = &AssociateFleetOutput{} 9691 } else { 9692 sv = *v 9693 } 9694 9695 for key, value := range shape { 9696 switch key { 9697 default: 9698 _, _ = key, value 9699 9700 } 9701 } 9702 *v = sv 9703 return nil 9704} 9705 9706func awsAwsjson11_deserializeOpDocumentBatchAssociateUserStackOutput(v **BatchAssociateUserStackOutput, value interface{}) error { 9707 if v == nil { 9708 return fmt.Errorf("unexpected nil of type %T", v) 9709 } 9710 if value == nil { 9711 return nil 9712 } 9713 9714 shape, ok := value.(map[string]interface{}) 9715 if !ok { 9716 return fmt.Errorf("unexpected JSON type %v", value) 9717 } 9718 9719 var sv *BatchAssociateUserStackOutput 9720 if *v == nil { 9721 sv = &BatchAssociateUserStackOutput{} 9722 } else { 9723 sv = *v 9724 } 9725 9726 for key, value := range shape { 9727 switch key { 9728 case "errors": 9729 if err := awsAwsjson11_deserializeDocumentUserStackAssociationErrorList(&sv.Errors, value); err != nil { 9730 return err 9731 } 9732 9733 default: 9734 _, _ = key, value 9735 9736 } 9737 } 9738 *v = sv 9739 return nil 9740} 9741 9742func awsAwsjson11_deserializeOpDocumentBatchDisassociateUserStackOutput(v **BatchDisassociateUserStackOutput, value interface{}) error { 9743 if v == nil { 9744 return fmt.Errorf("unexpected nil of type %T", v) 9745 } 9746 if value == nil { 9747 return nil 9748 } 9749 9750 shape, ok := value.(map[string]interface{}) 9751 if !ok { 9752 return fmt.Errorf("unexpected JSON type %v", value) 9753 } 9754 9755 var sv *BatchDisassociateUserStackOutput 9756 if *v == nil { 9757 sv = &BatchDisassociateUserStackOutput{} 9758 } else { 9759 sv = *v 9760 } 9761 9762 for key, value := range shape { 9763 switch key { 9764 case "errors": 9765 if err := awsAwsjson11_deserializeDocumentUserStackAssociationErrorList(&sv.Errors, value); err != nil { 9766 return err 9767 } 9768 9769 default: 9770 _, _ = key, value 9771 9772 } 9773 } 9774 *v = sv 9775 return nil 9776} 9777 9778func awsAwsjson11_deserializeOpDocumentCopyImageOutput(v **CopyImageOutput, value interface{}) error { 9779 if v == nil { 9780 return fmt.Errorf("unexpected nil of type %T", v) 9781 } 9782 if value == nil { 9783 return nil 9784 } 9785 9786 shape, ok := value.(map[string]interface{}) 9787 if !ok { 9788 return fmt.Errorf("unexpected JSON type %v", value) 9789 } 9790 9791 var sv *CopyImageOutput 9792 if *v == nil { 9793 sv = &CopyImageOutput{} 9794 } else { 9795 sv = *v 9796 } 9797 9798 for key, value := range shape { 9799 switch key { 9800 case "DestinationImageName": 9801 if value != nil { 9802 jtv, ok := value.(string) 9803 if !ok { 9804 return fmt.Errorf("expected Name to be of type string, got %T instead", value) 9805 } 9806 sv.DestinationImageName = ptr.String(jtv) 9807 } 9808 9809 default: 9810 _, _ = key, value 9811 9812 } 9813 } 9814 *v = sv 9815 return nil 9816} 9817 9818func awsAwsjson11_deserializeOpDocumentCreateDirectoryConfigOutput(v **CreateDirectoryConfigOutput, value interface{}) error { 9819 if v == nil { 9820 return fmt.Errorf("unexpected nil of type %T", v) 9821 } 9822 if value == nil { 9823 return nil 9824 } 9825 9826 shape, ok := value.(map[string]interface{}) 9827 if !ok { 9828 return fmt.Errorf("unexpected JSON type %v", value) 9829 } 9830 9831 var sv *CreateDirectoryConfigOutput 9832 if *v == nil { 9833 sv = &CreateDirectoryConfigOutput{} 9834 } else { 9835 sv = *v 9836 } 9837 9838 for key, value := range shape { 9839 switch key { 9840 case "DirectoryConfig": 9841 if err := awsAwsjson11_deserializeDocumentDirectoryConfig(&sv.DirectoryConfig, value); err != nil { 9842 return err 9843 } 9844 9845 default: 9846 _, _ = key, value 9847 9848 } 9849 } 9850 *v = sv 9851 return nil 9852} 9853 9854func awsAwsjson11_deserializeOpDocumentCreateFleetOutput(v **CreateFleetOutput, value interface{}) error { 9855 if v == nil { 9856 return fmt.Errorf("unexpected nil of type %T", v) 9857 } 9858 if value == nil { 9859 return nil 9860 } 9861 9862 shape, ok := value.(map[string]interface{}) 9863 if !ok { 9864 return fmt.Errorf("unexpected JSON type %v", value) 9865 } 9866 9867 var sv *CreateFleetOutput 9868 if *v == nil { 9869 sv = &CreateFleetOutput{} 9870 } else { 9871 sv = *v 9872 } 9873 9874 for key, value := range shape { 9875 switch key { 9876 case "Fleet": 9877 if err := awsAwsjson11_deserializeDocumentFleet(&sv.Fleet, value); err != nil { 9878 return err 9879 } 9880 9881 default: 9882 _, _ = key, value 9883 9884 } 9885 } 9886 *v = sv 9887 return nil 9888} 9889 9890func awsAwsjson11_deserializeOpDocumentCreateImageBuilderOutput(v **CreateImageBuilderOutput, value interface{}) error { 9891 if v == nil { 9892 return fmt.Errorf("unexpected nil of type %T", v) 9893 } 9894 if value == nil { 9895 return nil 9896 } 9897 9898 shape, ok := value.(map[string]interface{}) 9899 if !ok { 9900 return fmt.Errorf("unexpected JSON type %v", value) 9901 } 9902 9903 var sv *CreateImageBuilderOutput 9904 if *v == nil { 9905 sv = &CreateImageBuilderOutput{} 9906 } else { 9907 sv = *v 9908 } 9909 9910 for key, value := range shape { 9911 switch key { 9912 case "ImageBuilder": 9913 if err := awsAwsjson11_deserializeDocumentImageBuilder(&sv.ImageBuilder, value); err != nil { 9914 return err 9915 } 9916 9917 default: 9918 _, _ = key, value 9919 9920 } 9921 } 9922 *v = sv 9923 return nil 9924} 9925 9926func awsAwsjson11_deserializeOpDocumentCreateImageBuilderStreamingURLOutput(v **CreateImageBuilderStreamingURLOutput, value interface{}) error { 9927 if v == nil { 9928 return fmt.Errorf("unexpected nil of type %T", v) 9929 } 9930 if value == nil { 9931 return nil 9932 } 9933 9934 shape, ok := value.(map[string]interface{}) 9935 if !ok { 9936 return fmt.Errorf("unexpected JSON type %v", value) 9937 } 9938 9939 var sv *CreateImageBuilderStreamingURLOutput 9940 if *v == nil { 9941 sv = &CreateImageBuilderStreamingURLOutput{} 9942 } else { 9943 sv = *v 9944 } 9945 9946 for key, value := range shape { 9947 switch key { 9948 case "Expires": 9949 if value != nil { 9950 jtv, ok := value.(json.Number) 9951 if !ok { 9952 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 9953 } 9954 f64, err := jtv.Float64() 9955 if err != nil { 9956 return err 9957 } 9958 sv.Expires = ptr.Time(smithytime.ParseEpochSeconds(f64)) 9959 } 9960 9961 case "StreamingURL": 9962 if value != nil { 9963 jtv, ok := value.(string) 9964 if !ok { 9965 return fmt.Errorf("expected String to be of type string, got %T instead", value) 9966 } 9967 sv.StreamingURL = ptr.String(jtv) 9968 } 9969 9970 default: 9971 _, _ = key, value 9972 9973 } 9974 } 9975 *v = sv 9976 return nil 9977} 9978 9979func awsAwsjson11_deserializeOpDocumentCreateStackOutput(v **CreateStackOutput, value interface{}) error { 9980 if v == nil { 9981 return fmt.Errorf("unexpected nil of type %T", v) 9982 } 9983 if value == nil { 9984 return nil 9985 } 9986 9987 shape, ok := value.(map[string]interface{}) 9988 if !ok { 9989 return fmt.Errorf("unexpected JSON type %v", value) 9990 } 9991 9992 var sv *CreateStackOutput 9993 if *v == nil { 9994 sv = &CreateStackOutput{} 9995 } else { 9996 sv = *v 9997 } 9998 9999 for key, value := range shape { 10000 switch key { 10001 case "Stack": 10002 if err := awsAwsjson11_deserializeDocumentStack(&sv.Stack, value); err != nil { 10003 return err 10004 } 10005 10006 default: 10007 _, _ = key, value 10008 10009 } 10010 } 10011 *v = sv 10012 return nil 10013} 10014 10015func awsAwsjson11_deserializeOpDocumentCreateStreamingURLOutput(v **CreateStreamingURLOutput, value interface{}) error { 10016 if v == nil { 10017 return fmt.Errorf("unexpected nil of type %T", v) 10018 } 10019 if value == nil { 10020 return nil 10021 } 10022 10023 shape, ok := value.(map[string]interface{}) 10024 if !ok { 10025 return fmt.Errorf("unexpected JSON type %v", value) 10026 } 10027 10028 var sv *CreateStreamingURLOutput 10029 if *v == nil { 10030 sv = &CreateStreamingURLOutput{} 10031 } else { 10032 sv = *v 10033 } 10034 10035 for key, value := range shape { 10036 switch key { 10037 case "Expires": 10038 if value != nil { 10039 jtv, ok := value.(json.Number) 10040 if !ok { 10041 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 10042 } 10043 f64, err := jtv.Float64() 10044 if err != nil { 10045 return err 10046 } 10047 sv.Expires = ptr.Time(smithytime.ParseEpochSeconds(f64)) 10048 } 10049 10050 case "StreamingURL": 10051 if value != nil { 10052 jtv, ok := value.(string) 10053 if !ok { 10054 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10055 } 10056 sv.StreamingURL = ptr.String(jtv) 10057 } 10058 10059 default: 10060 _, _ = key, value 10061 10062 } 10063 } 10064 *v = sv 10065 return nil 10066} 10067 10068func awsAwsjson11_deserializeOpDocumentCreateUpdatedImageOutput(v **CreateUpdatedImageOutput, value interface{}) error { 10069 if v == nil { 10070 return fmt.Errorf("unexpected nil of type %T", v) 10071 } 10072 if value == nil { 10073 return nil 10074 } 10075 10076 shape, ok := value.(map[string]interface{}) 10077 if !ok { 10078 return fmt.Errorf("unexpected JSON type %v", value) 10079 } 10080 10081 var sv *CreateUpdatedImageOutput 10082 if *v == nil { 10083 sv = &CreateUpdatedImageOutput{} 10084 } else { 10085 sv = *v 10086 } 10087 10088 for key, value := range shape { 10089 switch key { 10090 case "canUpdateImage": 10091 if value != nil { 10092 jtv, ok := value.(bool) 10093 if !ok { 10094 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 10095 } 10096 sv.CanUpdateImage = jtv 10097 } 10098 10099 case "image": 10100 if err := awsAwsjson11_deserializeDocumentImage(&sv.Image, value); err != nil { 10101 return err 10102 } 10103 10104 default: 10105 _, _ = key, value 10106 10107 } 10108 } 10109 *v = sv 10110 return nil 10111} 10112 10113func awsAwsjson11_deserializeOpDocumentCreateUsageReportSubscriptionOutput(v **CreateUsageReportSubscriptionOutput, value interface{}) error { 10114 if v == nil { 10115 return fmt.Errorf("unexpected nil of type %T", v) 10116 } 10117 if value == nil { 10118 return nil 10119 } 10120 10121 shape, ok := value.(map[string]interface{}) 10122 if !ok { 10123 return fmt.Errorf("unexpected JSON type %v", value) 10124 } 10125 10126 var sv *CreateUsageReportSubscriptionOutput 10127 if *v == nil { 10128 sv = &CreateUsageReportSubscriptionOutput{} 10129 } else { 10130 sv = *v 10131 } 10132 10133 for key, value := range shape { 10134 switch key { 10135 case "S3BucketName": 10136 if value != nil { 10137 jtv, ok := value.(string) 10138 if !ok { 10139 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10140 } 10141 sv.S3BucketName = ptr.String(jtv) 10142 } 10143 10144 case "Schedule": 10145 if value != nil { 10146 jtv, ok := value.(string) 10147 if !ok { 10148 return fmt.Errorf("expected UsageReportSchedule to be of type string, got %T instead", value) 10149 } 10150 sv.Schedule = types.UsageReportSchedule(jtv) 10151 } 10152 10153 default: 10154 _, _ = key, value 10155 10156 } 10157 } 10158 *v = sv 10159 return nil 10160} 10161 10162func awsAwsjson11_deserializeOpDocumentCreateUserOutput(v **CreateUserOutput, value interface{}) error { 10163 if v == nil { 10164 return fmt.Errorf("unexpected nil of type %T", v) 10165 } 10166 if value == nil { 10167 return nil 10168 } 10169 10170 shape, ok := value.(map[string]interface{}) 10171 if !ok { 10172 return fmt.Errorf("unexpected JSON type %v", value) 10173 } 10174 10175 var sv *CreateUserOutput 10176 if *v == nil { 10177 sv = &CreateUserOutput{} 10178 } else { 10179 sv = *v 10180 } 10181 10182 for key, value := range shape { 10183 switch key { 10184 default: 10185 _, _ = key, value 10186 10187 } 10188 } 10189 *v = sv 10190 return nil 10191} 10192 10193func awsAwsjson11_deserializeOpDocumentDeleteDirectoryConfigOutput(v **DeleteDirectoryConfigOutput, value interface{}) error { 10194 if v == nil { 10195 return fmt.Errorf("unexpected nil of type %T", v) 10196 } 10197 if value == nil { 10198 return nil 10199 } 10200 10201 shape, ok := value.(map[string]interface{}) 10202 if !ok { 10203 return fmt.Errorf("unexpected JSON type %v", value) 10204 } 10205 10206 var sv *DeleteDirectoryConfigOutput 10207 if *v == nil { 10208 sv = &DeleteDirectoryConfigOutput{} 10209 } else { 10210 sv = *v 10211 } 10212 10213 for key, value := range shape { 10214 switch key { 10215 default: 10216 _, _ = key, value 10217 10218 } 10219 } 10220 *v = sv 10221 return nil 10222} 10223 10224func awsAwsjson11_deserializeOpDocumentDeleteFleetOutput(v **DeleteFleetOutput, value interface{}) error { 10225 if v == nil { 10226 return fmt.Errorf("unexpected nil of type %T", v) 10227 } 10228 if value == nil { 10229 return nil 10230 } 10231 10232 shape, ok := value.(map[string]interface{}) 10233 if !ok { 10234 return fmt.Errorf("unexpected JSON type %v", value) 10235 } 10236 10237 var sv *DeleteFleetOutput 10238 if *v == nil { 10239 sv = &DeleteFleetOutput{} 10240 } else { 10241 sv = *v 10242 } 10243 10244 for key, value := range shape { 10245 switch key { 10246 default: 10247 _, _ = key, value 10248 10249 } 10250 } 10251 *v = sv 10252 return nil 10253} 10254 10255func awsAwsjson11_deserializeOpDocumentDeleteImageBuilderOutput(v **DeleteImageBuilderOutput, value interface{}) error { 10256 if v == nil { 10257 return fmt.Errorf("unexpected nil of type %T", v) 10258 } 10259 if value == nil { 10260 return nil 10261 } 10262 10263 shape, ok := value.(map[string]interface{}) 10264 if !ok { 10265 return fmt.Errorf("unexpected JSON type %v", value) 10266 } 10267 10268 var sv *DeleteImageBuilderOutput 10269 if *v == nil { 10270 sv = &DeleteImageBuilderOutput{} 10271 } else { 10272 sv = *v 10273 } 10274 10275 for key, value := range shape { 10276 switch key { 10277 case "ImageBuilder": 10278 if err := awsAwsjson11_deserializeDocumentImageBuilder(&sv.ImageBuilder, value); err != nil { 10279 return err 10280 } 10281 10282 default: 10283 _, _ = key, value 10284 10285 } 10286 } 10287 *v = sv 10288 return nil 10289} 10290 10291func awsAwsjson11_deserializeOpDocumentDeleteImageOutput(v **DeleteImageOutput, value interface{}) error { 10292 if v == nil { 10293 return fmt.Errorf("unexpected nil of type %T", v) 10294 } 10295 if value == nil { 10296 return nil 10297 } 10298 10299 shape, ok := value.(map[string]interface{}) 10300 if !ok { 10301 return fmt.Errorf("unexpected JSON type %v", value) 10302 } 10303 10304 var sv *DeleteImageOutput 10305 if *v == nil { 10306 sv = &DeleteImageOutput{} 10307 } else { 10308 sv = *v 10309 } 10310 10311 for key, value := range shape { 10312 switch key { 10313 case "Image": 10314 if err := awsAwsjson11_deserializeDocumentImage(&sv.Image, value); err != nil { 10315 return err 10316 } 10317 10318 default: 10319 _, _ = key, value 10320 10321 } 10322 } 10323 *v = sv 10324 return nil 10325} 10326 10327func awsAwsjson11_deserializeOpDocumentDeleteImagePermissionsOutput(v **DeleteImagePermissionsOutput, value interface{}) error { 10328 if v == nil { 10329 return fmt.Errorf("unexpected nil of type %T", v) 10330 } 10331 if value == nil { 10332 return nil 10333 } 10334 10335 shape, ok := value.(map[string]interface{}) 10336 if !ok { 10337 return fmt.Errorf("unexpected JSON type %v", value) 10338 } 10339 10340 var sv *DeleteImagePermissionsOutput 10341 if *v == nil { 10342 sv = &DeleteImagePermissionsOutput{} 10343 } else { 10344 sv = *v 10345 } 10346 10347 for key, value := range shape { 10348 switch key { 10349 default: 10350 _, _ = key, value 10351 10352 } 10353 } 10354 *v = sv 10355 return nil 10356} 10357 10358func awsAwsjson11_deserializeOpDocumentDeleteStackOutput(v **DeleteStackOutput, value interface{}) error { 10359 if v == nil { 10360 return fmt.Errorf("unexpected nil of type %T", v) 10361 } 10362 if value == nil { 10363 return nil 10364 } 10365 10366 shape, ok := value.(map[string]interface{}) 10367 if !ok { 10368 return fmt.Errorf("unexpected JSON type %v", value) 10369 } 10370 10371 var sv *DeleteStackOutput 10372 if *v == nil { 10373 sv = &DeleteStackOutput{} 10374 } else { 10375 sv = *v 10376 } 10377 10378 for key, value := range shape { 10379 switch key { 10380 default: 10381 _, _ = key, value 10382 10383 } 10384 } 10385 *v = sv 10386 return nil 10387} 10388 10389func awsAwsjson11_deserializeOpDocumentDeleteUsageReportSubscriptionOutput(v **DeleteUsageReportSubscriptionOutput, value interface{}) error { 10390 if v == nil { 10391 return fmt.Errorf("unexpected nil of type %T", v) 10392 } 10393 if value == nil { 10394 return nil 10395 } 10396 10397 shape, ok := value.(map[string]interface{}) 10398 if !ok { 10399 return fmt.Errorf("unexpected JSON type %v", value) 10400 } 10401 10402 var sv *DeleteUsageReportSubscriptionOutput 10403 if *v == nil { 10404 sv = &DeleteUsageReportSubscriptionOutput{} 10405 } else { 10406 sv = *v 10407 } 10408 10409 for key, value := range shape { 10410 switch key { 10411 default: 10412 _, _ = key, value 10413 10414 } 10415 } 10416 *v = sv 10417 return nil 10418} 10419 10420func awsAwsjson11_deserializeOpDocumentDeleteUserOutput(v **DeleteUserOutput, value interface{}) error { 10421 if v == nil { 10422 return fmt.Errorf("unexpected nil of type %T", v) 10423 } 10424 if value == nil { 10425 return nil 10426 } 10427 10428 shape, ok := value.(map[string]interface{}) 10429 if !ok { 10430 return fmt.Errorf("unexpected JSON type %v", value) 10431 } 10432 10433 var sv *DeleteUserOutput 10434 if *v == nil { 10435 sv = &DeleteUserOutput{} 10436 } else { 10437 sv = *v 10438 } 10439 10440 for key, value := range shape { 10441 switch key { 10442 default: 10443 _, _ = key, value 10444 10445 } 10446 } 10447 *v = sv 10448 return nil 10449} 10450 10451func awsAwsjson11_deserializeOpDocumentDescribeDirectoryConfigsOutput(v **DescribeDirectoryConfigsOutput, value interface{}) error { 10452 if v == nil { 10453 return fmt.Errorf("unexpected nil of type %T", v) 10454 } 10455 if value == nil { 10456 return nil 10457 } 10458 10459 shape, ok := value.(map[string]interface{}) 10460 if !ok { 10461 return fmt.Errorf("unexpected JSON type %v", value) 10462 } 10463 10464 var sv *DescribeDirectoryConfigsOutput 10465 if *v == nil { 10466 sv = &DescribeDirectoryConfigsOutput{} 10467 } else { 10468 sv = *v 10469 } 10470 10471 for key, value := range shape { 10472 switch key { 10473 case "DirectoryConfigs": 10474 if err := awsAwsjson11_deserializeDocumentDirectoryConfigList(&sv.DirectoryConfigs, value); err != nil { 10475 return err 10476 } 10477 10478 case "NextToken": 10479 if value != nil { 10480 jtv, ok := value.(string) 10481 if !ok { 10482 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10483 } 10484 sv.NextToken = ptr.String(jtv) 10485 } 10486 10487 default: 10488 _, _ = key, value 10489 10490 } 10491 } 10492 *v = sv 10493 return nil 10494} 10495 10496func awsAwsjson11_deserializeOpDocumentDescribeFleetsOutput(v **DescribeFleetsOutput, 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.(map[string]interface{}) 10505 if !ok { 10506 return fmt.Errorf("unexpected JSON type %v", value) 10507 } 10508 10509 var sv *DescribeFleetsOutput 10510 if *v == nil { 10511 sv = &DescribeFleetsOutput{} 10512 } else { 10513 sv = *v 10514 } 10515 10516 for key, value := range shape { 10517 switch key { 10518 case "Fleets": 10519 if err := awsAwsjson11_deserializeDocumentFleetList(&sv.Fleets, value); err != nil { 10520 return err 10521 } 10522 10523 case "NextToken": 10524 if value != nil { 10525 jtv, ok := value.(string) 10526 if !ok { 10527 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10528 } 10529 sv.NextToken = ptr.String(jtv) 10530 } 10531 10532 default: 10533 _, _ = key, value 10534 10535 } 10536 } 10537 *v = sv 10538 return nil 10539} 10540 10541func awsAwsjson11_deserializeOpDocumentDescribeImageBuildersOutput(v **DescribeImageBuildersOutput, value interface{}) error { 10542 if v == nil { 10543 return fmt.Errorf("unexpected nil of type %T", v) 10544 } 10545 if value == nil { 10546 return nil 10547 } 10548 10549 shape, ok := value.(map[string]interface{}) 10550 if !ok { 10551 return fmt.Errorf("unexpected JSON type %v", value) 10552 } 10553 10554 var sv *DescribeImageBuildersOutput 10555 if *v == nil { 10556 sv = &DescribeImageBuildersOutput{} 10557 } else { 10558 sv = *v 10559 } 10560 10561 for key, value := range shape { 10562 switch key { 10563 case "ImageBuilders": 10564 if err := awsAwsjson11_deserializeDocumentImageBuilderList(&sv.ImageBuilders, value); err != nil { 10565 return err 10566 } 10567 10568 case "NextToken": 10569 if value != nil { 10570 jtv, ok := value.(string) 10571 if !ok { 10572 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10573 } 10574 sv.NextToken = ptr.String(jtv) 10575 } 10576 10577 default: 10578 _, _ = key, value 10579 10580 } 10581 } 10582 *v = sv 10583 return nil 10584} 10585 10586func awsAwsjson11_deserializeOpDocumentDescribeImagePermissionsOutput(v **DescribeImagePermissionsOutput, value interface{}) error { 10587 if v == nil { 10588 return fmt.Errorf("unexpected nil of type %T", v) 10589 } 10590 if value == nil { 10591 return nil 10592 } 10593 10594 shape, ok := value.(map[string]interface{}) 10595 if !ok { 10596 return fmt.Errorf("unexpected JSON type %v", value) 10597 } 10598 10599 var sv *DescribeImagePermissionsOutput 10600 if *v == nil { 10601 sv = &DescribeImagePermissionsOutput{} 10602 } else { 10603 sv = *v 10604 } 10605 10606 for key, value := range shape { 10607 switch key { 10608 case "Name": 10609 if value != nil { 10610 jtv, ok := value.(string) 10611 if !ok { 10612 return fmt.Errorf("expected Name to be of type string, got %T instead", value) 10613 } 10614 sv.Name = ptr.String(jtv) 10615 } 10616 10617 case "NextToken": 10618 if value != nil { 10619 jtv, ok := value.(string) 10620 if !ok { 10621 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10622 } 10623 sv.NextToken = ptr.String(jtv) 10624 } 10625 10626 case "SharedImagePermissionsList": 10627 if err := awsAwsjson11_deserializeDocumentSharedImagePermissionsList(&sv.SharedImagePermissionsList, value); err != nil { 10628 return err 10629 } 10630 10631 default: 10632 _, _ = key, value 10633 10634 } 10635 } 10636 *v = sv 10637 return nil 10638} 10639 10640func awsAwsjson11_deserializeOpDocumentDescribeImagesOutput(v **DescribeImagesOutput, value interface{}) error { 10641 if v == nil { 10642 return fmt.Errorf("unexpected nil of type %T", v) 10643 } 10644 if value == nil { 10645 return nil 10646 } 10647 10648 shape, ok := value.(map[string]interface{}) 10649 if !ok { 10650 return fmt.Errorf("unexpected JSON type %v", value) 10651 } 10652 10653 var sv *DescribeImagesOutput 10654 if *v == nil { 10655 sv = &DescribeImagesOutput{} 10656 } else { 10657 sv = *v 10658 } 10659 10660 for key, value := range shape { 10661 switch key { 10662 case "Images": 10663 if err := awsAwsjson11_deserializeDocumentImageList(&sv.Images, value); err != nil { 10664 return err 10665 } 10666 10667 case "NextToken": 10668 if value != nil { 10669 jtv, ok := value.(string) 10670 if !ok { 10671 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10672 } 10673 sv.NextToken = ptr.String(jtv) 10674 } 10675 10676 default: 10677 _, _ = key, value 10678 10679 } 10680 } 10681 *v = sv 10682 return nil 10683} 10684 10685func awsAwsjson11_deserializeOpDocumentDescribeSessionsOutput(v **DescribeSessionsOutput, value interface{}) error { 10686 if v == nil { 10687 return fmt.Errorf("unexpected nil of type %T", v) 10688 } 10689 if value == nil { 10690 return nil 10691 } 10692 10693 shape, ok := value.(map[string]interface{}) 10694 if !ok { 10695 return fmt.Errorf("unexpected JSON type %v", value) 10696 } 10697 10698 var sv *DescribeSessionsOutput 10699 if *v == nil { 10700 sv = &DescribeSessionsOutput{} 10701 } else { 10702 sv = *v 10703 } 10704 10705 for key, value := range shape { 10706 switch key { 10707 case "NextToken": 10708 if value != nil { 10709 jtv, ok := value.(string) 10710 if !ok { 10711 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10712 } 10713 sv.NextToken = ptr.String(jtv) 10714 } 10715 10716 case "Sessions": 10717 if err := awsAwsjson11_deserializeDocumentSessionList(&sv.Sessions, value); err != nil { 10718 return err 10719 } 10720 10721 default: 10722 _, _ = key, value 10723 10724 } 10725 } 10726 *v = sv 10727 return nil 10728} 10729 10730func awsAwsjson11_deserializeOpDocumentDescribeStacksOutput(v **DescribeStacksOutput, value interface{}) error { 10731 if v == nil { 10732 return fmt.Errorf("unexpected nil of type %T", v) 10733 } 10734 if value == nil { 10735 return nil 10736 } 10737 10738 shape, ok := value.(map[string]interface{}) 10739 if !ok { 10740 return fmt.Errorf("unexpected JSON type %v", value) 10741 } 10742 10743 var sv *DescribeStacksOutput 10744 if *v == nil { 10745 sv = &DescribeStacksOutput{} 10746 } else { 10747 sv = *v 10748 } 10749 10750 for key, value := range shape { 10751 switch key { 10752 case "NextToken": 10753 if value != nil { 10754 jtv, ok := value.(string) 10755 if !ok { 10756 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10757 } 10758 sv.NextToken = ptr.String(jtv) 10759 } 10760 10761 case "Stacks": 10762 if err := awsAwsjson11_deserializeDocumentStackList(&sv.Stacks, value); err != nil { 10763 return err 10764 } 10765 10766 default: 10767 _, _ = key, value 10768 10769 } 10770 } 10771 *v = sv 10772 return nil 10773} 10774 10775func awsAwsjson11_deserializeOpDocumentDescribeUsageReportSubscriptionsOutput(v **DescribeUsageReportSubscriptionsOutput, value interface{}) error { 10776 if v == nil { 10777 return fmt.Errorf("unexpected nil of type %T", v) 10778 } 10779 if value == nil { 10780 return nil 10781 } 10782 10783 shape, ok := value.(map[string]interface{}) 10784 if !ok { 10785 return fmt.Errorf("unexpected JSON type %v", value) 10786 } 10787 10788 var sv *DescribeUsageReportSubscriptionsOutput 10789 if *v == nil { 10790 sv = &DescribeUsageReportSubscriptionsOutput{} 10791 } else { 10792 sv = *v 10793 } 10794 10795 for key, value := range shape { 10796 switch key { 10797 case "NextToken": 10798 if value != nil { 10799 jtv, ok := value.(string) 10800 if !ok { 10801 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10802 } 10803 sv.NextToken = ptr.String(jtv) 10804 } 10805 10806 case "UsageReportSubscriptions": 10807 if err := awsAwsjson11_deserializeDocumentUsageReportSubscriptionList(&sv.UsageReportSubscriptions, value); err != nil { 10808 return err 10809 } 10810 10811 default: 10812 _, _ = key, value 10813 10814 } 10815 } 10816 *v = sv 10817 return nil 10818} 10819 10820func awsAwsjson11_deserializeOpDocumentDescribeUsersOutput(v **DescribeUsersOutput, value interface{}) error { 10821 if v == nil { 10822 return fmt.Errorf("unexpected nil of type %T", v) 10823 } 10824 if value == nil { 10825 return nil 10826 } 10827 10828 shape, ok := value.(map[string]interface{}) 10829 if !ok { 10830 return fmt.Errorf("unexpected JSON type %v", value) 10831 } 10832 10833 var sv *DescribeUsersOutput 10834 if *v == nil { 10835 sv = &DescribeUsersOutput{} 10836 } else { 10837 sv = *v 10838 } 10839 10840 for key, value := range shape { 10841 switch key { 10842 case "NextToken": 10843 if value != nil { 10844 jtv, ok := value.(string) 10845 if !ok { 10846 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10847 } 10848 sv.NextToken = ptr.String(jtv) 10849 } 10850 10851 case "Users": 10852 if err := awsAwsjson11_deserializeDocumentUserList(&sv.Users, value); err != nil { 10853 return err 10854 } 10855 10856 default: 10857 _, _ = key, value 10858 10859 } 10860 } 10861 *v = sv 10862 return nil 10863} 10864 10865func awsAwsjson11_deserializeOpDocumentDescribeUserStackAssociationsOutput(v **DescribeUserStackAssociationsOutput, value interface{}) error { 10866 if v == nil { 10867 return fmt.Errorf("unexpected nil of type %T", v) 10868 } 10869 if value == nil { 10870 return nil 10871 } 10872 10873 shape, ok := value.(map[string]interface{}) 10874 if !ok { 10875 return fmt.Errorf("unexpected JSON type %v", value) 10876 } 10877 10878 var sv *DescribeUserStackAssociationsOutput 10879 if *v == nil { 10880 sv = &DescribeUserStackAssociationsOutput{} 10881 } else { 10882 sv = *v 10883 } 10884 10885 for key, value := range shape { 10886 switch key { 10887 case "NextToken": 10888 if value != nil { 10889 jtv, ok := value.(string) 10890 if !ok { 10891 return fmt.Errorf("expected String to be of type string, got %T instead", value) 10892 } 10893 sv.NextToken = ptr.String(jtv) 10894 } 10895 10896 case "UserStackAssociations": 10897 if err := awsAwsjson11_deserializeDocumentUserStackAssociationList(&sv.UserStackAssociations, value); err != nil { 10898 return err 10899 } 10900 10901 default: 10902 _, _ = key, value 10903 10904 } 10905 } 10906 *v = sv 10907 return nil 10908} 10909 10910func awsAwsjson11_deserializeOpDocumentDisableUserOutput(v **DisableUserOutput, value interface{}) error { 10911 if v == nil { 10912 return fmt.Errorf("unexpected nil of type %T", v) 10913 } 10914 if value == nil { 10915 return nil 10916 } 10917 10918 shape, ok := value.(map[string]interface{}) 10919 if !ok { 10920 return fmt.Errorf("unexpected JSON type %v", value) 10921 } 10922 10923 var sv *DisableUserOutput 10924 if *v == nil { 10925 sv = &DisableUserOutput{} 10926 } else { 10927 sv = *v 10928 } 10929 10930 for key, value := range shape { 10931 switch key { 10932 default: 10933 _, _ = key, value 10934 10935 } 10936 } 10937 *v = sv 10938 return nil 10939} 10940 10941func awsAwsjson11_deserializeOpDocumentDisassociateFleetOutput(v **DisassociateFleetOutput, value interface{}) error { 10942 if v == nil { 10943 return fmt.Errorf("unexpected nil of type %T", v) 10944 } 10945 if value == nil { 10946 return nil 10947 } 10948 10949 shape, ok := value.(map[string]interface{}) 10950 if !ok { 10951 return fmt.Errorf("unexpected JSON type %v", value) 10952 } 10953 10954 var sv *DisassociateFleetOutput 10955 if *v == nil { 10956 sv = &DisassociateFleetOutput{} 10957 } else { 10958 sv = *v 10959 } 10960 10961 for key, value := range shape { 10962 switch key { 10963 default: 10964 _, _ = key, value 10965 10966 } 10967 } 10968 *v = sv 10969 return nil 10970} 10971 10972func awsAwsjson11_deserializeOpDocumentEnableUserOutput(v **EnableUserOutput, 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.(map[string]interface{}) 10981 if !ok { 10982 return fmt.Errorf("unexpected JSON type %v", value) 10983 } 10984 10985 var sv *EnableUserOutput 10986 if *v == nil { 10987 sv = &EnableUserOutput{} 10988 } else { 10989 sv = *v 10990 } 10991 10992 for key, value := range shape { 10993 switch key { 10994 default: 10995 _, _ = key, value 10996 10997 } 10998 } 10999 *v = sv 11000 return nil 11001} 11002 11003func awsAwsjson11_deserializeOpDocumentExpireSessionOutput(v **ExpireSessionOutput, value interface{}) error { 11004 if v == nil { 11005 return fmt.Errorf("unexpected nil of type %T", v) 11006 } 11007 if value == nil { 11008 return nil 11009 } 11010 11011 shape, ok := value.(map[string]interface{}) 11012 if !ok { 11013 return fmt.Errorf("unexpected JSON type %v", value) 11014 } 11015 11016 var sv *ExpireSessionOutput 11017 if *v == nil { 11018 sv = &ExpireSessionOutput{} 11019 } else { 11020 sv = *v 11021 } 11022 11023 for key, value := range shape { 11024 switch key { 11025 default: 11026 _, _ = key, value 11027 11028 } 11029 } 11030 *v = sv 11031 return nil 11032} 11033 11034func awsAwsjson11_deserializeOpDocumentListAssociatedFleetsOutput(v **ListAssociatedFleetsOutput, value interface{}) error { 11035 if v == nil { 11036 return fmt.Errorf("unexpected nil of type %T", v) 11037 } 11038 if value == nil { 11039 return nil 11040 } 11041 11042 shape, ok := value.(map[string]interface{}) 11043 if !ok { 11044 return fmt.Errorf("unexpected JSON type %v", value) 11045 } 11046 11047 var sv *ListAssociatedFleetsOutput 11048 if *v == nil { 11049 sv = &ListAssociatedFleetsOutput{} 11050 } else { 11051 sv = *v 11052 } 11053 11054 for key, value := range shape { 11055 switch key { 11056 case "Names": 11057 if err := awsAwsjson11_deserializeDocumentStringList(&sv.Names, value); err != nil { 11058 return err 11059 } 11060 11061 case "NextToken": 11062 if value != nil { 11063 jtv, ok := value.(string) 11064 if !ok { 11065 return fmt.Errorf("expected String to be of type string, got %T instead", value) 11066 } 11067 sv.NextToken = ptr.String(jtv) 11068 } 11069 11070 default: 11071 _, _ = key, value 11072 11073 } 11074 } 11075 *v = sv 11076 return nil 11077} 11078 11079func awsAwsjson11_deserializeOpDocumentListAssociatedStacksOutput(v **ListAssociatedStacksOutput, value interface{}) error { 11080 if v == nil { 11081 return fmt.Errorf("unexpected nil of type %T", v) 11082 } 11083 if value == nil { 11084 return nil 11085 } 11086 11087 shape, ok := value.(map[string]interface{}) 11088 if !ok { 11089 return fmt.Errorf("unexpected JSON type %v", value) 11090 } 11091 11092 var sv *ListAssociatedStacksOutput 11093 if *v == nil { 11094 sv = &ListAssociatedStacksOutput{} 11095 } else { 11096 sv = *v 11097 } 11098 11099 for key, value := range shape { 11100 switch key { 11101 case "Names": 11102 if err := awsAwsjson11_deserializeDocumentStringList(&sv.Names, value); err != nil { 11103 return err 11104 } 11105 11106 case "NextToken": 11107 if value != nil { 11108 jtv, ok := value.(string) 11109 if !ok { 11110 return fmt.Errorf("expected String to be of type string, got %T instead", value) 11111 } 11112 sv.NextToken = ptr.String(jtv) 11113 } 11114 11115 default: 11116 _, _ = key, value 11117 11118 } 11119 } 11120 *v = sv 11121 return nil 11122} 11123 11124func awsAwsjson11_deserializeOpDocumentListTagsForResourceOutput(v **ListTagsForResourceOutput, value interface{}) error { 11125 if v == nil { 11126 return fmt.Errorf("unexpected nil of type %T", v) 11127 } 11128 if value == nil { 11129 return nil 11130 } 11131 11132 shape, ok := value.(map[string]interface{}) 11133 if !ok { 11134 return fmt.Errorf("unexpected JSON type %v", value) 11135 } 11136 11137 var sv *ListTagsForResourceOutput 11138 if *v == nil { 11139 sv = &ListTagsForResourceOutput{} 11140 } else { 11141 sv = *v 11142 } 11143 11144 for key, value := range shape { 11145 switch key { 11146 case "Tags": 11147 if err := awsAwsjson11_deserializeDocumentTags(&sv.Tags, value); err != nil { 11148 return err 11149 } 11150 11151 default: 11152 _, _ = key, value 11153 11154 } 11155 } 11156 *v = sv 11157 return nil 11158} 11159 11160func awsAwsjson11_deserializeOpDocumentStartFleetOutput(v **StartFleetOutput, value interface{}) error { 11161 if v == nil { 11162 return fmt.Errorf("unexpected nil of type %T", v) 11163 } 11164 if value == nil { 11165 return nil 11166 } 11167 11168 shape, ok := value.(map[string]interface{}) 11169 if !ok { 11170 return fmt.Errorf("unexpected JSON type %v", value) 11171 } 11172 11173 var sv *StartFleetOutput 11174 if *v == nil { 11175 sv = &StartFleetOutput{} 11176 } else { 11177 sv = *v 11178 } 11179 11180 for key, value := range shape { 11181 switch key { 11182 default: 11183 _, _ = key, value 11184 11185 } 11186 } 11187 *v = sv 11188 return nil 11189} 11190 11191func awsAwsjson11_deserializeOpDocumentStartImageBuilderOutput(v **StartImageBuilderOutput, value interface{}) error { 11192 if v == nil { 11193 return fmt.Errorf("unexpected nil of type %T", v) 11194 } 11195 if value == nil { 11196 return nil 11197 } 11198 11199 shape, ok := value.(map[string]interface{}) 11200 if !ok { 11201 return fmt.Errorf("unexpected JSON type %v", value) 11202 } 11203 11204 var sv *StartImageBuilderOutput 11205 if *v == nil { 11206 sv = &StartImageBuilderOutput{} 11207 } else { 11208 sv = *v 11209 } 11210 11211 for key, value := range shape { 11212 switch key { 11213 case "ImageBuilder": 11214 if err := awsAwsjson11_deserializeDocumentImageBuilder(&sv.ImageBuilder, value); err != nil { 11215 return err 11216 } 11217 11218 default: 11219 _, _ = key, value 11220 11221 } 11222 } 11223 *v = sv 11224 return nil 11225} 11226 11227func awsAwsjson11_deserializeOpDocumentStopFleetOutput(v **StopFleetOutput, value interface{}) error { 11228 if v == nil { 11229 return fmt.Errorf("unexpected nil of type %T", v) 11230 } 11231 if value == nil { 11232 return nil 11233 } 11234 11235 shape, ok := value.(map[string]interface{}) 11236 if !ok { 11237 return fmt.Errorf("unexpected JSON type %v", value) 11238 } 11239 11240 var sv *StopFleetOutput 11241 if *v == nil { 11242 sv = &StopFleetOutput{} 11243 } else { 11244 sv = *v 11245 } 11246 11247 for key, value := range shape { 11248 switch key { 11249 default: 11250 _, _ = key, value 11251 11252 } 11253 } 11254 *v = sv 11255 return nil 11256} 11257 11258func awsAwsjson11_deserializeOpDocumentStopImageBuilderOutput(v **StopImageBuilderOutput, value interface{}) error { 11259 if v == nil { 11260 return fmt.Errorf("unexpected nil of type %T", v) 11261 } 11262 if value == nil { 11263 return nil 11264 } 11265 11266 shape, ok := value.(map[string]interface{}) 11267 if !ok { 11268 return fmt.Errorf("unexpected JSON type %v", value) 11269 } 11270 11271 var sv *StopImageBuilderOutput 11272 if *v == nil { 11273 sv = &StopImageBuilderOutput{} 11274 } else { 11275 sv = *v 11276 } 11277 11278 for key, value := range shape { 11279 switch key { 11280 case "ImageBuilder": 11281 if err := awsAwsjson11_deserializeDocumentImageBuilder(&sv.ImageBuilder, value); err != nil { 11282 return err 11283 } 11284 11285 default: 11286 _, _ = key, value 11287 11288 } 11289 } 11290 *v = sv 11291 return nil 11292} 11293 11294func awsAwsjson11_deserializeOpDocumentTagResourceOutput(v **TagResourceOutput, value interface{}) error { 11295 if v == nil { 11296 return fmt.Errorf("unexpected nil of type %T", v) 11297 } 11298 if value == nil { 11299 return nil 11300 } 11301 11302 shape, ok := value.(map[string]interface{}) 11303 if !ok { 11304 return fmt.Errorf("unexpected JSON type %v", value) 11305 } 11306 11307 var sv *TagResourceOutput 11308 if *v == nil { 11309 sv = &TagResourceOutput{} 11310 } else { 11311 sv = *v 11312 } 11313 11314 for key, value := range shape { 11315 switch key { 11316 default: 11317 _, _ = key, value 11318 11319 } 11320 } 11321 *v = sv 11322 return nil 11323} 11324 11325func awsAwsjson11_deserializeOpDocumentUntagResourceOutput(v **UntagResourceOutput, value interface{}) error { 11326 if v == nil { 11327 return fmt.Errorf("unexpected nil of type %T", v) 11328 } 11329 if value == nil { 11330 return nil 11331 } 11332 11333 shape, ok := value.(map[string]interface{}) 11334 if !ok { 11335 return fmt.Errorf("unexpected JSON type %v", value) 11336 } 11337 11338 var sv *UntagResourceOutput 11339 if *v == nil { 11340 sv = &UntagResourceOutput{} 11341 } else { 11342 sv = *v 11343 } 11344 11345 for key, value := range shape { 11346 switch key { 11347 default: 11348 _, _ = key, value 11349 11350 } 11351 } 11352 *v = sv 11353 return nil 11354} 11355 11356func awsAwsjson11_deserializeOpDocumentUpdateDirectoryConfigOutput(v **UpdateDirectoryConfigOutput, value interface{}) error { 11357 if v == nil { 11358 return fmt.Errorf("unexpected nil of type %T", v) 11359 } 11360 if value == nil { 11361 return nil 11362 } 11363 11364 shape, ok := value.(map[string]interface{}) 11365 if !ok { 11366 return fmt.Errorf("unexpected JSON type %v", value) 11367 } 11368 11369 var sv *UpdateDirectoryConfigOutput 11370 if *v == nil { 11371 sv = &UpdateDirectoryConfigOutput{} 11372 } else { 11373 sv = *v 11374 } 11375 11376 for key, value := range shape { 11377 switch key { 11378 case "DirectoryConfig": 11379 if err := awsAwsjson11_deserializeDocumentDirectoryConfig(&sv.DirectoryConfig, value); err != nil { 11380 return err 11381 } 11382 11383 default: 11384 _, _ = key, value 11385 11386 } 11387 } 11388 *v = sv 11389 return nil 11390} 11391 11392func awsAwsjson11_deserializeOpDocumentUpdateFleetOutput(v **UpdateFleetOutput, value interface{}) error { 11393 if v == nil { 11394 return fmt.Errorf("unexpected nil of type %T", v) 11395 } 11396 if value == nil { 11397 return nil 11398 } 11399 11400 shape, ok := value.(map[string]interface{}) 11401 if !ok { 11402 return fmt.Errorf("unexpected JSON type %v", value) 11403 } 11404 11405 var sv *UpdateFleetOutput 11406 if *v == nil { 11407 sv = &UpdateFleetOutput{} 11408 } else { 11409 sv = *v 11410 } 11411 11412 for key, value := range shape { 11413 switch key { 11414 case "Fleet": 11415 if err := awsAwsjson11_deserializeDocumentFleet(&sv.Fleet, value); err != nil { 11416 return err 11417 } 11418 11419 default: 11420 _, _ = key, value 11421 11422 } 11423 } 11424 *v = sv 11425 return nil 11426} 11427 11428func awsAwsjson11_deserializeOpDocumentUpdateImagePermissionsOutput(v **UpdateImagePermissionsOutput, value interface{}) error { 11429 if v == nil { 11430 return fmt.Errorf("unexpected nil of type %T", v) 11431 } 11432 if value == nil { 11433 return nil 11434 } 11435 11436 shape, ok := value.(map[string]interface{}) 11437 if !ok { 11438 return fmt.Errorf("unexpected JSON type %v", value) 11439 } 11440 11441 var sv *UpdateImagePermissionsOutput 11442 if *v == nil { 11443 sv = &UpdateImagePermissionsOutput{} 11444 } else { 11445 sv = *v 11446 } 11447 11448 for key, value := range shape { 11449 switch key { 11450 default: 11451 _, _ = key, value 11452 11453 } 11454 } 11455 *v = sv 11456 return nil 11457} 11458 11459func awsAwsjson11_deserializeOpDocumentUpdateStackOutput(v **UpdateStackOutput, value interface{}) error { 11460 if v == nil { 11461 return fmt.Errorf("unexpected nil of type %T", v) 11462 } 11463 if value == nil { 11464 return nil 11465 } 11466 11467 shape, ok := value.(map[string]interface{}) 11468 if !ok { 11469 return fmt.Errorf("unexpected JSON type %v", value) 11470 } 11471 11472 var sv *UpdateStackOutput 11473 if *v == nil { 11474 sv = &UpdateStackOutput{} 11475 } else { 11476 sv = *v 11477 } 11478 11479 for key, value := range shape { 11480 switch key { 11481 case "Stack": 11482 if err := awsAwsjson11_deserializeDocumentStack(&sv.Stack, value); err != nil { 11483 return err 11484 } 11485 11486 default: 11487 _, _ = key, value 11488 11489 } 11490 } 11491 *v = sv 11492 return nil 11493} 11494