1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package transfer 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/transfer/types" 12 smithy "github.com/aws/smithy-go" 13 smithyio "github.com/aws/smithy-go/io" 14 "github.com/aws/smithy-go/middleware" 15 "github.com/aws/smithy-go/ptr" 16 smithytime "github.com/aws/smithy-go/time" 17 smithyhttp "github.com/aws/smithy-go/transport/http" 18 "io" 19 "io/ioutil" 20 "strings" 21) 22 23type awsAwsjson11_deserializeOpCreateServer struct { 24} 25 26func (*awsAwsjson11_deserializeOpCreateServer) ID() string { 27 return "OperationDeserializer" 28} 29 30func (m *awsAwsjson11_deserializeOpCreateServer) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 31 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 32) { 33 out, metadata, err = next.HandleDeserialize(ctx, in) 34 if err != nil { 35 return out, metadata, err 36 } 37 38 response, ok := out.RawResponse.(*smithyhttp.Response) 39 if !ok { 40 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 41 } 42 43 if response.StatusCode < 200 || response.StatusCode >= 300 { 44 return out, metadata, awsAwsjson11_deserializeOpErrorCreateServer(response, &metadata) 45 } 46 output := &CreateServerOutput{} 47 out.Result = output 48 49 var buff [1024]byte 50 ringBuffer := smithyio.NewRingBuffer(buff[:]) 51 52 body := io.TeeReader(response.Body, ringBuffer) 53 decoder := json.NewDecoder(body) 54 decoder.UseNumber() 55 var shape interface{} 56 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 57 var snapshot bytes.Buffer 58 io.Copy(&snapshot, ringBuffer) 59 err = &smithy.DeserializationError{ 60 Err: fmt.Errorf("failed to decode response body, %w", err), 61 Snapshot: snapshot.Bytes(), 62 } 63 return out, metadata, err 64 } 65 66 err = awsAwsjson11_deserializeOpDocumentCreateServerOutput(&output, shape) 67 if err != nil { 68 var snapshot bytes.Buffer 69 io.Copy(&snapshot, ringBuffer) 70 err = &smithy.DeserializationError{ 71 Err: fmt.Errorf("failed to decode response body, %w", err), 72 Snapshot: snapshot.Bytes(), 73 } 74 return out, metadata, err 75 } 76 77 return out, metadata, err 78} 79 80func awsAwsjson11_deserializeOpErrorCreateServer(response *smithyhttp.Response, metadata *middleware.Metadata) error { 81 var errorBuffer bytes.Buffer 82 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 83 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 84 } 85 errorBody := bytes.NewReader(errorBuffer.Bytes()) 86 87 errorCode := "UnknownError" 88 errorMessage := errorCode 89 90 code := response.Header.Get("X-Amzn-ErrorType") 91 if len(code) != 0 { 92 errorCode = restjson.SanitizeErrorCode(code) 93 } 94 95 var buff [1024]byte 96 ringBuffer := smithyio.NewRingBuffer(buff[:]) 97 98 body := io.TeeReader(errorBody, ringBuffer) 99 decoder := json.NewDecoder(body) 100 decoder.UseNumber() 101 code, message, err := restjson.GetErrorInfo(decoder) 102 if err != nil { 103 var snapshot bytes.Buffer 104 io.Copy(&snapshot, ringBuffer) 105 err = &smithy.DeserializationError{ 106 Err: fmt.Errorf("failed to decode response body, %w", err), 107 Snapshot: snapshot.Bytes(), 108 } 109 return err 110 } 111 112 errorBody.Seek(0, io.SeekStart) 113 if len(code) != 0 { 114 errorCode = restjson.SanitizeErrorCode(code) 115 } 116 if len(message) != 0 { 117 errorMessage = message 118 } 119 120 switch { 121 case strings.EqualFold("AccessDeniedException", errorCode): 122 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 123 124 case strings.EqualFold("InternalServiceError", errorCode): 125 return awsAwsjson11_deserializeErrorInternalServiceError(response, errorBody) 126 127 case strings.EqualFold("InvalidRequestException", errorCode): 128 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 129 130 case strings.EqualFold("ResourceExistsException", errorCode): 131 return awsAwsjson11_deserializeErrorResourceExistsException(response, errorBody) 132 133 case strings.EqualFold("ServiceUnavailableException", errorCode): 134 return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) 135 136 case strings.EqualFold("ThrottlingException", errorCode): 137 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 138 139 default: 140 genericError := &smithy.GenericAPIError{ 141 Code: errorCode, 142 Message: errorMessage, 143 } 144 return genericError 145 146 } 147} 148 149type awsAwsjson11_deserializeOpCreateUser struct { 150} 151 152func (*awsAwsjson11_deserializeOpCreateUser) ID() string { 153 return "OperationDeserializer" 154} 155 156func (m *awsAwsjson11_deserializeOpCreateUser) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 157 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 158) { 159 out, metadata, err = next.HandleDeserialize(ctx, in) 160 if err != nil { 161 return out, metadata, err 162 } 163 164 response, ok := out.RawResponse.(*smithyhttp.Response) 165 if !ok { 166 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 167 } 168 169 if response.StatusCode < 200 || response.StatusCode >= 300 { 170 return out, metadata, awsAwsjson11_deserializeOpErrorCreateUser(response, &metadata) 171 } 172 output := &CreateUserOutput{} 173 out.Result = output 174 175 var buff [1024]byte 176 ringBuffer := smithyio.NewRingBuffer(buff[:]) 177 178 body := io.TeeReader(response.Body, ringBuffer) 179 decoder := json.NewDecoder(body) 180 decoder.UseNumber() 181 var shape interface{} 182 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 183 var snapshot bytes.Buffer 184 io.Copy(&snapshot, ringBuffer) 185 err = &smithy.DeserializationError{ 186 Err: fmt.Errorf("failed to decode response body, %w", err), 187 Snapshot: snapshot.Bytes(), 188 } 189 return out, metadata, err 190 } 191 192 err = awsAwsjson11_deserializeOpDocumentCreateUserOutput(&output, shape) 193 if err != nil { 194 var snapshot bytes.Buffer 195 io.Copy(&snapshot, ringBuffer) 196 err = &smithy.DeserializationError{ 197 Err: fmt.Errorf("failed to decode response body, %w", err), 198 Snapshot: snapshot.Bytes(), 199 } 200 return out, metadata, err 201 } 202 203 return out, metadata, err 204} 205 206func awsAwsjson11_deserializeOpErrorCreateUser(response *smithyhttp.Response, metadata *middleware.Metadata) error { 207 var errorBuffer bytes.Buffer 208 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 209 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 210 } 211 errorBody := bytes.NewReader(errorBuffer.Bytes()) 212 213 errorCode := "UnknownError" 214 errorMessage := errorCode 215 216 code := response.Header.Get("X-Amzn-ErrorType") 217 if len(code) != 0 { 218 errorCode = restjson.SanitizeErrorCode(code) 219 } 220 221 var buff [1024]byte 222 ringBuffer := smithyio.NewRingBuffer(buff[:]) 223 224 body := io.TeeReader(errorBody, ringBuffer) 225 decoder := json.NewDecoder(body) 226 decoder.UseNumber() 227 code, message, err := restjson.GetErrorInfo(decoder) 228 if err != nil { 229 var snapshot bytes.Buffer 230 io.Copy(&snapshot, ringBuffer) 231 err = &smithy.DeserializationError{ 232 Err: fmt.Errorf("failed to decode response body, %w", err), 233 Snapshot: snapshot.Bytes(), 234 } 235 return err 236 } 237 238 errorBody.Seek(0, io.SeekStart) 239 if len(code) != 0 { 240 errorCode = restjson.SanitizeErrorCode(code) 241 } 242 if len(message) != 0 { 243 errorMessage = message 244 } 245 246 switch { 247 case strings.EqualFold("InternalServiceError", errorCode): 248 return awsAwsjson11_deserializeErrorInternalServiceError(response, errorBody) 249 250 case strings.EqualFold("InvalidRequestException", errorCode): 251 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 252 253 case strings.EqualFold("ResourceExistsException", errorCode): 254 return awsAwsjson11_deserializeErrorResourceExistsException(response, errorBody) 255 256 case strings.EqualFold("ResourceNotFoundException", errorCode): 257 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 258 259 case strings.EqualFold("ServiceUnavailableException", errorCode): 260 return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) 261 262 default: 263 genericError := &smithy.GenericAPIError{ 264 Code: errorCode, 265 Message: errorMessage, 266 } 267 return genericError 268 269 } 270} 271 272type awsAwsjson11_deserializeOpDeleteServer struct { 273} 274 275func (*awsAwsjson11_deserializeOpDeleteServer) ID() string { 276 return "OperationDeserializer" 277} 278 279func (m *awsAwsjson11_deserializeOpDeleteServer) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 280 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 281) { 282 out, metadata, err = next.HandleDeserialize(ctx, in) 283 if err != nil { 284 return out, metadata, err 285 } 286 287 response, ok := out.RawResponse.(*smithyhttp.Response) 288 if !ok { 289 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 290 } 291 292 if response.StatusCode < 200 || response.StatusCode >= 300 { 293 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteServer(response, &metadata) 294 } 295 output := &DeleteServerOutput{} 296 out.Result = output 297 298 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 299 return out, metadata, &smithy.DeserializationError{ 300 Err: fmt.Errorf("failed to discard response body, %w", err), 301 } 302 } 303 304 return out, metadata, err 305} 306 307func awsAwsjson11_deserializeOpErrorDeleteServer(response *smithyhttp.Response, metadata *middleware.Metadata) error { 308 var errorBuffer bytes.Buffer 309 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 310 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 311 } 312 errorBody := bytes.NewReader(errorBuffer.Bytes()) 313 314 errorCode := "UnknownError" 315 errorMessage := errorCode 316 317 code := response.Header.Get("X-Amzn-ErrorType") 318 if len(code) != 0 { 319 errorCode = restjson.SanitizeErrorCode(code) 320 } 321 322 var buff [1024]byte 323 ringBuffer := smithyio.NewRingBuffer(buff[:]) 324 325 body := io.TeeReader(errorBody, ringBuffer) 326 decoder := json.NewDecoder(body) 327 decoder.UseNumber() 328 code, message, err := restjson.GetErrorInfo(decoder) 329 if err != nil { 330 var snapshot bytes.Buffer 331 io.Copy(&snapshot, ringBuffer) 332 err = &smithy.DeserializationError{ 333 Err: fmt.Errorf("failed to decode response body, %w", err), 334 Snapshot: snapshot.Bytes(), 335 } 336 return err 337 } 338 339 errorBody.Seek(0, io.SeekStart) 340 if len(code) != 0 { 341 errorCode = restjson.SanitizeErrorCode(code) 342 } 343 if len(message) != 0 { 344 errorMessage = message 345 } 346 347 switch { 348 case strings.EqualFold("AccessDeniedException", errorCode): 349 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 350 351 case strings.EqualFold("InternalServiceError", errorCode): 352 return awsAwsjson11_deserializeErrorInternalServiceError(response, errorBody) 353 354 case strings.EqualFold("InvalidRequestException", errorCode): 355 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 356 357 case strings.EqualFold("ResourceNotFoundException", errorCode): 358 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 359 360 case strings.EqualFold("ServiceUnavailableException", errorCode): 361 return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) 362 363 default: 364 genericError := &smithy.GenericAPIError{ 365 Code: errorCode, 366 Message: errorMessage, 367 } 368 return genericError 369 370 } 371} 372 373type awsAwsjson11_deserializeOpDeleteSshPublicKey struct { 374} 375 376func (*awsAwsjson11_deserializeOpDeleteSshPublicKey) ID() string { 377 return "OperationDeserializer" 378} 379 380func (m *awsAwsjson11_deserializeOpDeleteSshPublicKey) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 381 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 382) { 383 out, metadata, err = next.HandleDeserialize(ctx, in) 384 if err != nil { 385 return out, metadata, err 386 } 387 388 response, ok := out.RawResponse.(*smithyhttp.Response) 389 if !ok { 390 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 391 } 392 393 if response.StatusCode < 200 || response.StatusCode >= 300 { 394 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteSshPublicKey(response, &metadata) 395 } 396 output := &DeleteSshPublicKeyOutput{} 397 out.Result = output 398 399 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 400 return out, metadata, &smithy.DeserializationError{ 401 Err: fmt.Errorf("failed to discard response body, %w", err), 402 } 403 } 404 405 return out, metadata, err 406} 407 408func awsAwsjson11_deserializeOpErrorDeleteSshPublicKey(response *smithyhttp.Response, metadata *middleware.Metadata) error { 409 var errorBuffer bytes.Buffer 410 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 411 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 412 } 413 errorBody := bytes.NewReader(errorBuffer.Bytes()) 414 415 errorCode := "UnknownError" 416 errorMessage := errorCode 417 418 code := response.Header.Get("X-Amzn-ErrorType") 419 if len(code) != 0 { 420 errorCode = restjson.SanitizeErrorCode(code) 421 } 422 423 var buff [1024]byte 424 ringBuffer := smithyio.NewRingBuffer(buff[:]) 425 426 body := io.TeeReader(errorBody, ringBuffer) 427 decoder := json.NewDecoder(body) 428 decoder.UseNumber() 429 code, message, err := restjson.GetErrorInfo(decoder) 430 if err != nil { 431 var snapshot bytes.Buffer 432 io.Copy(&snapshot, ringBuffer) 433 err = &smithy.DeserializationError{ 434 Err: fmt.Errorf("failed to decode response body, %w", err), 435 Snapshot: snapshot.Bytes(), 436 } 437 return err 438 } 439 440 errorBody.Seek(0, io.SeekStart) 441 if len(code) != 0 { 442 errorCode = restjson.SanitizeErrorCode(code) 443 } 444 if len(message) != 0 { 445 errorMessage = message 446 } 447 448 switch { 449 case strings.EqualFold("InternalServiceError", errorCode): 450 return awsAwsjson11_deserializeErrorInternalServiceError(response, errorBody) 451 452 case strings.EqualFold("InvalidRequestException", errorCode): 453 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 454 455 case strings.EqualFold("ResourceNotFoundException", errorCode): 456 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 457 458 case strings.EqualFold("ServiceUnavailableException", errorCode): 459 return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) 460 461 case strings.EqualFold("ThrottlingException", errorCode): 462 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 463 464 default: 465 genericError := &smithy.GenericAPIError{ 466 Code: errorCode, 467 Message: errorMessage, 468 } 469 return genericError 470 471 } 472} 473 474type awsAwsjson11_deserializeOpDeleteUser struct { 475} 476 477func (*awsAwsjson11_deserializeOpDeleteUser) ID() string { 478 return "OperationDeserializer" 479} 480 481func (m *awsAwsjson11_deserializeOpDeleteUser) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 482 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 483) { 484 out, metadata, err = next.HandleDeserialize(ctx, in) 485 if err != nil { 486 return out, metadata, err 487 } 488 489 response, ok := out.RawResponse.(*smithyhttp.Response) 490 if !ok { 491 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 492 } 493 494 if response.StatusCode < 200 || response.StatusCode >= 300 { 495 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteUser(response, &metadata) 496 } 497 output := &DeleteUserOutput{} 498 out.Result = output 499 500 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 501 return out, metadata, &smithy.DeserializationError{ 502 Err: fmt.Errorf("failed to discard response body, %w", err), 503 } 504 } 505 506 return out, metadata, err 507} 508 509func awsAwsjson11_deserializeOpErrorDeleteUser(response *smithyhttp.Response, metadata *middleware.Metadata) error { 510 var errorBuffer bytes.Buffer 511 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 512 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 513 } 514 errorBody := bytes.NewReader(errorBuffer.Bytes()) 515 516 errorCode := "UnknownError" 517 errorMessage := errorCode 518 519 code := response.Header.Get("X-Amzn-ErrorType") 520 if len(code) != 0 { 521 errorCode = restjson.SanitizeErrorCode(code) 522 } 523 524 var buff [1024]byte 525 ringBuffer := smithyio.NewRingBuffer(buff[:]) 526 527 body := io.TeeReader(errorBody, ringBuffer) 528 decoder := json.NewDecoder(body) 529 decoder.UseNumber() 530 code, message, err := restjson.GetErrorInfo(decoder) 531 if err != nil { 532 var snapshot bytes.Buffer 533 io.Copy(&snapshot, ringBuffer) 534 err = &smithy.DeserializationError{ 535 Err: fmt.Errorf("failed to decode response body, %w", err), 536 Snapshot: snapshot.Bytes(), 537 } 538 return err 539 } 540 541 errorBody.Seek(0, io.SeekStart) 542 if len(code) != 0 { 543 errorCode = restjson.SanitizeErrorCode(code) 544 } 545 if len(message) != 0 { 546 errorMessage = message 547 } 548 549 switch { 550 case strings.EqualFold("InternalServiceError", errorCode): 551 return awsAwsjson11_deserializeErrorInternalServiceError(response, errorBody) 552 553 case strings.EqualFold("InvalidRequestException", errorCode): 554 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 555 556 case strings.EqualFold("ResourceNotFoundException", errorCode): 557 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 558 559 case strings.EqualFold("ServiceUnavailableException", errorCode): 560 return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) 561 562 default: 563 genericError := &smithy.GenericAPIError{ 564 Code: errorCode, 565 Message: errorMessage, 566 } 567 return genericError 568 569 } 570} 571 572type awsAwsjson11_deserializeOpDescribeSecurityPolicy struct { 573} 574 575func (*awsAwsjson11_deserializeOpDescribeSecurityPolicy) ID() string { 576 return "OperationDeserializer" 577} 578 579func (m *awsAwsjson11_deserializeOpDescribeSecurityPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 580 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 581) { 582 out, metadata, err = next.HandleDeserialize(ctx, in) 583 if err != nil { 584 return out, metadata, err 585 } 586 587 response, ok := out.RawResponse.(*smithyhttp.Response) 588 if !ok { 589 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 590 } 591 592 if response.StatusCode < 200 || response.StatusCode >= 300 { 593 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeSecurityPolicy(response, &metadata) 594 } 595 output := &DescribeSecurityPolicyOutput{} 596 out.Result = output 597 598 var buff [1024]byte 599 ringBuffer := smithyio.NewRingBuffer(buff[:]) 600 601 body := io.TeeReader(response.Body, ringBuffer) 602 decoder := json.NewDecoder(body) 603 decoder.UseNumber() 604 var shape interface{} 605 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 606 var snapshot bytes.Buffer 607 io.Copy(&snapshot, ringBuffer) 608 err = &smithy.DeserializationError{ 609 Err: fmt.Errorf("failed to decode response body, %w", err), 610 Snapshot: snapshot.Bytes(), 611 } 612 return out, metadata, err 613 } 614 615 err = awsAwsjson11_deserializeOpDocumentDescribeSecurityPolicyOutput(&output, shape) 616 if err != nil { 617 var snapshot bytes.Buffer 618 io.Copy(&snapshot, ringBuffer) 619 err = &smithy.DeserializationError{ 620 Err: fmt.Errorf("failed to decode response body, %w", err), 621 Snapshot: snapshot.Bytes(), 622 } 623 return out, metadata, err 624 } 625 626 return out, metadata, err 627} 628 629func awsAwsjson11_deserializeOpErrorDescribeSecurityPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { 630 var errorBuffer bytes.Buffer 631 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 632 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 633 } 634 errorBody := bytes.NewReader(errorBuffer.Bytes()) 635 636 errorCode := "UnknownError" 637 errorMessage := errorCode 638 639 code := response.Header.Get("X-Amzn-ErrorType") 640 if len(code) != 0 { 641 errorCode = restjson.SanitizeErrorCode(code) 642 } 643 644 var buff [1024]byte 645 ringBuffer := smithyio.NewRingBuffer(buff[:]) 646 647 body := io.TeeReader(errorBody, ringBuffer) 648 decoder := json.NewDecoder(body) 649 decoder.UseNumber() 650 code, message, err := restjson.GetErrorInfo(decoder) 651 if err != nil { 652 var snapshot bytes.Buffer 653 io.Copy(&snapshot, ringBuffer) 654 err = &smithy.DeserializationError{ 655 Err: fmt.Errorf("failed to decode response body, %w", err), 656 Snapshot: snapshot.Bytes(), 657 } 658 return err 659 } 660 661 errorBody.Seek(0, io.SeekStart) 662 if len(code) != 0 { 663 errorCode = restjson.SanitizeErrorCode(code) 664 } 665 if len(message) != 0 { 666 errorMessage = message 667 } 668 669 switch { 670 case strings.EqualFold("InternalServiceError", errorCode): 671 return awsAwsjson11_deserializeErrorInternalServiceError(response, errorBody) 672 673 case strings.EqualFold("InvalidRequestException", errorCode): 674 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 675 676 case strings.EqualFold("ResourceNotFoundException", errorCode): 677 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 678 679 case strings.EqualFold("ServiceUnavailableException", errorCode): 680 return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) 681 682 default: 683 genericError := &smithy.GenericAPIError{ 684 Code: errorCode, 685 Message: errorMessage, 686 } 687 return genericError 688 689 } 690} 691 692type awsAwsjson11_deserializeOpDescribeServer struct { 693} 694 695func (*awsAwsjson11_deserializeOpDescribeServer) ID() string { 696 return "OperationDeserializer" 697} 698 699func (m *awsAwsjson11_deserializeOpDescribeServer) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 700 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 701) { 702 out, metadata, err = next.HandleDeserialize(ctx, in) 703 if err != nil { 704 return out, metadata, err 705 } 706 707 response, ok := out.RawResponse.(*smithyhttp.Response) 708 if !ok { 709 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 710 } 711 712 if response.StatusCode < 200 || response.StatusCode >= 300 { 713 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeServer(response, &metadata) 714 } 715 output := &DescribeServerOutput{} 716 out.Result = output 717 718 var buff [1024]byte 719 ringBuffer := smithyio.NewRingBuffer(buff[:]) 720 721 body := io.TeeReader(response.Body, ringBuffer) 722 decoder := json.NewDecoder(body) 723 decoder.UseNumber() 724 var shape interface{} 725 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 726 var snapshot bytes.Buffer 727 io.Copy(&snapshot, ringBuffer) 728 err = &smithy.DeserializationError{ 729 Err: fmt.Errorf("failed to decode response body, %w", err), 730 Snapshot: snapshot.Bytes(), 731 } 732 return out, metadata, err 733 } 734 735 err = awsAwsjson11_deserializeOpDocumentDescribeServerOutput(&output, shape) 736 if err != nil { 737 var snapshot bytes.Buffer 738 io.Copy(&snapshot, ringBuffer) 739 err = &smithy.DeserializationError{ 740 Err: fmt.Errorf("failed to decode response body, %w", err), 741 Snapshot: snapshot.Bytes(), 742 } 743 return out, metadata, err 744 } 745 746 return out, metadata, err 747} 748 749func awsAwsjson11_deserializeOpErrorDescribeServer(response *smithyhttp.Response, metadata *middleware.Metadata) error { 750 var errorBuffer bytes.Buffer 751 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 752 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 753 } 754 errorBody := bytes.NewReader(errorBuffer.Bytes()) 755 756 errorCode := "UnknownError" 757 errorMessage := errorCode 758 759 code := response.Header.Get("X-Amzn-ErrorType") 760 if len(code) != 0 { 761 errorCode = restjson.SanitizeErrorCode(code) 762 } 763 764 var buff [1024]byte 765 ringBuffer := smithyio.NewRingBuffer(buff[:]) 766 767 body := io.TeeReader(errorBody, ringBuffer) 768 decoder := json.NewDecoder(body) 769 decoder.UseNumber() 770 code, message, err := restjson.GetErrorInfo(decoder) 771 if err != nil { 772 var snapshot bytes.Buffer 773 io.Copy(&snapshot, ringBuffer) 774 err = &smithy.DeserializationError{ 775 Err: fmt.Errorf("failed to decode response body, %w", err), 776 Snapshot: snapshot.Bytes(), 777 } 778 return err 779 } 780 781 errorBody.Seek(0, io.SeekStart) 782 if len(code) != 0 { 783 errorCode = restjson.SanitizeErrorCode(code) 784 } 785 if len(message) != 0 { 786 errorMessage = message 787 } 788 789 switch { 790 case strings.EqualFold("InternalServiceError", errorCode): 791 return awsAwsjson11_deserializeErrorInternalServiceError(response, errorBody) 792 793 case strings.EqualFold("InvalidRequestException", errorCode): 794 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 795 796 case strings.EqualFold("ResourceNotFoundException", errorCode): 797 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 798 799 case strings.EqualFold("ServiceUnavailableException", errorCode): 800 return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) 801 802 default: 803 genericError := &smithy.GenericAPIError{ 804 Code: errorCode, 805 Message: errorMessage, 806 } 807 return genericError 808 809 } 810} 811 812type awsAwsjson11_deserializeOpDescribeUser struct { 813} 814 815func (*awsAwsjson11_deserializeOpDescribeUser) ID() string { 816 return "OperationDeserializer" 817} 818 819func (m *awsAwsjson11_deserializeOpDescribeUser) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 820 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 821) { 822 out, metadata, err = next.HandleDeserialize(ctx, in) 823 if err != nil { 824 return out, metadata, err 825 } 826 827 response, ok := out.RawResponse.(*smithyhttp.Response) 828 if !ok { 829 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 830 } 831 832 if response.StatusCode < 200 || response.StatusCode >= 300 { 833 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeUser(response, &metadata) 834 } 835 output := &DescribeUserOutput{} 836 out.Result = output 837 838 var buff [1024]byte 839 ringBuffer := smithyio.NewRingBuffer(buff[:]) 840 841 body := io.TeeReader(response.Body, ringBuffer) 842 decoder := json.NewDecoder(body) 843 decoder.UseNumber() 844 var shape interface{} 845 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 846 var snapshot bytes.Buffer 847 io.Copy(&snapshot, ringBuffer) 848 err = &smithy.DeserializationError{ 849 Err: fmt.Errorf("failed to decode response body, %w", err), 850 Snapshot: snapshot.Bytes(), 851 } 852 return out, metadata, err 853 } 854 855 err = awsAwsjson11_deserializeOpDocumentDescribeUserOutput(&output, shape) 856 if err != nil { 857 var snapshot bytes.Buffer 858 io.Copy(&snapshot, ringBuffer) 859 err = &smithy.DeserializationError{ 860 Err: fmt.Errorf("failed to decode response body, %w", err), 861 Snapshot: snapshot.Bytes(), 862 } 863 return out, metadata, err 864 } 865 866 return out, metadata, err 867} 868 869func awsAwsjson11_deserializeOpErrorDescribeUser(response *smithyhttp.Response, metadata *middleware.Metadata) error { 870 var errorBuffer bytes.Buffer 871 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 872 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 873 } 874 errorBody := bytes.NewReader(errorBuffer.Bytes()) 875 876 errorCode := "UnknownError" 877 errorMessage := errorCode 878 879 code := response.Header.Get("X-Amzn-ErrorType") 880 if len(code) != 0 { 881 errorCode = restjson.SanitizeErrorCode(code) 882 } 883 884 var buff [1024]byte 885 ringBuffer := smithyio.NewRingBuffer(buff[:]) 886 887 body := io.TeeReader(errorBody, ringBuffer) 888 decoder := json.NewDecoder(body) 889 decoder.UseNumber() 890 code, message, err := restjson.GetErrorInfo(decoder) 891 if err != nil { 892 var snapshot bytes.Buffer 893 io.Copy(&snapshot, ringBuffer) 894 err = &smithy.DeserializationError{ 895 Err: fmt.Errorf("failed to decode response body, %w", err), 896 Snapshot: snapshot.Bytes(), 897 } 898 return err 899 } 900 901 errorBody.Seek(0, io.SeekStart) 902 if len(code) != 0 { 903 errorCode = restjson.SanitizeErrorCode(code) 904 } 905 if len(message) != 0 { 906 errorMessage = message 907 } 908 909 switch { 910 case strings.EqualFold("InternalServiceError", errorCode): 911 return awsAwsjson11_deserializeErrorInternalServiceError(response, errorBody) 912 913 case strings.EqualFold("InvalidRequestException", errorCode): 914 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 915 916 case strings.EqualFold("ResourceNotFoundException", errorCode): 917 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 918 919 case strings.EqualFold("ServiceUnavailableException", errorCode): 920 return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) 921 922 default: 923 genericError := &smithy.GenericAPIError{ 924 Code: errorCode, 925 Message: errorMessage, 926 } 927 return genericError 928 929 } 930} 931 932type awsAwsjson11_deserializeOpImportSshPublicKey struct { 933} 934 935func (*awsAwsjson11_deserializeOpImportSshPublicKey) ID() string { 936 return "OperationDeserializer" 937} 938 939func (m *awsAwsjson11_deserializeOpImportSshPublicKey) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 940 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 941) { 942 out, metadata, err = next.HandleDeserialize(ctx, in) 943 if err != nil { 944 return out, metadata, err 945 } 946 947 response, ok := out.RawResponse.(*smithyhttp.Response) 948 if !ok { 949 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 950 } 951 952 if response.StatusCode < 200 || response.StatusCode >= 300 { 953 return out, metadata, awsAwsjson11_deserializeOpErrorImportSshPublicKey(response, &metadata) 954 } 955 output := &ImportSshPublicKeyOutput{} 956 out.Result = output 957 958 var buff [1024]byte 959 ringBuffer := smithyio.NewRingBuffer(buff[:]) 960 961 body := io.TeeReader(response.Body, ringBuffer) 962 decoder := json.NewDecoder(body) 963 decoder.UseNumber() 964 var shape interface{} 965 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 966 var snapshot bytes.Buffer 967 io.Copy(&snapshot, ringBuffer) 968 err = &smithy.DeserializationError{ 969 Err: fmt.Errorf("failed to decode response body, %w", err), 970 Snapshot: snapshot.Bytes(), 971 } 972 return out, metadata, err 973 } 974 975 err = awsAwsjson11_deserializeOpDocumentImportSshPublicKeyOutput(&output, shape) 976 if err != nil { 977 var snapshot bytes.Buffer 978 io.Copy(&snapshot, ringBuffer) 979 err = &smithy.DeserializationError{ 980 Err: fmt.Errorf("failed to decode response body, %w", err), 981 Snapshot: snapshot.Bytes(), 982 } 983 return out, metadata, err 984 } 985 986 return out, metadata, err 987} 988 989func awsAwsjson11_deserializeOpErrorImportSshPublicKey(response *smithyhttp.Response, metadata *middleware.Metadata) error { 990 var errorBuffer bytes.Buffer 991 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 992 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 993 } 994 errorBody := bytes.NewReader(errorBuffer.Bytes()) 995 996 errorCode := "UnknownError" 997 errorMessage := errorCode 998 999 code := response.Header.Get("X-Amzn-ErrorType") 1000 if len(code) != 0 { 1001 errorCode = restjson.SanitizeErrorCode(code) 1002 } 1003 1004 var buff [1024]byte 1005 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1006 1007 body := io.TeeReader(errorBody, ringBuffer) 1008 decoder := json.NewDecoder(body) 1009 decoder.UseNumber() 1010 code, message, err := restjson.GetErrorInfo(decoder) 1011 if err != nil { 1012 var snapshot bytes.Buffer 1013 io.Copy(&snapshot, ringBuffer) 1014 err = &smithy.DeserializationError{ 1015 Err: fmt.Errorf("failed to decode response body, %w", err), 1016 Snapshot: snapshot.Bytes(), 1017 } 1018 return err 1019 } 1020 1021 errorBody.Seek(0, io.SeekStart) 1022 if len(code) != 0 { 1023 errorCode = restjson.SanitizeErrorCode(code) 1024 } 1025 if len(message) != 0 { 1026 errorMessage = message 1027 } 1028 1029 switch { 1030 case strings.EqualFold("InternalServiceError", errorCode): 1031 return awsAwsjson11_deserializeErrorInternalServiceError(response, errorBody) 1032 1033 case strings.EqualFold("InvalidRequestException", errorCode): 1034 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 1035 1036 case strings.EqualFold("ResourceExistsException", errorCode): 1037 return awsAwsjson11_deserializeErrorResourceExistsException(response, errorBody) 1038 1039 case strings.EqualFold("ResourceNotFoundException", errorCode): 1040 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 1041 1042 case strings.EqualFold("ServiceUnavailableException", errorCode): 1043 return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) 1044 1045 case strings.EqualFold("ThrottlingException", errorCode): 1046 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 1047 1048 default: 1049 genericError := &smithy.GenericAPIError{ 1050 Code: errorCode, 1051 Message: errorMessage, 1052 } 1053 return genericError 1054 1055 } 1056} 1057 1058type awsAwsjson11_deserializeOpListSecurityPolicies struct { 1059} 1060 1061func (*awsAwsjson11_deserializeOpListSecurityPolicies) ID() string { 1062 return "OperationDeserializer" 1063} 1064 1065func (m *awsAwsjson11_deserializeOpListSecurityPolicies) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1066 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1067) { 1068 out, metadata, err = next.HandleDeserialize(ctx, in) 1069 if err != nil { 1070 return out, metadata, err 1071 } 1072 1073 response, ok := out.RawResponse.(*smithyhttp.Response) 1074 if !ok { 1075 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1076 } 1077 1078 if response.StatusCode < 200 || response.StatusCode >= 300 { 1079 return out, metadata, awsAwsjson11_deserializeOpErrorListSecurityPolicies(response, &metadata) 1080 } 1081 output := &ListSecurityPoliciesOutput{} 1082 out.Result = output 1083 1084 var buff [1024]byte 1085 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1086 1087 body := io.TeeReader(response.Body, ringBuffer) 1088 decoder := json.NewDecoder(body) 1089 decoder.UseNumber() 1090 var shape interface{} 1091 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1092 var snapshot bytes.Buffer 1093 io.Copy(&snapshot, ringBuffer) 1094 err = &smithy.DeserializationError{ 1095 Err: fmt.Errorf("failed to decode response body, %w", err), 1096 Snapshot: snapshot.Bytes(), 1097 } 1098 return out, metadata, err 1099 } 1100 1101 err = awsAwsjson11_deserializeOpDocumentListSecurityPoliciesOutput(&output, shape) 1102 if err != nil { 1103 var snapshot bytes.Buffer 1104 io.Copy(&snapshot, ringBuffer) 1105 err = &smithy.DeserializationError{ 1106 Err: fmt.Errorf("failed to decode response body, %w", err), 1107 Snapshot: snapshot.Bytes(), 1108 } 1109 return out, metadata, err 1110 } 1111 1112 return out, metadata, err 1113} 1114 1115func awsAwsjson11_deserializeOpErrorListSecurityPolicies(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1116 var errorBuffer bytes.Buffer 1117 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1118 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1119 } 1120 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1121 1122 errorCode := "UnknownError" 1123 errorMessage := errorCode 1124 1125 code := response.Header.Get("X-Amzn-ErrorType") 1126 if len(code) != 0 { 1127 errorCode = restjson.SanitizeErrorCode(code) 1128 } 1129 1130 var buff [1024]byte 1131 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1132 1133 body := io.TeeReader(errorBody, ringBuffer) 1134 decoder := json.NewDecoder(body) 1135 decoder.UseNumber() 1136 code, message, err := restjson.GetErrorInfo(decoder) 1137 if err != nil { 1138 var snapshot bytes.Buffer 1139 io.Copy(&snapshot, ringBuffer) 1140 err = &smithy.DeserializationError{ 1141 Err: fmt.Errorf("failed to decode response body, %w", err), 1142 Snapshot: snapshot.Bytes(), 1143 } 1144 return err 1145 } 1146 1147 errorBody.Seek(0, io.SeekStart) 1148 if len(code) != 0 { 1149 errorCode = restjson.SanitizeErrorCode(code) 1150 } 1151 if len(message) != 0 { 1152 errorMessage = message 1153 } 1154 1155 switch { 1156 case strings.EqualFold("InternalServiceError", errorCode): 1157 return awsAwsjson11_deserializeErrorInternalServiceError(response, errorBody) 1158 1159 case strings.EqualFold("InvalidNextTokenException", errorCode): 1160 return awsAwsjson11_deserializeErrorInvalidNextTokenException(response, errorBody) 1161 1162 case strings.EqualFold("InvalidRequestException", errorCode): 1163 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 1164 1165 case strings.EqualFold("ServiceUnavailableException", errorCode): 1166 return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) 1167 1168 default: 1169 genericError := &smithy.GenericAPIError{ 1170 Code: errorCode, 1171 Message: errorMessage, 1172 } 1173 return genericError 1174 1175 } 1176} 1177 1178type awsAwsjson11_deserializeOpListServers struct { 1179} 1180 1181func (*awsAwsjson11_deserializeOpListServers) ID() string { 1182 return "OperationDeserializer" 1183} 1184 1185func (m *awsAwsjson11_deserializeOpListServers) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1186 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1187) { 1188 out, metadata, err = next.HandleDeserialize(ctx, in) 1189 if err != nil { 1190 return out, metadata, err 1191 } 1192 1193 response, ok := out.RawResponse.(*smithyhttp.Response) 1194 if !ok { 1195 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1196 } 1197 1198 if response.StatusCode < 200 || response.StatusCode >= 300 { 1199 return out, metadata, awsAwsjson11_deserializeOpErrorListServers(response, &metadata) 1200 } 1201 output := &ListServersOutput{} 1202 out.Result = output 1203 1204 var buff [1024]byte 1205 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1206 1207 body := io.TeeReader(response.Body, ringBuffer) 1208 decoder := json.NewDecoder(body) 1209 decoder.UseNumber() 1210 var shape interface{} 1211 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1212 var snapshot bytes.Buffer 1213 io.Copy(&snapshot, ringBuffer) 1214 err = &smithy.DeserializationError{ 1215 Err: fmt.Errorf("failed to decode response body, %w", err), 1216 Snapshot: snapshot.Bytes(), 1217 } 1218 return out, metadata, err 1219 } 1220 1221 err = awsAwsjson11_deserializeOpDocumentListServersOutput(&output, shape) 1222 if err != nil { 1223 var snapshot bytes.Buffer 1224 io.Copy(&snapshot, ringBuffer) 1225 err = &smithy.DeserializationError{ 1226 Err: fmt.Errorf("failed to decode response body, %w", err), 1227 Snapshot: snapshot.Bytes(), 1228 } 1229 return out, metadata, err 1230 } 1231 1232 return out, metadata, err 1233} 1234 1235func awsAwsjson11_deserializeOpErrorListServers(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1236 var errorBuffer bytes.Buffer 1237 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1238 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1239 } 1240 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1241 1242 errorCode := "UnknownError" 1243 errorMessage := errorCode 1244 1245 code := response.Header.Get("X-Amzn-ErrorType") 1246 if len(code) != 0 { 1247 errorCode = restjson.SanitizeErrorCode(code) 1248 } 1249 1250 var buff [1024]byte 1251 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1252 1253 body := io.TeeReader(errorBody, ringBuffer) 1254 decoder := json.NewDecoder(body) 1255 decoder.UseNumber() 1256 code, message, err := restjson.GetErrorInfo(decoder) 1257 if err != nil { 1258 var snapshot bytes.Buffer 1259 io.Copy(&snapshot, ringBuffer) 1260 err = &smithy.DeserializationError{ 1261 Err: fmt.Errorf("failed to decode response body, %w", err), 1262 Snapshot: snapshot.Bytes(), 1263 } 1264 return err 1265 } 1266 1267 errorBody.Seek(0, io.SeekStart) 1268 if len(code) != 0 { 1269 errorCode = restjson.SanitizeErrorCode(code) 1270 } 1271 if len(message) != 0 { 1272 errorMessage = message 1273 } 1274 1275 switch { 1276 case strings.EqualFold("InternalServiceError", errorCode): 1277 return awsAwsjson11_deserializeErrorInternalServiceError(response, errorBody) 1278 1279 case strings.EqualFold("InvalidNextTokenException", errorCode): 1280 return awsAwsjson11_deserializeErrorInvalidNextTokenException(response, errorBody) 1281 1282 case strings.EqualFold("InvalidRequestException", errorCode): 1283 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 1284 1285 case strings.EqualFold("ServiceUnavailableException", errorCode): 1286 return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) 1287 1288 default: 1289 genericError := &smithy.GenericAPIError{ 1290 Code: errorCode, 1291 Message: errorMessage, 1292 } 1293 return genericError 1294 1295 } 1296} 1297 1298type awsAwsjson11_deserializeOpListTagsForResource struct { 1299} 1300 1301func (*awsAwsjson11_deserializeOpListTagsForResource) ID() string { 1302 return "OperationDeserializer" 1303} 1304 1305func (m *awsAwsjson11_deserializeOpListTagsForResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1306 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1307) { 1308 out, metadata, err = next.HandleDeserialize(ctx, in) 1309 if err != nil { 1310 return out, metadata, err 1311 } 1312 1313 response, ok := out.RawResponse.(*smithyhttp.Response) 1314 if !ok { 1315 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1316 } 1317 1318 if response.StatusCode < 200 || response.StatusCode >= 300 { 1319 return out, metadata, awsAwsjson11_deserializeOpErrorListTagsForResource(response, &metadata) 1320 } 1321 output := &ListTagsForResourceOutput{} 1322 out.Result = output 1323 1324 var buff [1024]byte 1325 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1326 1327 body := io.TeeReader(response.Body, ringBuffer) 1328 decoder := json.NewDecoder(body) 1329 decoder.UseNumber() 1330 var shape interface{} 1331 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1332 var snapshot bytes.Buffer 1333 io.Copy(&snapshot, ringBuffer) 1334 err = &smithy.DeserializationError{ 1335 Err: fmt.Errorf("failed to decode response body, %w", err), 1336 Snapshot: snapshot.Bytes(), 1337 } 1338 return out, metadata, err 1339 } 1340 1341 err = awsAwsjson11_deserializeOpDocumentListTagsForResourceOutput(&output, shape) 1342 if err != nil { 1343 var snapshot bytes.Buffer 1344 io.Copy(&snapshot, ringBuffer) 1345 err = &smithy.DeserializationError{ 1346 Err: fmt.Errorf("failed to decode response body, %w", err), 1347 Snapshot: snapshot.Bytes(), 1348 } 1349 return out, metadata, err 1350 } 1351 1352 return out, metadata, err 1353} 1354 1355func awsAwsjson11_deserializeOpErrorListTagsForResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1356 var errorBuffer bytes.Buffer 1357 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1358 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1359 } 1360 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1361 1362 errorCode := "UnknownError" 1363 errorMessage := errorCode 1364 1365 code := response.Header.Get("X-Amzn-ErrorType") 1366 if len(code) != 0 { 1367 errorCode = restjson.SanitizeErrorCode(code) 1368 } 1369 1370 var buff [1024]byte 1371 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1372 1373 body := io.TeeReader(errorBody, ringBuffer) 1374 decoder := json.NewDecoder(body) 1375 decoder.UseNumber() 1376 code, message, err := restjson.GetErrorInfo(decoder) 1377 if err != nil { 1378 var snapshot bytes.Buffer 1379 io.Copy(&snapshot, ringBuffer) 1380 err = &smithy.DeserializationError{ 1381 Err: fmt.Errorf("failed to decode response body, %w", err), 1382 Snapshot: snapshot.Bytes(), 1383 } 1384 return err 1385 } 1386 1387 errorBody.Seek(0, io.SeekStart) 1388 if len(code) != 0 { 1389 errorCode = restjson.SanitizeErrorCode(code) 1390 } 1391 if len(message) != 0 { 1392 errorMessage = message 1393 } 1394 1395 switch { 1396 case strings.EqualFold("InternalServiceError", errorCode): 1397 return awsAwsjson11_deserializeErrorInternalServiceError(response, errorBody) 1398 1399 case strings.EqualFold("InvalidNextTokenException", errorCode): 1400 return awsAwsjson11_deserializeErrorInvalidNextTokenException(response, errorBody) 1401 1402 case strings.EqualFold("InvalidRequestException", errorCode): 1403 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 1404 1405 case strings.EqualFold("ServiceUnavailableException", errorCode): 1406 return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) 1407 1408 default: 1409 genericError := &smithy.GenericAPIError{ 1410 Code: errorCode, 1411 Message: errorMessage, 1412 } 1413 return genericError 1414 1415 } 1416} 1417 1418type awsAwsjson11_deserializeOpListUsers struct { 1419} 1420 1421func (*awsAwsjson11_deserializeOpListUsers) ID() string { 1422 return "OperationDeserializer" 1423} 1424 1425func (m *awsAwsjson11_deserializeOpListUsers) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1426 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1427) { 1428 out, metadata, err = next.HandleDeserialize(ctx, in) 1429 if err != nil { 1430 return out, metadata, err 1431 } 1432 1433 response, ok := out.RawResponse.(*smithyhttp.Response) 1434 if !ok { 1435 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1436 } 1437 1438 if response.StatusCode < 200 || response.StatusCode >= 300 { 1439 return out, metadata, awsAwsjson11_deserializeOpErrorListUsers(response, &metadata) 1440 } 1441 output := &ListUsersOutput{} 1442 out.Result = output 1443 1444 var buff [1024]byte 1445 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1446 1447 body := io.TeeReader(response.Body, ringBuffer) 1448 decoder := json.NewDecoder(body) 1449 decoder.UseNumber() 1450 var shape interface{} 1451 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1452 var snapshot bytes.Buffer 1453 io.Copy(&snapshot, ringBuffer) 1454 err = &smithy.DeserializationError{ 1455 Err: fmt.Errorf("failed to decode response body, %w", err), 1456 Snapshot: snapshot.Bytes(), 1457 } 1458 return out, metadata, err 1459 } 1460 1461 err = awsAwsjson11_deserializeOpDocumentListUsersOutput(&output, shape) 1462 if err != nil { 1463 var snapshot bytes.Buffer 1464 io.Copy(&snapshot, ringBuffer) 1465 err = &smithy.DeserializationError{ 1466 Err: fmt.Errorf("failed to decode response body, %w", err), 1467 Snapshot: snapshot.Bytes(), 1468 } 1469 return out, metadata, err 1470 } 1471 1472 return out, metadata, err 1473} 1474 1475func awsAwsjson11_deserializeOpErrorListUsers(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1476 var errorBuffer bytes.Buffer 1477 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1478 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1479 } 1480 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1481 1482 errorCode := "UnknownError" 1483 errorMessage := errorCode 1484 1485 code := response.Header.Get("X-Amzn-ErrorType") 1486 if len(code) != 0 { 1487 errorCode = restjson.SanitizeErrorCode(code) 1488 } 1489 1490 var buff [1024]byte 1491 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1492 1493 body := io.TeeReader(errorBody, ringBuffer) 1494 decoder := json.NewDecoder(body) 1495 decoder.UseNumber() 1496 code, message, err := restjson.GetErrorInfo(decoder) 1497 if err != nil { 1498 var snapshot bytes.Buffer 1499 io.Copy(&snapshot, ringBuffer) 1500 err = &smithy.DeserializationError{ 1501 Err: fmt.Errorf("failed to decode response body, %w", err), 1502 Snapshot: snapshot.Bytes(), 1503 } 1504 return err 1505 } 1506 1507 errorBody.Seek(0, io.SeekStart) 1508 if len(code) != 0 { 1509 errorCode = restjson.SanitizeErrorCode(code) 1510 } 1511 if len(message) != 0 { 1512 errorMessage = message 1513 } 1514 1515 switch { 1516 case strings.EqualFold("InternalServiceError", errorCode): 1517 return awsAwsjson11_deserializeErrorInternalServiceError(response, errorBody) 1518 1519 case strings.EqualFold("InvalidNextTokenException", errorCode): 1520 return awsAwsjson11_deserializeErrorInvalidNextTokenException(response, errorBody) 1521 1522 case strings.EqualFold("InvalidRequestException", errorCode): 1523 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 1524 1525 case strings.EqualFold("ResourceNotFoundException", errorCode): 1526 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 1527 1528 case strings.EqualFold("ServiceUnavailableException", errorCode): 1529 return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) 1530 1531 default: 1532 genericError := &smithy.GenericAPIError{ 1533 Code: errorCode, 1534 Message: errorMessage, 1535 } 1536 return genericError 1537 1538 } 1539} 1540 1541type awsAwsjson11_deserializeOpStartServer struct { 1542} 1543 1544func (*awsAwsjson11_deserializeOpStartServer) ID() string { 1545 return "OperationDeserializer" 1546} 1547 1548func (m *awsAwsjson11_deserializeOpStartServer) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1549 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1550) { 1551 out, metadata, err = next.HandleDeserialize(ctx, in) 1552 if err != nil { 1553 return out, metadata, err 1554 } 1555 1556 response, ok := out.RawResponse.(*smithyhttp.Response) 1557 if !ok { 1558 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1559 } 1560 1561 if response.StatusCode < 200 || response.StatusCode >= 300 { 1562 return out, metadata, awsAwsjson11_deserializeOpErrorStartServer(response, &metadata) 1563 } 1564 output := &StartServerOutput{} 1565 out.Result = output 1566 1567 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 1568 return out, metadata, &smithy.DeserializationError{ 1569 Err: fmt.Errorf("failed to discard response body, %w", err), 1570 } 1571 } 1572 1573 return out, metadata, err 1574} 1575 1576func awsAwsjson11_deserializeOpErrorStartServer(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("InternalServiceError", errorCode): 1618 return awsAwsjson11_deserializeErrorInternalServiceError(response, errorBody) 1619 1620 case strings.EqualFold("InvalidRequestException", errorCode): 1621 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 1622 1623 case strings.EqualFold("ResourceNotFoundException", errorCode): 1624 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 1625 1626 case strings.EqualFold("ServiceUnavailableException", errorCode): 1627 return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) 1628 1629 case strings.EqualFold("ThrottlingException", errorCode): 1630 return awsAwsjson11_deserializeErrorThrottlingException(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_deserializeOpStopServer struct { 1643} 1644 1645func (*awsAwsjson11_deserializeOpStopServer) ID() string { 1646 return "OperationDeserializer" 1647} 1648 1649func (m *awsAwsjson11_deserializeOpStopServer) 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_deserializeOpErrorStopServer(response, &metadata) 1664 } 1665 output := &StopServerOutput{} 1666 out.Result = output 1667 1668 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 1669 return out, metadata, &smithy.DeserializationError{ 1670 Err: fmt.Errorf("failed to discard response body, %w", err), 1671 } 1672 } 1673 1674 return out, metadata, err 1675} 1676 1677func awsAwsjson11_deserializeOpErrorStopServer(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1678 var errorBuffer bytes.Buffer 1679 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1680 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1681 } 1682 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1683 1684 errorCode := "UnknownError" 1685 errorMessage := errorCode 1686 1687 code := response.Header.Get("X-Amzn-ErrorType") 1688 if len(code) != 0 { 1689 errorCode = restjson.SanitizeErrorCode(code) 1690 } 1691 1692 var buff [1024]byte 1693 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1694 1695 body := io.TeeReader(errorBody, ringBuffer) 1696 decoder := json.NewDecoder(body) 1697 decoder.UseNumber() 1698 code, message, err := restjson.GetErrorInfo(decoder) 1699 if err != nil { 1700 var snapshot bytes.Buffer 1701 io.Copy(&snapshot, ringBuffer) 1702 err = &smithy.DeserializationError{ 1703 Err: fmt.Errorf("failed to decode response body, %w", err), 1704 Snapshot: snapshot.Bytes(), 1705 } 1706 return err 1707 } 1708 1709 errorBody.Seek(0, io.SeekStart) 1710 if len(code) != 0 { 1711 errorCode = restjson.SanitizeErrorCode(code) 1712 } 1713 if len(message) != 0 { 1714 errorMessage = message 1715 } 1716 1717 switch { 1718 case strings.EqualFold("InternalServiceError", errorCode): 1719 return awsAwsjson11_deserializeErrorInternalServiceError(response, errorBody) 1720 1721 case strings.EqualFold("InvalidRequestException", errorCode): 1722 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 1723 1724 case strings.EqualFold("ResourceNotFoundException", errorCode): 1725 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 1726 1727 case strings.EqualFold("ServiceUnavailableException", errorCode): 1728 return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) 1729 1730 case strings.EqualFold("ThrottlingException", errorCode): 1731 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 1732 1733 default: 1734 genericError := &smithy.GenericAPIError{ 1735 Code: errorCode, 1736 Message: errorMessage, 1737 } 1738 return genericError 1739 1740 } 1741} 1742 1743type awsAwsjson11_deserializeOpTagResource struct { 1744} 1745 1746func (*awsAwsjson11_deserializeOpTagResource) ID() string { 1747 return "OperationDeserializer" 1748} 1749 1750func (m *awsAwsjson11_deserializeOpTagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1751 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1752) { 1753 out, metadata, err = next.HandleDeserialize(ctx, in) 1754 if err != nil { 1755 return out, metadata, err 1756 } 1757 1758 response, ok := out.RawResponse.(*smithyhttp.Response) 1759 if !ok { 1760 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1761 } 1762 1763 if response.StatusCode < 200 || response.StatusCode >= 300 { 1764 return out, metadata, awsAwsjson11_deserializeOpErrorTagResource(response, &metadata) 1765 } 1766 output := &TagResourceOutput{} 1767 out.Result = output 1768 1769 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 1770 return out, metadata, &smithy.DeserializationError{ 1771 Err: fmt.Errorf("failed to discard response body, %w", err), 1772 } 1773 } 1774 1775 return out, metadata, err 1776} 1777 1778func awsAwsjson11_deserializeOpErrorTagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1779 var errorBuffer bytes.Buffer 1780 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1781 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1782 } 1783 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1784 1785 errorCode := "UnknownError" 1786 errorMessage := errorCode 1787 1788 code := response.Header.Get("X-Amzn-ErrorType") 1789 if len(code) != 0 { 1790 errorCode = restjson.SanitizeErrorCode(code) 1791 } 1792 1793 var buff [1024]byte 1794 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1795 1796 body := io.TeeReader(errorBody, ringBuffer) 1797 decoder := json.NewDecoder(body) 1798 decoder.UseNumber() 1799 code, message, err := restjson.GetErrorInfo(decoder) 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 err 1808 } 1809 1810 errorBody.Seek(0, io.SeekStart) 1811 if len(code) != 0 { 1812 errorCode = restjson.SanitizeErrorCode(code) 1813 } 1814 if len(message) != 0 { 1815 errorMessage = message 1816 } 1817 1818 switch { 1819 case strings.EqualFold("InternalServiceError", errorCode): 1820 return awsAwsjson11_deserializeErrorInternalServiceError(response, errorBody) 1821 1822 case strings.EqualFold("InvalidRequestException", errorCode): 1823 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 1824 1825 case strings.EqualFold("ResourceNotFoundException", errorCode): 1826 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 1827 1828 case strings.EqualFold("ServiceUnavailableException", errorCode): 1829 return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) 1830 1831 default: 1832 genericError := &smithy.GenericAPIError{ 1833 Code: errorCode, 1834 Message: errorMessage, 1835 } 1836 return genericError 1837 1838 } 1839} 1840 1841type awsAwsjson11_deserializeOpTestIdentityProvider struct { 1842} 1843 1844func (*awsAwsjson11_deserializeOpTestIdentityProvider) ID() string { 1845 return "OperationDeserializer" 1846} 1847 1848func (m *awsAwsjson11_deserializeOpTestIdentityProvider) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1849 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1850) { 1851 out, metadata, err = next.HandleDeserialize(ctx, in) 1852 if err != nil { 1853 return out, metadata, err 1854 } 1855 1856 response, ok := out.RawResponse.(*smithyhttp.Response) 1857 if !ok { 1858 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1859 } 1860 1861 if response.StatusCode < 200 || response.StatusCode >= 300 { 1862 return out, metadata, awsAwsjson11_deserializeOpErrorTestIdentityProvider(response, &metadata) 1863 } 1864 output := &TestIdentityProviderOutput{} 1865 out.Result = output 1866 1867 var buff [1024]byte 1868 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1869 1870 body := io.TeeReader(response.Body, ringBuffer) 1871 decoder := json.NewDecoder(body) 1872 decoder.UseNumber() 1873 var shape interface{} 1874 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1875 var snapshot bytes.Buffer 1876 io.Copy(&snapshot, ringBuffer) 1877 err = &smithy.DeserializationError{ 1878 Err: fmt.Errorf("failed to decode response body, %w", err), 1879 Snapshot: snapshot.Bytes(), 1880 } 1881 return out, metadata, err 1882 } 1883 1884 err = awsAwsjson11_deserializeOpDocumentTestIdentityProviderOutput(&output, shape) 1885 if err != nil { 1886 var snapshot bytes.Buffer 1887 io.Copy(&snapshot, ringBuffer) 1888 err = &smithy.DeserializationError{ 1889 Err: fmt.Errorf("failed to decode response body, %w", err), 1890 Snapshot: snapshot.Bytes(), 1891 } 1892 return out, metadata, err 1893 } 1894 1895 return out, metadata, err 1896} 1897 1898func awsAwsjson11_deserializeOpErrorTestIdentityProvider(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1899 var errorBuffer bytes.Buffer 1900 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1901 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1902 } 1903 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1904 1905 errorCode := "UnknownError" 1906 errorMessage := errorCode 1907 1908 code := response.Header.Get("X-Amzn-ErrorType") 1909 if len(code) != 0 { 1910 errorCode = restjson.SanitizeErrorCode(code) 1911 } 1912 1913 var buff [1024]byte 1914 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1915 1916 body := io.TeeReader(errorBody, ringBuffer) 1917 decoder := json.NewDecoder(body) 1918 decoder.UseNumber() 1919 code, message, err := restjson.GetErrorInfo(decoder) 1920 if err != nil { 1921 var snapshot bytes.Buffer 1922 io.Copy(&snapshot, ringBuffer) 1923 err = &smithy.DeserializationError{ 1924 Err: fmt.Errorf("failed to decode response body, %w", err), 1925 Snapshot: snapshot.Bytes(), 1926 } 1927 return err 1928 } 1929 1930 errorBody.Seek(0, io.SeekStart) 1931 if len(code) != 0 { 1932 errorCode = restjson.SanitizeErrorCode(code) 1933 } 1934 if len(message) != 0 { 1935 errorMessage = message 1936 } 1937 1938 switch { 1939 case strings.EqualFold("InternalServiceError", errorCode): 1940 return awsAwsjson11_deserializeErrorInternalServiceError(response, errorBody) 1941 1942 case strings.EqualFold("InvalidRequestException", errorCode): 1943 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 1944 1945 case strings.EqualFold("ResourceNotFoundException", errorCode): 1946 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 1947 1948 case strings.EqualFold("ServiceUnavailableException", errorCode): 1949 return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) 1950 1951 default: 1952 genericError := &smithy.GenericAPIError{ 1953 Code: errorCode, 1954 Message: errorMessage, 1955 } 1956 return genericError 1957 1958 } 1959} 1960 1961type awsAwsjson11_deserializeOpUntagResource struct { 1962} 1963 1964func (*awsAwsjson11_deserializeOpUntagResource) ID() string { 1965 return "OperationDeserializer" 1966} 1967 1968func (m *awsAwsjson11_deserializeOpUntagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1969 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1970) { 1971 out, metadata, err = next.HandleDeserialize(ctx, in) 1972 if err != nil { 1973 return out, metadata, err 1974 } 1975 1976 response, ok := out.RawResponse.(*smithyhttp.Response) 1977 if !ok { 1978 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1979 } 1980 1981 if response.StatusCode < 200 || response.StatusCode >= 300 { 1982 return out, metadata, awsAwsjson11_deserializeOpErrorUntagResource(response, &metadata) 1983 } 1984 output := &UntagResourceOutput{} 1985 out.Result = output 1986 1987 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 1988 return out, metadata, &smithy.DeserializationError{ 1989 Err: fmt.Errorf("failed to discard response body, %w", err), 1990 } 1991 } 1992 1993 return out, metadata, err 1994} 1995 1996func awsAwsjson11_deserializeOpErrorUntagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1997 var errorBuffer bytes.Buffer 1998 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1999 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2000 } 2001 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2002 2003 errorCode := "UnknownError" 2004 errorMessage := errorCode 2005 2006 code := response.Header.Get("X-Amzn-ErrorType") 2007 if len(code) != 0 { 2008 errorCode = restjson.SanitizeErrorCode(code) 2009 } 2010 2011 var buff [1024]byte 2012 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2013 2014 body := io.TeeReader(errorBody, ringBuffer) 2015 decoder := json.NewDecoder(body) 2016 decoder.UseNumber() 2017 code, message, err := restjson.GetErrorInfo(decoder) 2018 if err != nil { 2019 var snapshot bytes.Buffer 2020 io.Copy(&snapshot, ringBuffer) 2021 err = &smithy.DeserializationError{ 2022 Err: fmt.Errorf("failed to decode response body, %w", err), 2023 Snapshot: snapshot.Bytes(), 2024 } 2025 return err 2026 } 2027 2028 errorBody.Seek(0, io.SeekStart) 2029 if len(code) != 0 { 2030 errorCode = restjson.SanitizeErrorCode(code) 2031 } 2032 if len(message) != 0 { 2033 errorMessage = message 2034 } 2035 2036 switch { 2037 case strings.EqualFold("InternalServiceError", errorCode): 2038 return awsAwsjson11_deserializeErrorInternalServiceError(response, errorBody) 2039 2040 case strings.EqualFold("InvalidRequestException", errorCode): 2041 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 2042 2043 case strings.EqualFold("ResourceNotFoundException", errorCode): 2044 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 2045 2046 case strings.EqualFold("ServiceUnavailableException", errorCode): 2047 return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) 2048 2049 default: 2050 genericError := &smithy.GenericAPIError{ 2051 Code: errorCode, 2052 Message: errorMessage, 2053 } 2054 return genericError 2055 2056 } 2057} 2058 2059type awsAwsjson11_deserializeOpUpdateServer struct { 2060} 2061 2062func (*awsAwsjson11_deserializeOpUpdateServer) ID() string { 2063 return "OperationDeserializer" 2064} 2065 2066func (m *awsAwsjson11_deserializeOpUpdateServer) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2067 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2068) { 2069 out, metadata, err = next.HandleDeserialize(ctx, in) 2070 if err != nil { 2071 return out, metadata, err 2072 } 2073 2074 response, ok := out.RawResponse.(*smithyhttp.Response) 2075 if !ok { 2076 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2077 } 2078 2079 if response.StatusCode < 200 || response.StatusCode >= 300 { 2080 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateServer(response, &metadata) 2081 } 2082 output := &UpdateServerOutput{} 2083 out.Result = output 2084 2085 var buff [1024]byte 2086 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2087 2088 body := io.TeeReader(response.Body, ringBuffer) 2089 decoder := json.NewDecoder(body) 2090 decoder.UseNumber() 2091 var shape interface{} 2092 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2093 var snapshot bytes.Buffer 2094 io.Copy(&snapshot, ringBuffer) 2095 err = &smithy.DeserializationError{ 2096 Err: fmt.Errorf("failed to decode response body, %w", err), 2097 Snapshot: snapshot.Bytes(), 2098 } 2099 return out, metadata, err 2100 } 2101 2102 err = awsAwsjson11_deserializeOpDocumentUpdateServerOutput(&output, shape) 2103 if err != nil { 2104 var snapshot bytes.Buffer 2105 io.Copy(&snapshot, ringBuffer) 2106 err = &smithy.DeserializationError{ 2107 Err: fmt.Errorf("failed to decode response body, %w", err), 2108 Snapshot: snapshot.Bytes(), 2109 } 2110 return out, metadata, err 2111 } 2112 2113 return out, metadata, err 2114} 2115 2116func awsAwsjson11_deserializeOpErrorUpdateServer(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2117 var errorBuffer bytes.Buffer 2118 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2119 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2120 } 2121 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2122 2123 errorCode := "UnknownError" 2124 errorMessage := errorCode 2125 2126 code := response.Header.Get("X-Amzn-ErrorType") 2127 if len(code) != 0 { 2128 errorCode = restjson.SanitizeErrorCode(code) 2129 } 2130 2131 var buff [1024]byte 2132 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2133 2134 body := io.TeeReader(errorBody, ringBuffer) 2135 decoder := json.NewDecoder(body) 2136 decoder.UseNumber() 2137 code, message, err := restjson.GetErrorInfo(decoder) 2138 if err != nil { 2139 var snapshot bytes.Buffer 2140 io.Copy(&snapshot, ringBuffer) 2141 err = &smithy.DeserializationError{ 2142 Err: fmt.Errorf("failed to decode response body, %w", err), 2143 Snapshot: snapshot.Bytes(), 2144 } 2145 return err 2146 } 2147 2148 errorBody.Seek(0, io.SeekStart) 2149 if len(code) != 0 { 2150 errorCode = restjson.SanitizeErrorCode(code) 2151 } 2152 if len(message) != 0 { 2153 errorMessage = message 2154 } 2155 2156 switch { 2157 case strings.EqualFold("AccessDeniedException", errorCode): 2158 return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody) 2159 2160 case strings.EqualFold("ConflictException", errorCode): 2161 return awsAwsjson11_deserializeErrorConflictException(response, errorBody) 2162 2163 case strings.EqualFold("InternalServiceError", errorCode): 2164 return awsAwsjson11_deserializeErrorInternalServiceError(response, errorBody) 2165 2166 case strings.EqualFold("InvalidRequestException", errorCode): 2167 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 2168 2169 case strings.EqualFold("ResourceExistsException", errorCode): 2170 return awsAwsjson11_deserializeErrorResourceExistsException(response, errorBody) 2171 2172 case strings.EqualFold("ResourceNotFoundException", errorCode): 2173 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 2174 2175 case strings.EqualFold("ServiceUnavailableException", errorCode): 2176 return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) 2177 2178 case strings.EqualFold("ThrottlingException", errorCode): 2179 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 2180 2181 default: 2182 genericError := &smithy.GenericAPIError{ 2183 Code: errorCode, 2184 Message: errorMessage, 2185 } 2186 return genericError 2187 2188 } 2189} 2190 2191type awsAwsjson11_deserializeOpUpdateUser struct { 2192} 2193 2194func (*awsAwsjson11_deserializeOpUpdateUser) ID() string { 2195 return "OperationDeserializer" 2196} 2197 2198func (m *awsAwsjson11_deserializeOpUpdateUser) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2199 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2200) { 2201 out, metadata, err = next.HandleDeserialize(ctx, in) 2202 if err != nil { 2203 return out, metadata, err 2204 } 2205 2206 response, ok := out.RawResponse.(*smithyhttp.Response) 2207 if !ok { 2208 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2209 } 2210 2211 if response.StatusCode < 200 || response.StatusCode >= 300 { 2212 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateUser(response, &metadata) 2213 } 2214 output := &UpdateUserOutput{} 2215 out.Result = output 2216 2217 var buff [1024]byte 2218 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2219 2220 body := io.TeeReader(response.Body, ringBuffer) 2221 decoder := json.NewDecoder(body) 2222 decoder.UseNumber() 2223 var shape interface{} 2224 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2225 var snapshot bytes.Buffer 2226 io.Copy(&snapshot, ringBuffer) 2227 err = &smithy.DeserializationError{ 2228 Err: fmt.Errorf("failed to decode response body, %w", err), 2229 Snapshot: snapshot.Bytes(), 2230 } 2231 return out, metadata, err 2232 } 2233 2234 err = awsAwsjson11_deserializeOpDocumentUpdateUserOutput(&output, shape) 2235 if err != nil { 2236 var snapshot bytes.Buffer 2237 io.Copy(&snapshot, ringBuffer) 2238 err = &smithy.DeserializationError{ 2239 Err: fmt.Errorf("failed to decode response body, %w", err), 2240 Snapshot: snapshot.Bytes(), 2241 } 2242 return out, metadata, err 2243 } 2244 2245 return out, metadata, err 2246} 2247 2248func awsAwsjson11_deserializeOpErrorUpdateUser(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2249 var errorBuffer bytes.Buffer 2250 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2251 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2252 } 2253 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2254 2255 errorCode := "UnknownError" 2256 errorMessage := errorCode 2257 2258 code := response.Header.Get("X-Amzn-ErrorType") 2259 if len(code) != 0 { 2260 errorCode = restjson.SanitizeErrorCode(code) 2261 } 2262 2263 var buff [1024]byte 2264 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2265 2266 body := io.TeeReader(errorBody, ringBuffer) 2267 decoder := json.NewDecoder(body) 2268 decoder.UseNumber() 2269 code, message, err := restjson.GetErrorInfo(decoder) 2270 if err != nil { 2271 var snapshot bytes.Buffer 2272 io.Copy(&snapshot, ringBuffer) 2273 err = &smithy.DeserializationError{ 2274 Err: fmt.Errorf("failed to decode response body, %w", err), 2275 Snapshot: snapshot.Bytes(), 2276 } 2277 return err 2278 } 2279 2280 errorBody.Seek(0, io.SeekStart) 2281 if len(code) != 0 { 2282 errorCode = restjson.SanitizeErrorCode(code) 2283 } 2284 if len(message) != 0 { 2285 errorMessage = message 2286 } 2287 2288 switch { 2289 case strings.EqualFold("InternalServiceError", errorCode): 2290 return awsAwsjson11_deserializeErrorInternalServiceError(response, errorBody) 2291 2292 case strings.EqualFold("InvalidRequestException", errorCode): 2293 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 2294 2295 case strings.EqualFold("ResourceNotFoundException", errorCode): 2296 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 2297 2298 case strings.EqualFold("ServiceUnavailableException", errorCode): 2299 return awsAwsjson11_deserializeErrorServiceUnavailableException(response, errorBody) 2300 2301 case strings.EqualFold("ThrottlingException", errorCode): 2302 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 2303 2304 default: 2305 genericError := &smithy.GenericAPIError{ 2306 Code: errorCode, 2307 Message: errorMessage, 2308 } 2309 return genericError 2310 2311 } 2312} 2313 2314func awsAwsjson11_deserializeErrorAccessDeniedException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 2315 var buff [1024]byte 2316 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2317 2318 body := io.TeeReader(errorBody, ringBuffer) 2319 decoder := json.NewDecoder(body) 2320 decoder.UseNumber() 2321 var shape interface{} 2322 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2323 var snapshot bytes.Buffer 2324 io.Copy(&snapshot, ringBuffer) 2325 err = &smithy.DeserializationError{ 2326 Err: fmt.Errorf("failed to decode response body, %w", err), 2327 Snapshot: snapshot.Bytes(), 2328 } 2329 return err 2330 } 2331 2332 output := &types.AccessDeniedException{} 2333 err := awsAwsjson11_deserializeDocumentAccessDeniedException(&output, shape) 2334 2335 if err != nil { 2336 var snapshot bytes.Buffer 2337 io.Copy(&snapshot, ringBuffer) 2338 err = &smithy.DeserializationError{ 2339 Err: fmt.Errorf("failed to decode response body, %w", err), 2340 Snapshot: snapshot.Bytes(), 2341 } 2342 return err 2343 } 2344 2345 errorBody.Seek(0, io.SeekStart) 2346 return output 2347} 2348 2349func awsAwsjson11_deserializeErrorConflictException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 2350 var buff [1024]byte 2351 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2352 2353 body := io.TeeReader(errorBody, ringBuffer) 2354 decoder := json.NewDecoder(body) 2355 decoder.UseNumber() 2356 var shape interface{} 2357 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2358 var snapshot bytes.Buffer 2359 io.Copy(&snapshot, ringBuffer) 2360 err = &smithy.DeserializationError{ 2361 Err: fmt.Errorf("failed to decode response body, %w", err), 2362 Snapshot: snapshot.Bytes(), 2363 } 2364 return err 2365 } 2366 2367 output := &types.ConflictException{} 2368 err := awsAwsjson11_deserializeDocumentConflictException(&output, shape) 2369 2370 if err != nil { 2371 var snapshot bytes.Buffer 2372 io.Copy(&snapshot, ringBuffer) 2373 err = &smithy.DeserializationError{ 2374 Err: fmt.Errorf("failed to decode response body, %w", err), 2375 Snapshot: snapshot.Bytes(), 2376 } 2377 return err 2378 } 2379 2380 errorBody.Seek(0, io.SeekStart) 2381 return output 2382} 2383 2384func awsAwsjson11_deserializeErrorInternalServiceError(response *smithyhttp.Response, errorBody *bytes.Reader) error { 2385 var buff [1024]byte 2386 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2387 2388 body := io.TeeReader(errorBody, ringBuffer) 2389 decoder := json.NewDecoder(body) 2390 decoder.UseNumber() 2391 var shape interface{} 2392 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2393 var snapshot bytes.Buffer 2394 io.Copy(&snapshot, ringBuffer) 2395 err = &smithy.DeserializationError{ 2396 Err: fmt.Errorf("failed to decode response body, %w", err), 2397 Snapshot: snapshot.Bytes(), 2398 } 2399 return err 2400 } 2401 2402 output := &types.InternalServiceError{} 2403 err := awsAwsjson11_deserializeDocumentInternalServiceError(&output, shape) 2404 2405 if err != nil { 2406 var snapshot bytes.Buffer 2407 io.Copy(&snapshot, ringBuffer) 2408 err = &smithy.DeserializationError{ 2409 Err: fmt.Errorf("failed to decode response body, %w", err), 2410 Snapshot: snapshot.Bytes(), 2411 } 2412 return err 2413 } 2414 2415 errorBody.Seek(0, io.SeekStart) 2416 return output 2417} 2418 2419func awsAwsjson11_deserializeErrorInvalidNextTokenException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 2420 var buff [1024]byte 2421 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2422 2423 body := io.TeeReader(errorBody, ringBuffer) 2424 decoder := json.NewDecoder(body) 2425 decoder.UseNumber() 2426 var shape interface{} 2427 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2428 var snapshot bytes.Buffer 2429 io.Copy(&snapshot, ringBuffer) 2430 err = &smithy.DeserializationError{ 2431 Err: fmt.Errorf("failed to decode response body, %w", err), 2432 Snapshot: snapshot.Bytes(), 2433 } 2434 return err 2435 } 2436 2437 output := &types.InvalidNextTokenException{} 2438 err := awsAwsjson11_deserializeDocumentInvalidNextTokenException(&output, shape) 2439 2440 if err != nil { 2441 var snapshot bytes.Buffer 2442 io.Copy(&snapshot, ringBuffer) 2443 err = &smithy.DeserializationError{ 2444 Err: fmt.Errorf("failed to decode response body, %w", err), 2445 Snapshot: snapshot.Bytes(), 2446 } 2447 return err 2448 } 2449 2450 errorBody.Seek(0, io.SeekStart) 2451 return output 2452} 2453 2454func awsAwsjson11_deserializeErrorInvalidRequestException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 2455 var buff [1024]byte 2456 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2457 2458 body := io.TeeReader(errorBody, ringBuffer) 2459 decoder := json.NewDecoder(body) 2460 decoder.UseNumber() 2461 var shape interface{} 2462 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2463 var snapshot bytes.Buffer 2464 io.Copy(&snapshot, ringBuffer) 2465 err = &smithy.DeserializationError{ 2466 Err: fmt.Errorf("failed to decode response body, %w", err), 2467 Snapshot: snapshot.Bytes(), 2468 } 2469 return err 2470 } 2471 2472 output := &types.InvalidRequestException{} 2473 err := awsAwsjson11_deserializeDocumentInvalidRequestException(&output, shape) 2474 2475 if err != nil { 2476 var snapshot bytes.Buffer 2477 io.Copy(&snapshot, ringBuffer) 2478 err = &smithy.DeserializationError{ 2479 Err: fmt.Errorf("failed to decode response body, %w", err), 2480 Snapshot: snapshot.Bytes(), 2481 } 2482 return err 2483 } 2484 2485 errorBody.Seek(0, io.SeekStart) 2486 return output 2487} 2488 2489func awsAwsjson11_deserializeErrorResourceExistsException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 2490 var buff [1024]byte 2491 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2492 2493 body := io.TeeReader(errorBody, ringBuffer) 2494 decoder := json.NewDecoder(body) 2495 decoder.UseNumber() 2496 var shape interface{} 2497 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2498 var snapshot bytes.Buffer 2499 io.Copy(&snapshot, ringBuffer) 2500 err = &smithy.DeserializationError{ 2501 Err: fmt.Errorf("failed to decode response body, %w", err), 2502 Snapshot: snapshot.Bytes(), 2503 } 2504 return err 2505 } 2506 2507 output := &types.ResourceExistsException{} 2508 err := awsAwsjson11_deserializeDocumentResourceExistsException(&output, shape) 2509 2510 if err != nil { 2511 var snapshot bytes.Buffer 2512 io.Copy(&snapshot, ringBuffer) 2513 err = &smithy.DeserializationError{ 2514 Err: fmt.Errorf("failed to decode response body, %w", err), 2515 Snapshot: snapshot.Bytes(), 2516 } 2517 return err 2518 } 2519 2520 errorBody.Seek(0, io.SeekStart) 2521 return output 2522} 2523 2524func awsAwsjson11_deserializeErrorResourceNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 2525 var buff [1024]byte 2526 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2527 2528 body := io.TeeReader(errorBody, ringBuffer) 2529 decoder := json.NewDecoder(body) 2530 decoder.UseNumber() 2531 var shape interface{} 2532 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2533 var snapshot bytes.Buffer 2534 io.Copy(&snapshot, ringBuffer) 2535 err = &smithy.DeserializationError{ 2536 Err: fmt.Errorf("failed to decode response body, %w", err), 2537 Snapshot: snapshot.Bytes(), 2538 } 2539 return err 2540 } 2541 2542 output := &types.ResourceNotFoundException{} 2543 err := awsAwsjson11_deserializeDocumentResourceNotFoundException(&output, shape) 2544 2545 if err != nil { 2546 var snapshot bytes.Buffer 2547 io.Copy(&snapshot, ringBuffer) 2548 err = &smithy.DeserializationError{ 2549 Err: fmt.Errorf("failed to decode response body, %w", err), 2550 Snapshot: snapshot.Bytes(), 2551 } 2552 return err 2553 } 2554 2555 errorBody.Seek(0, io.SeekStart) 2556 return output 2557} 2558 2559func awsAwsjson11_deserializeErrorServiceUnavailableException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 2560 var buff [1024]byte 2561 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2562 2563 body := io.TeeReader(errorBody, ringBuffer) 2564 decoder := json.NewDecoder(body) 2565 decoder.UseNumber() 2566 var shape interface{} 2567 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2568 var snapshot bytes.Buffer 2569 io.Copy(&snapshot, ringBuffer) 2570 err = &smithy.DeserializationError{ 2571 Err: fmt.Errorf("failed to decode response body, %w", err), 2572 Snapshot: snapshot.Bytes(), 2573 } 2574 return err 2575 } 2576 2577 output := &types.ServiceUnavailableException{} 2578 err := awsAwsjson11_deserializeDocumentServiceUnavailableException(&output, shape) 2579 2580 if err != nil { 2581 var snapshot bytes.Buffer 2582 io.Copy(&snapshot, ringBuffer) 2583 err = &smithy.DeserializationError{ 2584 Err: fmt.Errorf("failed to decode response body, %w", err), 2585 Snapshot: snapshot.Bytes(), 2586 } 2587 return err 2588 } 2589 2590 errorBody.Seek(0, io.SeekStart) 2591 return output 2592} 2593 2594func awsAwsjson11_deserializeErrorThrottlingException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 2595 var buff [1024]byte 2596 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2597 2598 body := io.TeeReader(errorBody, ringBuffer) 2599 decoder := json.NewDecoder(body) 2600 decoder.UseNumber() 2601 var shape interface{} 2602 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2603 var snapshot bytes.Buffer 2604 io.Copy(&snapshot, ringBuffer) 2605 err = &smithy.DeserializationError{ 2606 Err: fmt.Errorf("failed to decode response body, %w", err), 2607 Snapshot: snapshot.Bytes(), 2608 } 2609 return err 2610 } 2611 2612 output := &types.ThrottlingException{} 2613 err := awsAwsjson11_deserializeDocumentThrottlingException(&output, shape) 2614 2615 if err != nil { 2616 var snapshot bytes.Buffer 2617 io.Copy(&snapshot, ringBuffer) 2618 err = &smithy.DeserializationError{ 2619 Err: fmt.Errorf("failed to decode response body, %w", err), 2620 Snapshot: snapshot.Bytes(), 2621 } 2622 return err 2623 } 2624 2625 errorBody.Seek(0, io.SeekStart) 2626 return output 2627} 2628 2629func awsAwsjson11_deserializeDocumentAccessDeniedException(v **types.AccessDeniedException, value interface{}) error { 2630 if v == nil { 2631 return fmt.Errorf("unexpected nil of type %T", v) 2632 } 2633 if value == nil { 2634 return nil 2635 } 2636 2637 shape, ok := value.(map[string]interface{}) 2638 if !ok { 2639 return fmt.Errorf("unexpected JSON type %v", value) 2640 } 2641 2642 var sv *types.AccessDeniedException 2643 if *v == nil { 2644 sv = &types.AccessDeniedException{} 2645 } else { 2646 sv = *v 2647 } 2648 2649 for key, value := range shape { 2650 switch key { 2651 case "Message": 2652 if value != nil { 2653 jtv, ok := value.(string) 2654 if !ok { 2655 return fmt.Errorf("expected ServiceErrorMessage to be of type string, got %T instead", value) 2656 } 2657 sv.Message = ptr.String(jtv) 2658 } 2659 2660 default: 2661 _, _ = key, value 2662 2663 } 2664 } 2665 *v = sv 2666 return nil 2667} 2668 2669func awsAwsjson11_deserializeDocumentAddressAllocationIds(v *[]string, value interface{}) error { 2670 if v == nil { 2671 return fmt.Errorf("unexpected nil of type %T", v) 2672 } 2673 if value == nil { 2674 return nil 2675 } 2676 2677 shape, ok := value.([]interface{}) 2678 if !ok { 2679 return fmt.Errorf("unexpected JSON type %v", value) 2680 } 2681 2682 var cv []string 2683 if *v == nil { 2684 cv = []string{} 2685 } else { 2686 cv = *v 2687 } 2688 2689 for _, value := range shape { 2690 var col string 2691 if value != nil { 2692 jtv, ok := value.(string) 2693 if !ok { 2694 return fmt.Errorf("expected AddressAllocationId to be of type string, got %T instead", value) 2695 } 2696 col = jtv 2697 } 2698 cv = append(cv, col) 2699 2700 } 2701 *v = cv 2702 return nil 2703} 2704 2705func awsAwsjson11_deserializeDocumentConflictException(v **types.ConflictException, value interface{}) error { 2706 if v == nil { 2707 return fmt.Errorf("unexpected nil of type %T", v) 2708 } 2709 if value == nil { 2710 return nil 2711 } 2712 2713 shape, ok := value.(map[string]interface{}) 2714 if !ok { 2715 return fmt.Errorf("unexpected JSON type %v", value) 2716 } 2717 2718 var sv *types.ConflictException 2719 if *v == nil { 2720 sv = &types.ConflictException{} 2721 } else { 2722 sv = *v 2723 } 2724 2725 for key, value := range shape { 2726 switch key { 2727 case "Message": 2728 if value != nil { 2729 jtv, ok := value.(string) 2730 if !ok { 2731 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 2732 } 2733 sv.Message = ptr.String(jtv) 2734 } 2735 2736 default: 2737 _, _ = key, value 2738 2739 } 2740 } 2741 *v = sv 2742 return nil 2743} 2744 2745func awsAwsjson11_deserializeDocumentDescribedSecurityPolicy(v **types.DescribedSecurityPolicy, value interface{}) error { 2746 if v == nil { 2747 return fmt.Errorf("unexpected nil of type %T", v) 2748 } 2749 if value == nil { 2750 return nil 2751 } 2752 2753 shape, ok := value.(map[string]interface{}) 2754 if !ok { 2755 return fmt.Errorf("unexpected JSON type %v", value) 2756 } 2757 2758 var sv *types.DescribedSecurityPolicy 2759 if *v == nil { 2760 sv = &types.DescribedSecurityPolicy{} 2761 } else { 2762 sv = *v 2763 } 2764 2765 for key, value := range shape { 2766 switch key { 2767 case "Fips": 2768 if value != nil { 2769 jtv, ok := value.(bool) 2770 if !ok { 2771 return fmt.Errorf("expected Fips to be of type *bool, got %T instead", value) 2772 } 2773 sv.Fips = ptr.Bool(jtv) 2774 } 2775 2776 case "SecurityPolicyName": 2777 if value != nil { 2778 jtv, ok := value.(string) 2779 if !ok { 2780 return fmt.Errorf("expected SecurityPolicyName to be of type string, got %T instead", value) 2781 } 2782 sv.SecurityPolicyName = ptr.String(jtv) 2783 } 2784 2785 case "SshCiphers": 2786 if err := awsAwsjson11_deserializeDocumentSecurityPolicyOptions(&sv.SshCiphers, value); err != nil { 2787 return err 2788 } 2789 2790 case "SshKexs": 2791 if err := awsAwsjson11_deserializeDocumentSecurityPolicyOptions(&sv.SshKexs, value); err != nil { 2792 return err 2793 } 2794 2795 case "SshMacs": 2796 if err := awsAwsjson11_deserializeDocumentSecurityPolicyOptions(&sv.SshMacs, value); err != nil { 2797 return err 2798 } 2799 2800 case "TlsCiphers": 2801 if err := awsAwsjson11_deserializeDocumentSecurityPolicyOptions(&sv.TlsCiphers, value); err != nil { 2802 return err 2803 } 2804 2805 default: 2806 _, _ = key, value 2807 2808 } 2809 } 2810 *v = sv 2811 return nil 2812} 2813 2814func awsAwsjson11_deserializeDocumentDescribedServer(v **types.DescribedServer, value interface{}) error { 2815 if v == nil { 2816 return fmt.Errorf("unexpected nil of type %T", v) 2817 } 2818 if value == nil { 2819 return nil 2820 } 2821 2822 shape, ok := value.(map[string]interface{}) 2823 if !ok { 2824 return fmt.Errorf("unexpected JSON type %v", value) 2825 } 2826 2827 var sv *types.DescribedServer 2828 if *v == nil { 2829 sv = &types.DescribedServer{} 2830 } else { 2831 sv = *v 2832 } 2833 2834 for key, value := range shape { 2835 switch key { 2836 case "Arn": 2837 if value != nil { 2838 jtv, ok := value.(string) 2839 if !ok { 2840 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 2841 } 2842 sv.Arn = ptr.String(jtv) 2843 } 2844 2845 case "Certificate": 2846 if value != nil { 2847 jtv, ok := value.(string) 2848 if !ok { 2849 return fmt.Errorf("expected Certificate to be of type string, got %T instead", value) 2850 } 2851 sv.Certificate = ptr.String(jtv) 2852 } 2853 2854 case "Domain": 2855 if value != nil { 2856 jtv, ok := value.(string) 2857 if !ok { 2858 return fmt.Errorf("expected Domain to be of type string, got %T instead", value) 2859 } 2860 sv.Domain = types.Domain(jtv) 2861 } 2862 2863 case "EndpointDetails": 2864 if err := awsAwsjson11_deserializeDocumentEndpointDetails(&sv.EndpointDetails, value); err != nil { 2865 return err 2866 } 2867 2868 case "EndpointType": 2869 if value != nil { 2870 jtv, ok := value.(string) 2871 if !ok { 2872 return fmt.Errorf("expected EndpointType to be of type string, got %T instead", value) 2873 } 2874 sv.EndpointType = types.EndpointType(jtv) 2875 } 2876 2877 case "HostKeyFingerprint": 2878 if value != nil { 2879 jtv, ok := value.(string) 2880 if !ok { 2881 return fmt.Errorf("expected HostKeyFingerprint to be of type string, got %T instead", value) 2882 } 2883 sv.HostKeyFingerprint = ptr.String(jtv) 2884 } 2885 2886 case "IdentityProviderDetails": 2887 if err := awsAwsjson11_deserializeDocumentIdentityProviderDetails(&sv.IdentityProviderDetails, value); err != nil { 2888 return err 2889 } 2890 2891 case "IdentityProviderType": 2892 if value != nil { 2893 jtv, ok := value.(string) 2894 if !ok { 2895 return fmt.Errorf("expected IdentityProviderType to be of type string, got %T instead", value) 2896 } 2897 sv.IdentityProviderType = types.IdentityProviderType(jtv) 2898 } 2899 2900 case "LoggingRole": 2901 if value != nil { 2902 jtv, ok := value.(string) 2903 if !ok { 2904 return fmt.Errorf("expected Role to be of type string, got %T instead", value) 2905 } 2906 sv.LoggingRole = ptr.String(jtv) 2907 } 2908 2909 case "Protocols": 2910 if err := awsAwsjson11_deserializeDocumentProtocols(&sv.Protocols, value); err != nil { 2911 return err 2912 } 2913 2914 case "SecurityPolicyName": 2915 if value != nil { 2916 jtv, ok := value.(string) 2917 if !ok { 2918 return fmt.Errorf("expected SecurityPolicyName to be of type string, got %T instead", value) 2919 } 2920 sv.SecurityPolicyName = ptr.String(jtv) 2921 } 2922 2923 case "ServerId": 2924 if value != nil { 2925 jtv, ok := value.(string) 2926 if !ok { 2927 return fmt.Errorf("expected ServerId to be of type string, got %T instead", value) 2928 } 2929 sv.ServerId = ptr.String(jtv) 2930 } 2931 2932 case "State": 2933 if value != nil { 2934 jtv, ok := value.(string) 2935 if !ok { 2936 return fmt.Errorf("expected State to be of type string, got %T instead", value) 2937 } 2938 sv.State = types.State(jtv) 2939 } 2940 2941 case "Tags": 2942 if err := awsAwsjson11_deserializeDocumentTags(&sv.Tags, value); err != nil { 2943 return err 2944 } 2945 2946 case "UserCount": 2947 if value != nil { 2948 jtv, ok := value.(json.Number) 2949 if !ok { 2950 return fmt.Errorf("expected UserCount to be json.Number, got %T instead", value) 2951 } 2952 i64, err := jtv.Int64() 2953 if err != nil { 2954 return err 2955 } 2956 sv.UserCount = ptr.Int32(int32(i64)) 2957 } 2958 2959 default: 2960 _, _ = key, value 2961 2962 } 2963 } 2964 *v = sv 2965 return nil 2966} 2967 2968func awsAwsjson11_deserializeDocumentDescribedUser(v **types.DescribedUser, value interface{}) error { 2969 if v == nil { 2970 return fmt.Errorf("unexpected nil of type %T", v) 2971 } 2972 if value == nil { 2973 return nil 2974 } 2975 2976 shape, ok := value.(map[string]interface{}) 2977 if !ok { 2978 return fmt.Errorf("unexpected JSON type %v", value) 2979 } 2980 2981 var sv *types.DescribedUser 2982 if *v == nil { 2983 sv = &types.DescribedUser{} 2984 } else { 2985 sv = *v 2986 } 2987 2988 for key, value := range shape { 2989 switch key { 2990 case "Arn": 2991 if value != nil { 2992 jtv, ok := value.(string) 2993 if !ok { 2994 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 2995 } 2996 sv.Arn = ptr.String(jtv) 2997 } 2998 2999 case "HomeDirectory": 3000 if value != nil { 3001 jtv, ok := value.(string) 3002 if !ok { 3003 return fmt.Errorf("expected HomeDirectory to be of type string, got %T instead", value) 3004 } 3005 sv.HomeDirectory = ptr.String(jtv) 3006 } 3007 3008 case "HomeDirectoryMappings": 3009 if err := awsAwsjson11_deserializeDocumentHomeDirectoryMappings(&sv.HomeDirectoryMappings, value); err != nil { 3010 return err 3011 } 3012 3013 case "HomeDirectoryType": 3014 if value != nil { 3015 jtv, ok := value.(string) 3016 if !ok { 3017 return fmt.Errorf("expected HomeDirectoryType to be of type string, got %T instead", value) 3018 } 3019 sv.HomeDirectoryType = types.HomeDirectoryType(jtv) 3020 } 3021 3022 case "Policy": 3023 if value != nil { 3024 jtv, ok := value.(string) 3025 if !ok { 3026 return fmt.Errorf("expected Policy to be of type string, got %T instead", value) 3027 } 3028 sv.Policy = ptr.String(jtv) 3029 } 3030 3031 case "PosixProfile": 3032 if err := awsAwsjson11_deserializeDocumentPosixProfile(&sv.PosixProfile, value); err != nil { 3033 return err 3034 } 3035 3036 case "Role": 3037 if value != nil { 3038 jtv, ok := value.(string) 3039 if !ok { 3040 return fmt.Errorf("expected Role to be of type string, got %T instead", value) 3041 } 3042 sv.Role = ptr.String(jtv) 3043 } 3044 3045 case "SshPublicKeys": 3046 if err := awsAwsjson11_deserializeDocumentSshPublicKeys(&sv.SshPublicKeys, value); err != nil { 3047 return err 3048 } 3049 3050 case "Tags": 3051 if err := awsAwsjson11_deserializeDocumentTags(&sv.Tags, value); err != nil { 3052 return err 3053 } 3054 3055 case "UserName": 3056 if value != nil { 3057 jtv, ok := value.(string) 3058 if !ok { 3059 return fmt.Errorf("expected UserName to be of type string, got %T instead", value) 3060 } 3061 sv.UserName = ptr.String(jtv) 3062 } 3063 3064 default: 3065 _, _ = key, value 3066 3067 } 3068 } 3069 *v = sv 3070 return nil 3071} 3072 3073func awsAwsjson11_deserializeDocumentEndpointDetails(v **types.EndpointDetails, value interface{}) error { 3074 if v == nil { 3075 return fmt.Errorf("unexpected nil of type %T", v) 3076 } 3077 if value == nil { 3078 return nil 3079 } 3080 3081 shape, ok := value.(map[string]interface{}) 3082 if !ok { 3083 return fmt.Errorf("unexpected JSON type %v", value) 3084 } 3085 3086 var sv *types.EndpointDetails 3087 if *v == nil { 3088 sv = &types.EndpointDetails{} 3089 } else { 3090 sv = *v 3091 } 3092 3093 for key, value := range shape { 3094 switch key { 3095 case "AddressAllocationIds": 3096 if err := awsAwsjson11_deserializeDocumentAddressAllocationIds(&sv.AddressAllocationIds, value); err != nil { 3097 return err 3098 } 3099 3100 case "SecurityGroupIds": 3101 if err := awsAwsjson11_deserializeDocumentSecurityGroupIds(&sv.SecurityGroupIds, value); err != nil { 3102 return err 3103 } 3104 3105 case "SubnetIds": 3106 if err := awsAwsjson11_deserializeDocumentSubnetIds(&sv.SubnetIds, value); err != nil { 3107 return err 3108 } 3109 3110 case "VpcEndpointId": 3111 if value != nil { 3112 jtv, ok := value.(string) 3113 if !ok { 3114 return fmt.Errorf("expected VpcEndpointId to be of type string, got %T instead", value) 3115 } 3116 sv.VpcEndpointId = ptr.String(jtv) 3117 } 3118 3119 case "VpcId": 3120 if value != nil { 3121 jtv, ok := value.(string) 3122 if !ok { 3123 return fmt.Errorf("expected VpcId to be of type string, got %T instead", value) 3124 } 3125 sv.VpcId = ptr.String(jtv) 3126 } 3127 3128 default: 3129 _, _ = key, value 3130 3131 } 3132 } 3133 *v = sv 3134 return nil 3135} 3136 3137func awsAwsjson11_deserializeDocumentHomeDirectoryMapEntry(v **types.HomeDirectoryMapEntry, value interface{}) error { 3138 if v == nil { 3139 return fmt.Errorf("unexpected nil of type %T", v) 3140 } 3141 if value == nil { 3142 return nil 3143 } 3144 3145 shape, ok := value.(map[string]interface{}) 3146 if !ok { 3147 return fmt.Errorf("unexpected JSON type %v", value) 3148 } 3149 3150 var sv *types.HomeDirectoryMapEntry 3151 if *v == nil { 3152 sv = &types.HomeDirectoryMapEntry{} 3153 } else { 3154 sv = *v 3155 } 3156 3157 for key, value := range shape { 3158 switch key { 3159 case "Entry": 3160 if value != nil { 3161 jtv, ok := value.(string) 3162 if !ok { 3163 return fmt.Errorf("expected MapEntry to be of type string, got %T instead", value) 3164 } 3165 sv.Entry = ptr.String(jtv) 3166 } 3167 3168 case "Target": 3169 if value != nil { 3170 jtv, ok := value.(string) 3171 if !ok { 3172 return fmt.Errorf("expected MapTarget to be of type string, got %T instead", value) 3173 } 3174 sv.Target = ptr.String(jtv) 3175 } 3176 3177 default: 3178 _, _ = key, value 3179 3180 } 3181 } 3182 *v = sv 3183 return nil 3184} 3185 3186func awsAwsjson11_deserializeDocumentHomeDirectoryMappings(v *[]types.HomeDirectoryMapEntry, value interface{}) error { 3187 if v == nil { 3188 return fmt.Errorf("unexpected nil of type %T", v) 3189 } 3190 if value == nil { 3191 return nil 3192 } 3193 3194 shape, ok := value.([]interface{}) 3195 if !ok { 3196 return fmt.Errorf("unexpected JSON type %v", value) 3197 } 3198 3199 var cv []types.HomeDirectoryMapEntry 3200 if *v == nil { 3201 cv = []types.HomeDirectoryMapEntry{} 3202 } else { 3203 cv = *v 3204 } 3205 3206 for _, value := range shape { 3207 var col types.HomeDirectoryMapEntry 3208 destAddr := &col 3209 if err := awsAwsjson11_deserializeDocumentHomeDirectoryMapEntry(&destAddr, value); err != nil { 3210 return err 3211 } 3212 col = *destAddr 3213 cv = append(cv, col) 3214 3215 } 3216 *v = cv 3217 return nil 3218} 3219 3220func awsAwsjson11_deserializeDocumentIdentityProviderDetails(v **types.IdentityProviderDetails, value interface{}) error { 3221 if v == nil { 3222 return fmt.Errorf("unexpected nil of type %T", v) 3223 } 3224 if value == nil { 3225 return nil 3226 } 3227 3228 shape, ok := value.(map[string]interface{}) 3229 if !ok { 3230 return fmt.Errorf("unexpected JSON type %v", value) 3231 } 3232 3233 var sv *types.IdentityProviderDetails 3234 if *v == nil { 3235 sv = &types.IdentityProviderDetails{} 3236 } else { 3237 sv = *v 3238 } 3239 3240 for key, value := range shape { 3241 switch key { 3242 case "InvocationRole": 3243 if value != nil { 3244 jtv, ok := value.(string) 3245 if !ok { 3246 return fmt.Errorf("expected Role to be of type string, got %T instead", value) 3247 } 3248 sv.InvocationRole = ptr.String(jtv) 3249 } 3250 3251 case "Url": 3252 if value != nil { 3253 jtv, ok := value.(string) 3254 if !ok { 3255 return fmt.Errorf("expected Url to be of type string, got %T instead", value) 3256 } 3257 sv.Url = ptr.String(jtv) 3258 } 3259 3260 default: 3261 _, _ = key, value 3262 3263 } 3264 } 3265 *v = sv 3266 return nil 3267} 3268 3269func awsAwsjson11_deserializeDocumentInternalServiceError(v **types.InternalServiceError, value interface{}) error { 3270 if v == nil { 3271 return fmt.Errorf("unexpected nil of type %T", v) 3272 } 3273 if value == nil { 3274 return nil 3275 } 3276 3277 shape, ok := value.(map[string]interface{}) 3278 if !ok { 3279 return fmt.Errorf("unexpected JSON type %v", value) 3280 } 3281 3282 var sv *types.InternalServiceError 3283 if *v == nil { 3284 sv = &types.InternalServiceError{} 3285 } else { 3286 sv = *v 3287 } 3288 3289 for key, value := range shape { 3290 switch key { 3291 case "Message": 3292 if value != nil { 3293 jtv, ok := value.(string) 3294 if !ok { 3295 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 3296 } 3297 sv.Message = ptr.String(jtv) 3298 } 3299 3300 default: 3301 _, _ = key, value 3302 3303 } 3304 } 3305 *v = sv 3306 return nil 3307} 3308 3309func awsAwsjson11_deserializeDocumentInvalidNextTokenException(v **types.InvalidNextTokenException, value interface{}) error { 3310 if v == nil { 3311 return fmt.Errorf("unexpected nil of type %T", v) 3312 } 3313 if value == nil { 3314 return nil 3315 } 3316 3317 shape, ok := value.(map[string]interface{}) 3318 if !ok { 3319 return fmt.Errorf("unexpected JSON type %v", value) 3320 } 3321 3322 var sv *types.InvalidNextTokenException 3323 if *v == nil { 3324 sv = &types.InvalidNextTokenException{} 3325 } else { 3326 sv = *v 3327 } 3328 3329 for key, value := range shape { 3330 switch key { 3331 case "Message": 3332 if value != nil { 3333 jtv, ok := value.(string) 3334 if !ok { 3335 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 3336 } 3337 sv.Message = ptr.String(jtv) 3338 } 3339 3340 default: 3341 _, _ = key, value 3342 3343 } 3344 } 3345 *v = sv 3346 return nil 3347} 3348 3349func awsAwsjson11_deserializeDocumentInvalidRequestException(v **types.InvalidRequestException, value interface{}) error { 3350 if v == nil { 3351 return fmt.Errorf("unexpected nil of type %T", v) 3352 } 3353 if value == nil { 3354 return nil 3355 } 3356 3357 shape, ok := value.(map[string]interface{}) 3358 if !ok { 3359 return fmt.Errorf("unexpected JSON type %v", value) 3360 } 3361 3362 var sv *types.InvalidRequestException 3363 if *v == nil { 3364 sv = &types.InvalidRequestException{} 3365 } else { 3366 sv = *v 3367 } 3368 3369 for key, value := range shape { 3370 switch key { 3371 case "Message": 3372 if value != nil { 3373 jtv, ok := value.(string) 3374 if !ok { 3375 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 3376 } 3377 sv.Message = ptr.String(jtv) 3378 } 3379 3380 default: 3381 _, _ = key, value 3382 3383 } 3384 } 3385 *v = sv 3386 return nil 3387} 3388 3389func awsAwsjson11_deserializeDocumentListedServer(v **types.ListedServer, value interface{}) error { 3390 if v == nil { 3391 return fmt.Errorf("unexpected nil of type %T", v) 3392 } 3393 if value == nil { 3394 return nil 3395 } 3396 3397 shape, ok := value.(map[string]interface{}) 3398 if !ok { 3399 return fmt.Errorf("unexpected JSON type %v", value) 3400 } 3401 3402 var sv *types.ListedServer 3403 if *v == nil { 3404 sv = &types.ListedServer{} 3405 } else { 3406 sv = *v 3407 } 3408 3409 for key, value := range shape { 3410 switch key { 3411 case "Arn": 3412 if value != nil { 3413 jtv, ok := value.(string) 3414 if !ok { 3415 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 3416 } 3417 sv.Arn = ptr.String(jtv) 3418 } 3419 3420 case "Domain": 3421 if value != nil { 3422 jtv, ok := value.(string) 3423 if !ok { 3424 return fmt.Errorf("expected Domain to be of type string, got %T instead", value) 3425 } 3426 sv.Domain = types.Domain(jtv) 3427 } 3428 3429 case "EndpointType": 3430 if value != nil { 3431 jtv, ok := value.(string) 3432 if !ok { 3433 return fmt.Errorf("expected EndpointType to be of type string, got %T instead", value) 3434 } 3435 sv.EndpointType = types.EndpointType(jtv) 3436 } 3437 3438 case "IdentityProviderType": 3439 if value != nil { 3440 jtv, ok := value.(string) 3441 if !ok { 3442 return fmt.Errorf("expected IdentityProviderType to be of type string, got %T instead", value) 3443 } 3444 sv.IdentityProviderType = types.IdentityProviderType(jtv) 3445 } 3446 3447 case "LoggingRole": 3448 if value != nil { 3449 jtv, ok := value.(string) 3450 if !ok { 3451 return fmt.Errorf("expected Role to be of type string, got %T instead", value) 3452 } 3453 sv.LoggingRole = ptr.String(jtv) 3454 } 3455 3456 case "ServerId": 3457 if value != nil { 3458 jtv, ok := value.(string) 3459 if !ok { 3460 return fmt.Errorf("expected ServerId to be of type string, got %T instead", value) 3461 } 3462 sv.ServerId = ptr.String(jtv) 3463 } 3464 3465 case "State": 3466 if value != nil { 3467 jtv, ok := value.(string) 3468 if !ok { 3469 return fmt.Errorf("expected State to be of type string, got %T instead", value) 3470 } 3471 sv.State = types.State(jtv) 3472 } 3473 3474 case "UserCount": 3475 if value != nil { 3476 jtv, ok := value.(json.Number) 3477 if !ok { 3478 return fmt.Errorf("expected UserCount to be json.Number, got %T instead", value) 3479 } 3480 i64, err := jtv.Int64() 3481 if err != nil { 3482 return err 3483 } 3484 sv.UserCount = ptr.Int32(int32(i64)) 3485 } 3486 3487 default: 3488 _, _ = key, value 3489 3490 } 3491 } 3492 *v = sv 3493 return nil 3494} 3495 3496func awsAwsjson11_deserializeDocumentListedServers(v *[]types.ListedServer, value interface{}) error { 3497 if v == nil { 3498 return fmt.Errorf("unexpected nil of type %T", v) 3499 } 3500 if value == nil { 3501 return nil 3502 } 3503 3504 shape, ok := value.([]interface{}) 3505 if !ok { 3506 return fmt.Errorf("unexpected JSON type %v", value) 3507 } 3508 3509 var cv []types.ListedServer 3510 if *v == nil { 3511 cv = []types.ListedServer{} 3512 } else { 3513 cv = *v 3514 } 3515 3516 for _, value := range shape { 3517 var col types.ListedServer 3518 destAddr := &col 3519 if err := awsAwsjson11_deserializeDocumentListedServer(&destAddr, value); err != nil { 3520 return err 3521 } 3522 col = *destAddr 3523 cv = append(cv, col) 3524 3525 } 3526 *v = cv 3527 return nil 3528} 3529 3530func awsAwsjson11_deserializeDocumentListedUser(v **types.ListedUser, value interface{}) error { 3531 if v == nil { 3532 return fmt.Errorf("unexpected nil of type %T", v) 3533 } 3534 if value == nil { 3535 return nil 3536 } 3537 3538 shape, ok := value.(map[string]interface{}) 3539 if !ok { 3540 return fmt.Errorf("unexpected JSON type %v", value) 3541 } 3542 3543 var sv *types.ListedUser 3544 if *v == nil { 3545 sv = &types.ListedUser{} 3546 } else { 3547 sv = *v 3548 } 3549 3550 for key, value := range shape { 3551 switch key { 3552 case "Arn": 3553 if value != nil { 3554 jtv, ok := value.(string) 3555 if !ok { 3556 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 3557 } 3558 sv.Arn = ptr.String(jtv) 3559 } 3560 3561 case "HomeDirectory": 3562 if value != nil { 3563 jtv, ok := value.(string) 3564 if !ok { 3565 return fmt.Errorf("expected HomeDirectory to be of type string, got %T instead", value) 3566 } 3567 sv.HomeDirectory = ptr.String(jtv) 3568 } 3569 3570 case "HomeDirectoryType": 3571 if value != nil { 3572 jtv, ok := value.(string) 3573 if !ok { 3574 return fmt.Errorf("expected HomeDirectoryType to be of type string, got %T instead", value) 3575 } 3576 sv.HomeDirectoryType = types.HomeDirectoryType(jtv) 3577 } 3578 3579 case "Role": 3580 if value != nil { 3581 jtv, ok := value.(string) 3582 if !ok { 3583 return fmt.Errorf("expected Role to be of type string, got %T instead", value) 3584 } 3585 sv.Role = ptr.String(jtv) 3586 } 3587 3588 case "SshPublicKeyCount": 3589 if value != nil { 3590 jtv, ok := value.(json.Number) 3591 if !ok { 3592 return fmt.Errorf("expected SshPublicKeyCount to be json.Number, got %T instead", value) 3593 } 3594 i64, err := jtv.Int64() 3595 if err != nil { 3596 return err 3597 } 3598 sv.SshPublicKeyCount = ptr.Int32(int32(i64)) 3599 } 3600 3601 case "UserName": 3602 if value != nil { 3603 jtv, ok := value.(string) 3604 if !ok { 3605 return fmt.Errorf("expected UserName to be of type string, got %T instead", value) 3606 } 3607 sv.UserName = ptr.String(jtv) 3608 } 3609 3610 default: 3611 _, _ = key, value 3612 3613 } 3614 } 3615 *v = sv 3616 return nil 3617} 3618 3619func awsAwsjson11_deserializeDocumentListedUsers(v *[]types.ListedUser, value interface{}) error { 3620 if v == nil { 3621 return fmt.Errorf("unexpected nil of type %T", v) 3622 } 3623 if value == nil { 3624 return nil 3625 } 3626 3627 shape, ok := value.([]interface{}) 3628 if !ok { 3629 return fmt.Errorf("unexpected JSON type %v", value) 3630 } 3631 3632 var cv []types.ListedUser 3633 if *v == nil { 3634 cv = []types.ListedUser{} 3635 } else { 3636 cv = *v 3637 } 3638 3639 for _, value := range shape { 3640 var col types.ListedUser 3641 destAddr := &col 3642 if err := awsAwsjson11_deserializeDocumentListedUser(&destAddr, value); err != nil { 3643 return err 3644 } 3645 col = *destAddr 3646 cv = append(cv, col) 3647 3648 } 3649 *v = cv 3650 return nil 3651} 3652 3653func awsAwsjson11_deserializeDocumentPosixProfile(v **types.PosixProfile, value interface{}) error { 3654 if v == nil { 3655 return fmt.Errorf("unexpected nil of type %T", v) 3656 } 3657 if value == nil { 3658 return nil 3659 } 3660 3661 shape, ok := value.(map[string]interface{}) 3662 if !ok { 3663 return fmt.Errorf("unexpected JSON type %v", value) 3664 } 3665 3666 var sv *types.PosixProfile 3667 if *v == nil { 3668 sv = &types.PosixProfile{} 3669 } else { 3670 sv = *v 3671 } 3672 3673 for key, value := range shape { 3674 switch key { 3675 case "Gid": 3676 if value != nil { 3677 jtv, ok := value.(json.Number) 3678 if !ok { 3679 return fmt.Errorf("expected PosixId to be json.Number, got %T instead", value) 3680 } 3681 i64, err := jtv.Int64() 3682 if err != nil { 3683 return err 3684 } 3685 sv.Gid = ptr.Int64(i64) 3686 } 3687 3688 case "SecondaryGids": 3689 if err := awsAwsjson11_deserializeDocumentSecondaryGids(&sv.SecondaryGids, value); err != nil { 3690 return err 3691 } 3692 3693 case "Uid": 3694 if value != nil { 3695 jtv, ok := value.(json.Number) 3696 if !ok { 3697 return fmt.Errorf("expected PosixId to be json.Number, got %T instead", value) 3698 } 3699 i64, err := jtv.Int64() 3700 if err != nil { 3701 return err 3702 } 3703 sv.Uid = ptr.Int64(i64) 3704 } 3705 3706 default: 3707 _, _ = key, value 3708 3709 } 3710 } 3711 *v = sv 3712 return nil 3713} 3714 3715func awsAwsjson11_deserializeDocumentProtocols(v *[]types.Protocol, value interface{}) error { 3716 if v == nil { 3717 return fmt.Errorf("unexpected nil of type %T", v) 3718 } 3719 if value == nil { 3720 return nil 3721 } 3722 3723 shape, ok := value.([]interface{}) 3724 if !ok { 3725 return fmt.Errorf("unexpected JSON type %v", value) 3726 } 3727 3728 var cv []types.Protocol 3729 if *v == nil { 3730 cv = []types.Protocol{} 3731 } else { 3732 cv = *v 3733 } 3734 3735 for _, value := range shape { 3736 var col types.Protocol 3737 if value != nil { 3738 jtv, ok := value.(string) 3739 if !ok { 3740 return fmt.Errorf("expected Protocol to be of type string, got %T instead", value) 3741 } 3742 col = types.Protocol(jtv) 3743 } 3744 cv = append(cv, col) 3745 3746 } 3747 *v = cv 3748 return nil 3749} 3750 3751func awsAwsjson11_deserializeDocumentResourceExistsException(v **types.ResourceExistsException, value interface{}) error { 3752 if v == nil { 3753 return fmt.Errorf("unexpected nil of type %T", v) 3754 } 3755 if value == nil { 3756 return nil 3757 } 3758 3759 shape, ok := value.(map[string]interface{}) 3760 if !ok { 3761 return fmt.Errorf("unexpected JSON type %v", value) 3762 } 3763 3764 var sv *types.ResourceExistsException 3765 if *v == nil { 3766 sv = &types.ResourceExistsException{} 3767 } else { 3768 sv = *v 3769 } 3770 3771 for key, value := range shape { 3772 switch key { 3773 case "Message": 3774 if value != nil { 3775 jtv, ok := value.(string) 3776 if !ok { 3777 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 3778 } 3779 sv.Message = ptr.String(jtv) 3780 } 3781 3782 case "Resource": 3783 if value != nil { 3784 jtv, ok := value.(string) 3785 if !ok { 3786 return fmt.Errorf("expected Resource to be of type string, got %T instead", value) 3787 } 3788 sv.Resource = ptr.String(jtv) 3789 } 3790 3791 case "ResourceType": 3792 if value != nil { 3793 jtv, ok := value.(string) 3794 if !ok { 3795 return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value) 3796 } 3797 sv.ResourceType = ptr.String(jtv) 3798 } 3799 3800 default: 3801 _, _ = key, value 3802 3803 } 3804 } 3805 *v = sv 3806 return nil 3807} 3808 3809func awsAwsjson11_deserializeDocumentResourceNotFoundException(v **types.ResourceNotFoundException, value interface{}) error { 3810 if v == nil { 3811 return fmt.Errorf("unexpected nil of type %T", v) 3812 } 3813 if value == nil { 3814 return nil 3815 } 3816 3817 shape, ok := value.(map[string]interface{}) 3818 if !ok { 3819 return fmt.Errorf("unexpected JSON type %v", value) 3820 } 3821 3822 var sv *types.ResourceNotFoundException 3823 if *v == nil { 3824 sv = &types.ResourceNotFoundException{} 3825 } else { 3826 sv = *v 3827 } 3828 3829 for key, value := range shape { 3830 switch key { 3831 case "Message": 3832 if value != nil { 3833 jtv, ok := value.(string) 3834 if !ok { 3835 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 3836 } 3837 sv.Message = ptr.String(jtv) 3838 } 3839 3840 case "Resource": 3841 if value != nil { 3842 jtv, ok := value.(string) 3843 if !ok { 3844 return fmt.Errorf("expected Resource to be of type string, got %T instead", value) 3845 } 3846 sv.Resource = ptr.String(jtv) 3847 } 3848 3849 case "ResourceType": 3850 if value != nil { 3851 jtv, ok := value.(string) 3852 if !ok { 3853 return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value) 3854 } 3855 sv.ResourceType = ptr.String(jtv) 3856 } 3857 3858 default: 3859 _, _ = key, value 3860 3861 } 3862 } 3863 *v = sv 3864 return nil 3865} 3866 3867func awsAwsjson11_deserializeDocumentSecondaryGids(v *[]int64, value interface{}) error { 3868 if v == nil { 3869 return fmt.Errorf("unexpected nil of type %T", v) 3870 } 3871 if value == nil { 3872 return nil 3873 } 3874 3875 shape, ok := value.([]interface{}) 3876 if !ok { 3877 return fmt.Errorf("unexpected JSON type %v", value) 3878 } 3879 3880 var cv []int64 3881 if *v == nil { 3882 cv = []int64{} 3883 } else { 3884 cv = *v 3885 } 3886 3887 for _, value := range shape { 3888 var col int64 3889 if value != nil { 3890 jtv, ok := value.(json.Number) 3891 if !ok { 3892 return fmt.Errorf("expected PosixId to be json.Number, got %T instead", value) 3893 } 3894 i64, err := jtv.Int64() 3895 if err != nil { 3896 return err 3897 } 3898 col = i64 3899 } 3900 cv = append(cv, col) 3901 3902 } 3903 *v = cv 3904 return nil 3905} 3906 3907func awsAwsjson11_deserializeDocumentSecurityGroupIds(v *[]string, value interface{}) error { 3908 if v == nil { 3909 return fmt.Errorf("unexpected nil of type %T", v) 3910 } 3911 if value == nil { 3912 return nil 3913 } 3914 3915 shape, ok := value.([]interface{}) 3916 if !ok { 3917 return fmt.Errorf("unexpected JSON type %v", value) 3918 } 3919 3920 var cv []string 3921 if *v == nil { 3922 cv = []string{} 3923 } else { 3924 cv = *v 3925 } 3926 3927 for _, value := range shape { 3928 var col string 3929 if value != nil { 3930 jtv, ok := value.(string) 3931 if !ok { 3932 return fmt.Errorf("expected SecurityGroupId to be of type string, got %T instead", value) 3933 } 3934 col = jtv 3935 } 3936 cv = append(cv, col) 3937 3938 } 3939 *v = cv 3940 return nil 3941} 3942 3943func awsAwsjson11_deserializeDocumentSecurityPolicyNames(v *[]string, value interface{}) error { 3944 if v == nil { 3945 return fmt.Errorf("unexpected nil of type %T", v) 3946 } 3947 if value == nil { 3948 return nil 3949 } 3950 3951 shape, ok := value.([]interface{}) 3952 if !ok { 3953 return fmt.Errorf("unexpected JSON type %v", value) 3954 } 3955 3956 var cv []string 3957 if *v == nil { 3958 cv = []string{} 3959 } else { 3960 cv = *v 3961 } 3962 3963 for _, value := range shape { 3964 var col string 3965 if value != nil { 3966 jtv, ok := value.(string) 3967 if !ok { 3968 return fmt.Errorf("expected SecurityPolicyName to be of type string, got %T instead", value) 3969 } 3970 col = jtv 3971 } 3972 cv = append(cv, col) 3973 3974 } 3975 *v = cv 3976 return nil 3977} 3978 3979func awsAwsjson11_deserializeDocumentSecurityPolicyOptions(v *[]string, value interface{}) error { 3980 if v == nil { 3981 return fmt.Errorf("unexpected nil of type %T", v) 3982 } 3983 if value == nil { 3984 return nil 3985 } 3986 3987 shape, ok := value.([]interface{}) 3988 if !ok { 3989 return fmt.Errorf("unexpected JSON type %v", value) 3990 } 3991 3992 var cv []string 3993 if *v == nil { 3994 cv = []string{} 3995 } else { 3996 cv = *v 3997 } 3998 3999 for _, value := range shape { 4000 var col string 4001 if value != nil { 4002 jtv, ok := value.(string) 4003 if !ok { 4004 return fmt.Errorf("expected SecurityPolicyOption to be of type string, got %T instead", value) 4005 } 4006 col = jtv 4007 } 4008 cv = append(cv, col) 4009 4010 } 4011 *v = cv 4012 return nil 4013} 4014 4015func awsAwsjson11_deserializeDocumentServiceUnavailableException(v **types.ServiceUnavailableException, value interface{}) error { 4016 if v == nil { 4017 return fmt.Errorf("unexpected nil of type %T", v) 4018 } 4019 if value == nil { 4020 return nil 4021 } 4022 4023 shape, ok := value.(map[string]interface{}) 4024 if !ok { 4025 return fmt.Errorf("unexpected JSON type %v", value) 4026 } 4027 4028 var sv *types.ServiceUnavailableException 4029 if *v == nil { 4030 sv = &types.ServiceUnavailableException{} 4031 } else { 4032 sv = *v 4033 } 4034 4035 for key, value := range shape { 4036 switch key { 4037 case "Message": 4038 if value != nil { 4039 jtv, ok := value.(string) 4040 if !ok { 4041 return fmt.Errorf("expected ServiceErrorMessage to be of type string, got %T instead", value) 4042 } 4043 sv.Message = ptr.String(jtv) 4044 } 4045 4046 default: 4047 _, _ = key, value 4048 4049 } 4050 } 4051 *v = sv 4052 return nil 4053} 4054 4055func awsAwsjson11_deserializeDocumentSshPublicKey(v **types.SshPublicKey, value interface{}) error { 4056 if v == nil { 4057 return fmt.Errorf("unexpected nil of type %T", v) 4058 } 4059 if value == nil { 4060 return nil 4061 } 4062 4063 shape, ok := value.(map[string]interface{}) 4064 if !ok { 4065 return fmt.Errorf("unexpected JSON type %v", value) 4066 } 4067 4068 var sv *types.SshPublicKey 4069 if *v == nil { 4070 sv = &types.SshPublicKey{} 4071 } else { 4072 sv = *v 4073 } 4074 4075 for key, value := range shape { 4076 switch key { 4077 case "DateImported": 4078 if value != nil { 4079 jtv, ok := value.(json.Number) 4080 if !ok { 4081 return fmt.Errorf("expected DateImported to be json.Number, got %T instead", value) 4082 } 4083 f64, err := jtv.Float64() 4084 if err != nil { 4085 return err 4086 } 4087 sv.DateImported = ptr.Time(smithytime.ParseEpochSeconds(f64)) 4088 } 4089 4090 case "SshPublicKeyBody": 4091 if value != nil { 4092 jtv, ok := value.(string) 4093 if !ok { 4094 return fmt.Errorf("expected SshPublicKeyBody to be of type string, got %T instead", value) 4095 } 4096 sv.SshPublicKeyBody = ptr.String(jtv) 4097 } 4098 4099 case "SshPublicKeyId": 4100 if value != nil { 4101 jtv, ok := value.(string) 4102 if !ok { 4103 return fmt.Errorf("expected SshPublicKeyId to be of type string, got %T instead", value) 4104 } 4105 sv.SshPublicKeyId = ptr.String(jtv) 4106 } 4107 4108 default: 4109 _, _ = key, value 4110 4111 } 4112 } 4113 *v = sv 4114 return nil 4115} 4116 4117func awsAwsjson11_deserializeDocumentSshPublicKeys(v *[]types.SshPublicKey, value interface{}) error { 4118 if v == nil { 4119 return fmt.Errorf("unexpected nil of type %T", v) 4120 } 4121 if value == nil { 4122 return nil 4123 } 4124 4125 shape, ok := value.([]interface{}) 4126 if !ok { 4127 return fmt.Errorf("unexpected JSON type %v", value) 4128 } 4129 4130 var cv []types.SshPublicKey 4131 if *v == nil { 4132 cv = []types.SshPublicKey{} 4133 } else { 4134 cv = *v 4135 } 4136 4137 for _, value := range shape { 4138 var col types.SshPublicKey 4139 destAddr := &col 4140 if err := awsAwsjson11_deserializeDocumentSshPublicKey(&destAddr, value); err != nil { 4141 return err 4142 } 4143 col = *destAddr 4144 cv = append(cv, col) 4145 4146 } 4147 *v = cv 4148 return nil 4149} 4150 4151func awsAwsjson11_deserializeDocumentSubnetIds(v *[]string, value interface{}) error { 4152 if v == nil { 4153 return fmt.Errorf("unexpected nil of type %T", v) 4154 } 4155 if value == nil { 4156 return nil 4157 } 4158 4159 shape, ok := value.([]interface{}) 4160 if !ok { 4161 return fmt.Errorf("unexpected JSON type %v", value) 4162 } 4163 4164 var cv []string 4165 if *v == nil { 4166 cv = []string{} 4167 } else { 4168 cv = *v 4169 } 4170 4171 for _, value := range shape { 4172 var col string 4173 if value != nil { 4174 jtv, ok := value.(string) 4175 if !ok { 4176 return fmt.Errorf("expected SubnetId to be of type string, got %T instead", value) 4177 } 4178 col = jtv 4179 } 4180 cv = append(cv, col) 4181 4182 } 4183 *v = cv 4184 return nil 4185} 4186 4187func awsAwsjson11_deserializeDocumentTag(v **types.Tag, value interface{}) error { 4188 if v == nil { 4189 return fmt.Errorf("unexpected nil of type %T", v) 4190 } 4191 if value == nil { 4192 return nil 4193 } 4194 4195 shape, ok := value.(map[string]interface{}) 4196 if !ok { 4197 return fmt.Errorf("unexpected JSON type %v", value) 4198 } 4199 4200 var sv *types.Tag 4201 if *v == nil { 4202 sv = &types.Tag{} 4203 } else { 4204 sv = *v 4205 } 4206 4207 for key, value := range shape { 4208 switch key { 4209 case "Key": 4210 if value != nil { 4211 jtv, ok := value.(string) 4212 if !ok { 4213 return fmt.Errorf("expected TagKey to be of type string, got %T instead", value) 4214 } 4215 sv.Key = ptr.String(jtv) 4216 } 4217 4218 case "Value": 4219 if value != nil { 4220 jtv, ok := value.(string) 4221 if !ok { 4222 return fmt.Errorf("expected TagValue to be of type string, got %T instead", value) 4223 } 4224 sv.Value = ptr.String(jtv) 4225 } 4226 4227 default: 4228 _, _ = key, value 4229 4230 } 4231 } 4232 *v = sv 4233 return nil 4234} 4235 4236func awsAwsjson11_deserializeDocumentTags(v *[]types.Tag, value interface{}) error { 4237 if v == nil { 4238 return fmt.Errorf("unexpected nil of type %T", v) 4239 } 4240 if value == nil { 4241 return nil 4242 } 4243 4244 shape, ok := value.([]interface{}) 4245 if !ok { 4246 return fmt.Errorf("unexpected JSON type %v", value) 4247 } 4248 4249 var cv []types.Tag 4250 if *v == nil { 4251 cv = []types.Tag{} 4252 } else { 4253 cv = *v 4254 } 4255 4256 for _, value := range shape { 4257 var col types.Tag 4258 destAddr := &col 4259 if err := awsAwsjson11_deserializeDocumentTag(&destAddr, value); err != nil { 4260 return err 4261 } 4262 col = *destAddr 4263 cv = append(cv, col) 4264 4265 } 4266 *v = cv 4267 return nil 4268} 4269 4270func awsAwsjson11_deserializeDocumentThrottlingException(v **types.ThrottlingException, value interface{}) error { 4271 if v == nil { 4272 return fmt.Errorf("unexpected nil of type %T", v) 4273 } 4274 if value == nil { 4275 return nil 4276 } 4277 4278 shape, ok := value.(map[string]interface{}) 4279 if !ok { 4280 return fmt.Errorf("unexpected JSON type %v", value) 4281 } 4282 4283 var sv *types.ThrottlingException 4284 if *v == nil { 4285 sv = &types.ThrottlingException{} 4286 } else { 4287 sv = *v 4288 } 4289 4290 for key, value := range shape { 4291 switch key { 4292 case "RetryAfterSeconds": 4293 if value != nil { 4294 jtv, ok := value.(string) 4295 if !ok { 4296 return fmt.Errorf("expected RetryAfterSeconds to be of type string, got %T instead", value) 4297 } 4298 sv.RetryAfterSeconds = ptr.String(jtv) 4299 } 4300 4301 default: 4302 _, _ = key, value 4303 4304 } 4305 } 4306 *v = sv 4307 return nil 4308} 4309 4310func awsAwsjson11_deserializeOpDocumentCreateServerOutput(v **CreateServerOutput, value interface{}) error { 4311 if v == nil { 4312 return fmt.Errorf("unexpected nil of type %T", v) 4313 } 4314 if value == nil { 4315 return nil 4316 } 4317 4318 shape, ok := value.(map[string]interface{}) 4319 if !ok { 4320 return fmt.Errorf("unexpected JSON type %v", value) 4321 } 4322 4323 var sv *CreateServerOutput 4324 if *v == nil { 4325 sv = &CreateServerOutput{} 4326 } else { 4327 sv = *v 4328 } 4329 4330 for key, value := range shape { 4331 switch key { 4332 case "ServerId": 4333 if value != nil { 4334 jtv, ok := value.(string) 4335 if !ok { 4336 return fmt.Errorf("expected ServerId to be of type string, got %T instead", value) 4337 } 4338 sv.ServerId = ptr.String(jtv) 4339 } 4340 4341 default: 4342 _, _ = key, value 4343 4344 } 4345 } 4346 *v = sv 4347 return nil 4348} 4349 4350func awsAwsjson11_deserializeOpDocumentCreateUserOutput(v **CreateUserOutput, value interface{}) error { 4351 if v == nil { 4352 return fmt.Errorf("unexpected nil of type %T", v) 4353 } 4354 if value == nil { 4355 return nil 4356 } 4357 4358 shape, ok := value.(map[string]interface{}) 4359 if !ok { 4360 return fmt.Errorf("unexpected JSON type %v", value) 4361 } 4362 4363 var sv *CreateUserOutput 4364 if *v == nil { 4365 sv = &CreateUserOutput{} 4366 } else { 4367 sv = *v 4368 } 4369 4370 for key, value := range shape { 4371 switch key { 4372 case "ServerId": 4373 if value != nil { 4374 jtv, ok := value.(string) 4375 if !ok { 4376 return fmt.Errorf("expected ServerId to be of type string, got %T instead", value) 4377 } 4378 sv.ServerId = ptr.String(jtv) 4379 } 4380 4381 case "UserName": 4382 if value != nil { 4383 jtv, ok := value.(string) 4384 if !ok { 4385 return fmt.Errorf("expected UserName to be of type string, got %T instead", value) 4386 } 4387 sv.UserName = ptr.String(jtv) 4388 } 4389 4390 default: 4391 _, _ = key, value 4392 4393 } 4394 } 4395 *v = sv 4396 return nil 4397} 4398 4399func awsAwsjson11_deserializeOpDocumentDescribeSecurityPolicyOutput(v **DescribeSecurityPolicyOutput, value interface{}) error { 4400 if v == nil { 4401 return fmt.Errorf("unexpected nil of type %T", v) 4402 } 4403 if value == nil { 4404 return nil 4405 } 4406 4407 shape, ok := value.(map[string]interface{}) 4408 if !ok { 4409 return fmt.Errorf("unexpected JSON type %v", value) 4410 } 4411 4412 var sv *DescribeSecurityPolicyOutput 4413 if *v == nil { 4414 sv = &DescribeSecurityPolicyOutput{} 4415 } else { 4416 sv = *v 4417 } 4418 4419 for key, value := range shape { 4420 switch key { 4421 case "SecurityPolicy": 4422 if err := awsAwsjson11_deserializeDocumentDescribedSecurityPolicy(&sv.SecurityPolicy, value); err != nil { 4423 return err 4424 } 4425 4426 default: 4427 _, _ = key, value 4428 4429 } 4430 } 4431 *v = sv 4432 return nil 4433} 4434 4435func awsAwsjson11_deserializeOpDocumentDescribeServerOutput(v **DescribeServerOutput, value interface{}) error { 4436 if v == nil { 4437 return fmt.Errorf("unexpected nil of type %T", v) 4438 } 4439 if value == nil { 4440 return nil 4441 } 4442 4443 shape, ok := value.(map[string]interface{}) 4444 if !ok { 4445 return fmt.Errorf("unexpected JSON type %v", value) 4446 } 4447 4448 var sv *DescribeServerOutput 4449 if *v == nil { 4450 sv = &DescribeServerOutput{} 4451 } else { 4452 sv = *v 4453 } 4454 4455 for key, value := range shape { 4456 switch key { 4457 case "Server": 4458 if err := awsAwsjson11_deserializeDocumentDescribedServer(&sv.Server, value); err != nil { 4459 return err 4460 } 4461 4462 default: 4463 _, _ = key, value 4464 4465 } 4466 } 4467 *v = sv 4468 return nil 4469} 4470 4471func awsAwsjson11_deserializeOpDocumentDescribeUserOutput(v **DescribeUserOutput, value interface{}) error { 4472 if v == nil { 4473 return fmt.Errorf("unexpected nil of type %T", v) 4474 } 4475 if value == nil { 4476 return nil 4477 } 4478 4479 shape, ok := value.(map[string]interface{}) 4480 if !ok { 4481 return fmt.Errorf("unexpected JSON type %v", value) 4482 } 4483 4484 var sv *DescribeUserOutput 4485 if *v == nil { 4486 sv = &DescribeUserOutput{} 4487 } else { 4488 sv = *v 4489 } 4490 4491 for key, value := range shape { 4492 switch key { 4493 case "ServerId": 4494 if value != nil { 4495 jtv, ok := value.(string) 4496 if !ok { 4497 return fmt.Errorf("expected ServerId to be of type string, got %T instead", value) 4498 } 4499 sv.ServerId = ptr.String(jtv) 4500 } 4501 4502 case "User": 4503 if err := awsAwsjson11_deserializeDocumentDescribedUser(&sv.User, value); err != nil { 4504 return err 4505 } 4506 4507 default: 4508 _, _ = key, value 4509 4510 } 4511 } 4512 *v = sv 4513 return nil 4514} 4515 4516func awsAwsjson11_deserializeOpDocumentImportSshPublicKeyOutput(v **ImportSshPublicKeyOutput, value interface{}) error { 4517 if v == nil { 4518 return fmt.Errorf("unexpected nil of type %T", v) 4519 } 4520 if value == nil { 4521 return nil 4522 } 4523 4524 shape, ok := value.(map[string]interface{}) 4525 if !ok { 4526 return fmt.Errorf("unexpected JSON type %v", value) 4527 } 4528 4529 var sv *ImportSshPublicKeyOutput 4530 if *v == nil { 4531 sv = &ImportSshPublicKeyOutput{} 4532 } else { 4533 sv = *v 4534 } 4535 4536 for key, value := range shape { 4537 switch key { 4538 case "ServerId": 4539 if value != nil { 4540 jtv, ok := value.(string) 4541 if !ok { 4542 return fmt.Errorf("expected ServerId to be of type string, got %T instead", value) 4543 } 4544 sv.ServerId = ptr.String(jtv) 4545 } 4546 4547 case "SshPublicKeyId": 4548 if value != nil { 4549 jtv, ok := value.(string) 4550 if !ok { 4551 return fmt.Errorf("expected SshPublicKeyId to be of type string, got %T instead", value) 4552 } 4553 sv.SshPublicKeyId = ptr.String(jtv) 4554 } 4555 4556 case "UserName": 4557 if value != nil { 4558 jtv, ok := value.(string) 4559 if !ok { 4560 return fmt.Errorf("expected UserName to be of type string, got %T instead", value) 4561 } 4562 sv.UserName = ptr.String(jtv) 4563 } 4564 4565 default: 4566 _, _ = key, value 4567 4568 } 4569 } 4570 *v = sv 4571 return nil 4572} 4573 4574func awsAwsjson11_deserializeOpDocumentListSecurityPoliciesOutput(v **ListSecurityPoliciesOutput, value interface{}) error { 4575 if v == nil { 4576 return fmt.Errorf("unexpected nil of type %T", v) 4577 } 4578 if value == nil { 4579 return nil 4580 } 4581 4582 shape, ok := value.(map[string]interface{}) 4583 if !ok { 4584 return fmt.Errorf("unexpected JSON type %v", value) 4585 } 4586 4587 var sv *ListSecurityPoliciesOutput 4588 if *v == nil { 4589 sv = &ListSecurityPoliciesOutput{} 4590 } else { 4591 sv = *v 4592 } 4593 4594 for key, value := range shape { 4595 switch key { 4596 case "NextToken": 4597 if value != nil { 4598 jtv, ok := value.(string) 4599 if !ok { 4600 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 4601 } 4602 sv.NextToken = ptr.String(jtv) 4603 } 4604 4605 case "SecurityPolicyNames": 4606 if err := awsAwsjson11_deserializeDocumentSecurityPolicyNames(&sv.SecurityPolicyNames, value); err != nil { 4607 return err 4608 } 4609 4610 default: 4611 _, _ = key, value 4612 4613 } 4614 } 4615 *v = sv 4616 return nil 4617} 4618 4619func awsAwsjson11_deserializeOpDocumentListServersOutput(v **ListServersOutput, value interface{}) error { 4620 if v == nil { 4621 return fmt.Errorf("unexpected nil of type %T", v) 4622 } 4623 if value == nil { 4624 return nil 4625 } 4626 4627 shape, ok := value.(map[string]interface{}) 4628 if !ok { 4629 return fmt.Errorf("unexpected JSON type %v", value) 4630 } 4631 4632 var sv *ListServersOutput 4633 if *v == nil { 4634 sv = &ListServersOutput{} 4635 } else { 4636 sv = *v 4637 } 4638 4639 for key, value := range shape { 4640 switch key { 4641 case "NextToken": 4642 if value != nil { 4643 jtv, ok := value.(string) 4644 if !ok { 4645 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 4646 } 4647 sv.NextToken = ptr.String(jtv) 4648 } 4649 4650 case "Servers": 4651 if err := awsAwsjson11_deserializeDocumentListedServers(&sv.Servers, value); err != nil { 4652 return err 4653 } 4654 4655 default: 4656 _, _ = key, value 4657 4658 } 4659 } 4660 *v = sv 4661 return nil 4662} 4663 4664func awsAwsjson11_deserializeOpDocumentListTagsForResourceOutput(v **ListTagsForResourceOutput, value interface{}) error { 4665 if v == nil { 4666 return fmt.Errorf("unexpected nil of type %T", v) 4667 } 4668 if value == nil { 4669 return nil 4670 } 4671 4672 shape, ok := value.(map[string]interface{}) 4673 if !ok { 4674 return fmt.Errorf("unexpected JSON type %v", value) 4675 } 4676 4677 var sv *ListTagsForResourceOutput 4678 if *v == nil { 4679 sv = &ListTagsForResourceOutput{} 4680 } else { 4681 sv = *v 4682 } 4683 4684 for key, value := range shape { 4685 switch key { 4686 case "Arn": 4687 if value != nil { 4688 jtv, ok := value.(string) 4689 if !ok { 4690 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 4691 } 4692 sv.Arn = ptr.String(jtv) 4693 } 4694 4695 case "NextToken": 4696 if value != nil { 4697 jtv, ok := value.(string) 4698 if !ok { 4699 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 4700 } 4701 sv.NextToken = ptr.String(jtv) 4702 } 4703 4704 case "Tags": 4705 if err := awsAwsjson11_deserializeDocumentTags(&sv.Tags, value); err != nil { 4706 return err 4707 } 4708 4709 default: 4710 _, _ = key, value 4711 4712 } 4713 } 4714 *v = sv 4715 return nil 4716} 4717 4718func awsAwsjson11_deserializeOpDocumentListUsersOutput(v **ListUsersOutput, value interface{}) error { 4719 if v == nil { 4720 return fmt.Errorf("unexpected nil of type %T", v) 4721 } 4722 if value == nil { 4723 return nil 4724 } 4725 4726 shape, ok := value.(map[string]interface{}) 4727 if !ok { 4728 return fmt.Errorf("unexpected JSON type %v", value) 4729 } 4730 4731 var sv *ListUsersOutput 4732 if *v == nil { 4733 sv = &ListUsersOutput{} 4734 } else { 4735 sv = *v 4736 } 4737 4738 for key, value := range shape { 4739 switch key { 4740 case "NextToken": 4741 if value != nil { 4742 jtv, ok := value.(string) 4743 if !ok { 4744 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 4745 } 4746 sv.NextToken = ptr.String(jtv) 4747 } 4748 4749 case "ServerId": 4750 if value != nil { 4751 jtv, ok := value.(string) 4752 if !ok { 4753 return fmt.Errorf("expected ServerId to be of type string, got %T instead", value) 4754 } 4755 sv.ServerId = ptr.String(jtv) 4756 } 4757 4758 case "Users": 4759 if err := awsAwsjson11_deserializeDocumentListedUsers(&sv.Users, value); err != nil { 4760 return err 4761 } 4762 4763 default: 4764 _, _ = key, value 4765 4766 } 4767 } 4768 *v = sv 4769 return nil 4770} 4771 4772func awsAwsjson11_deserializeOpDocumentTestIdentityProviderOutput(v **TestIdentityProviderOutput, value interface{}) error { 4773 if v == nil { 4774 return fmt.Errorf("unexpected nil of type %T", v) 4775 } 4776 if value == nil { 4777 return nil 4778 } 4779 4780 shape, ok := value.(map[string]interface{}) 4781 if !ok { 4782 return fmt.Errorf("unexpected JSON type %v", value) 4783 } 4784 4785 var sv *TestIdentityProviderOutput 4786 if *v == nil { 4787 sv = &TestIdentityProviderOutput{} 4788 } else { 4789 sv = *v 4790 } 4791 4792 for key, value := range shape { 4793 switch key { 4794 case "Message": 4795 if value != nil { 4796 jtv, ok := value.(string) 4797 if !ok { 4798 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 4799 } 4800 sv.Message = ptr.String(jtv) 4801 } 4802 4803 case "Response": 4804 if value != nil { 4805 jtv, ok := value.(string) 4806 if !ok { 4807 return fmt.Errorf("expected Response to be of type string, got %T instead", value) 4808 } 4809 sv.Response = ptr.String(jtv) 4810 } 4811 4812 case "StatusCode": 4813 if value != nil { 4814 jtv, ok := value.(json.Number) 4815 if !ok { 4816 return fmt.Errorf("expected StatusCode to be json.Number, got %T instead", value) 4817 } 4818 i64, err := jtv.Int64() 4819 if err != nil { 4820 return err 4821 } 4822 sv.StatusCode = int32(i64) 4823 } 4824 4825 case "Url": 4826 if value != nil { 4827 jtv, ok := value.(string) 4828 if !ok { 4829 return fmt.Errorf("expected Url to be of type string, got %T instead", value) 4830 } 4831 sv.Url = ptr.String(jtv) 4832 } 4833 4834 default: 4835 _, _ = key, value 4836 4837 } 4838 } 4839 *v = sv 4840 return nil 4841} 4842 4843func awsAwsjson11_deserializeOpDocumentUpdateServerOutput(v **UpdateServerOutput, value interface{}) error { 4844 if v == nil { 4845 return fmt.Errorf("unexpected nil of type %T", v) 4846 } 4847 if value == nil { 4848 return nil 4849 } 4850 4851 shape, ok := value.(map[string]interface{}) 4852 if !ok { 4853 return fmt.Errorf("unexpected JSON type %v", value) 4854 } 4855 4856 var sv *UpdateServerOutput 4857 if *v == nil { 4858 sv = &UpdateServerOutput{} 4859 } else { 4860 sv = *v 4861 } 4862 4863 for key, value := range shape { 4864 switch key { 4865 case "ServerId": 4866 if value != nil { 4867 jtv, ok := value.(string) 4868 if !ok { 4869 return fmt.Errorf("expected ServerId to be of type string, got %T instead", value) 4870 } 4871 sv.ServerId = ptr.String(jtv) 4872 } 4873 4874 default: 4875 _, _ = key, value 4876 4877 } 4878 } 4879 *v = sv 4880 return nil 4881} 4882 4883func awsAwsjson11_deserializeOpDocumentUpdateUserOutput(v **UpdateUserOutput, value interface{}) error { 4884 if v == nil { 4885 return fmt.Errorf("unexpected nil of type %T", v) 4886 } 4887 if value == nil { 4888 return nil 4889 } 4890 4891 shape, ok := value.(map[string]interface{}) 4892 if !ok { 4893 return fmt.Errorf("unexpected JSON type %v", value) 4894 } 4895 4896 var sv *UpdateUserOutput 4897 if *v == nil { 4898 sv = &UpdateUserOutput{} 4899 } else { 4900 sv = *v 4901 } 4902 4903 for key, value := range shape { 4904 switch key { 4905 case "ServerId": 4906 if value != nil { 4907 jtv, ok := value.(string) 4908 if !ok { 4909 return fmt.Errorf("expected ServerId to be of type string, got %T instead", value) 4910 } 4911 sv.ServerId = ptr.String(jtv) 4912 } 4913 4914 case "UserName": 4915 if value != nil { 4916 jtv, ok := value.(string) 4917 if !ok { 4918 return fmt.Errorf("expected UserName to be of type string, got %T instead", value) 4919 } 4920 sv.UserName = ptr.String(jtv) 4921 } 4922 4923 default: 4924 _, _ = key, value 4925 4926 } 4927 } 4928 *v = sv 4929 return nil 4930} 4931