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 "EndpointDetails": 2855 if err := awsAwsjson11_deserializeDocumentEndpointDetails(&sv.EndpointDetails, value); err != nil { 2856 return err 2857 } 2858 2859 case "EndpointType": 2860 if value != nil { 2861 jtv, ok := value.(string) 2862 if !ok { 2863 return fmt.Errorf("expected EndpointType to be of type string, got %T instead", value) 2864 } 2865 sv.EndpointType = types.EndpointType(jtv) 2866 } 2867 2868 case "HostKeyFingerprint": 2869 if value != nil { 2870 jtv, ok := value.(string) 2871 if !ok { 2872 return fmt.Errorf("expected HostKeyFingerprint to be of type string, got %T instead", value) 2873 } 2874 sv.HostKeyFingerprint = ptr.String(jtv) 2875 } 2876 2877 case "IdentityProviderDetails": 2878 if err := awsAwsjson11_deserializeDocumentIdentityProviderDetails(&sv.IdentityProviderDetails, value); err != nil { 2879 return err 2880 } 2881 2882 case "IdentityProviderType": 2883 if value != nil { 2884 jtv, ok := value.(string) 2885 if !ok { 2886 return fmt.Errorf("expected IdentityProviderType to be of type string, got %T instead", value) 2887 } 2888 sv.IdentityProviderType = types.IdentityProviderType(jtv) 2889 } 2890 2891 case "LoggingRole": 2892 if value != nil { 2893 jtv, ok := value.(string) 2894 if !ok { 2895 return fmt.Errorf("expected Role to be of type string, got %T instead", value) 2896 } 2897 sv.LoggingRole = ptr.String(jtv) 2898 } 2899 2900 case "Protocols": 2901 if err := awsAwsjson11_deserializeDocumentProtocols(&sv.Protocols, value); err != nil { 2902 return err 2903 } 2904 2905 case "SecurityPolicyName": 2906 if value != nil { 2907 jtv, ok := value.(string) 2908 if !ok { 2909 return fmt.Errorf("expected SecurityPolicyName to be of type string, got %T instead", value) 2910 } 2911 sv.SecurityPolicyName = ptr.String(jtv) 2912 } 2913 2914 case "ServerId": 2915 if value != nil { 2916 jtv, ok := value.(string) 2917 if !ok { 2918 return fmt.Errorf("expected ServerId to be of type string, got %T instead", value) 2919 } 2920 sv.ServerId = ptr.String(jtv) 2921 } 2922 2923 case "State": 2924 if value != nil { 2925 jtv, ok := value.(string) 2926 if !ok { 2927 return fmt.Errorf("expected State to be of type string, got %T instead", value) 2928 } 2929 sv.State = types.State(jtv) 2930 } 2931 2932 case "Tags": 2933 if err := awsAwsjson11_deserializeDocumentTags(&sv.Tags, value); err != nil { 2934 return err 2935 } 2936 2937 case "UserCount": 2938 if value != nil { 2939 jtv, ok := value.(json.Number) 2940 if !ok { 2941 return fmt.Errorf("expected UserCount to be json.Number, got %T instead", value) 2942 } 2943 i64, err := jtv.Int64() 2944 if err != nil { 2945 return err 2946 } 2947 sv.UserCount = ptr.Int32(int32(i64)) 2948 } 2949 2950 default: 2951 _, _ = key, value 2952 2953 } 2954 } 2955 *v = sv 2956 return nil 2957} 2958 2959func awsAwsjson11_deserializeDocumentDescribedUser(v **types.DescribedUser, value interface{}) error { 2960 if v == nil { 2961 return fmt.Errorf("unexpected nil of type %T", v) 2962 } 2963 if value == nil { 2964 return nil 2965 } 2966 2967 shape, ok := value.(map[string]interface{}) 2968 if !ok { 2969 return fmt.Errorf("unexpected JSON type %v", value) 2970 } 2971 2972 var sv *types.DescribedUser 2973 if *v == nil { 2974 sv = &types.DescribedUser{} 2975 } else { 2976 sv = *v 2977 } 2978 2979 for key, value := range shape { 2980 switch key { 2981 case "Arn": 2982 if value != nil { 2983 jtv, ok := value.(string) 2984 if !ok { 2985 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 2986 } 2987 sv.Arn = ptr.String(jtv) 2988 } 2989 2990 case "HomeDirectory": 2991 if value != nil { 2992 jtv, ok := value.(string) 2993 if !ok { 2994 return fmt.Errorf("expected HomeDirectory to be of type string, got %T instead", value) 2995 } 2996 sv.HomeDirectory = ptr.String(jtv) 2997 } 2998 2999 case "HomeDirectoryMappings": 3000 if err := awsAwsjson11_deserializeDocumentHomeDirectoryMappings(&sv.HomeDirectoryMappings, value); err != nil { 3001 return err 3002 } 3003 3004 case "HomeDirectoryType": 3005 if value != nil { 3006 jtv, ok := value.(string) 3007 if !ok { 3008 return fmt.Errorf("expected HomeDirectoryType to be of type string, got %T instead", value) 3009 } 3010 sv.HomeDirectoryType = types.HomeDirectoryType(jtv) 3011 } 3012 3013 case "Policy": 3014 if value != nil { 3015 jtv, ok := value.(string) 3016 if !ok { 3017 return fmt.Errorf("expected Policy to be of type string, got %T instead", value) 3018 } 3019 sv.Policy = ptr.String(jtv) 3020 } 3021 3022 case "Role": 3023 if value != nil { 3024 jtv, ok := value.(string) 3025 if !ok { 3026 return fmt.Errorf("expected Role to be of type string, got %T instead", value) 3027 } 3028 sv.Role = ptr.String(jtv) 3029 } 3030 3031 case "SshPublicKeys": 3032 if err := awsAwsjson11_deserializeDocumentSshPublicKeys(&sv.SshPublicKeys, value); err != nil { 3033 return err 3034 } 3035 3036 case "Tags": 3037 if err := awsAwsjson11_deserializeDocumentTags(&sv.Tags, value); err != nil { 3038 return err 3039 } 3040 3041 case "UserName": 3042 if value != nil { 3043 jtv, ok := value.(string) 3044 if !ok { 3045 return fmt.Errorf("expected UserName to be of type string, got %T instead", value) 3046 } 3047 sv.UserName = ptr.String(jtv) 3048 } 3049 3050 default: 3051 _, _ = key, value 3052 3053 } 3054 } 3055 *v = sv 3056 return nil 3057} 3058 3059func awsAwsjson11_deserializeDocumentEndpointDetails(v **types.EndpointDetails, value interface{}) error { 3060 if v == nil { 3061 return fmt.Errorf("unexpected nil of type %T", v) 3062 } 3063 if value == nil { 3064 return nil 3065 } 3066 3067 shape, ok := value.(map[string]interface{}) 3068 if !ok { 3069 return fmt.Errorf("unexpected JSON type %v", value) 3070 } 3071 3072 var sv *types.EndpointDetails 3073 if *v == nil { 3074 sv = &types.EndpointDetails{} 3075 } else { 3076 sv = *v 3077 } 3078 3079 for key, value := range shape { 3080 switch key { 3081 case "AddressAllocationIds": 3082 if err := awsAwsjson11_deserializeDocumentAddressAllocationIds(&sv.AddressAllocationIds, value); err != nil { 3083 return err 3084 } 3085 3086 case "SecurityGroupIds": 3087 if err := awsAwsjson11_deserializeDocumentSecurityGroupIds(&sv.SecurityGroupIds, value); err != nil { 3088 return err 3089 } 3090 3091 case "SubnetIds": 3092 if err := awsAwsjson11_deserializeDocumentSubnetIds(&sv.SubnetIds, value); err != nil { 3093 return err 3094 } 3095 3096 case "VpcEndpointId": 3097 if value != nil { 3098 jtv, ok := value.(string) 3099 if !ok { 3100 return fmt.Errorf("expected VpcEndpointId to be of type string, got %T instead", value) 3101 } 3102 sv.VpcEndpointId = ptr.String(jtv) 3103 } 3104 3105 case "VpcId": 3106 if value != nil { 3107 jtv, ok := value.(string) 3108 if !ok { 3109 return fmt.Errorf("expected VpcId to be of type string, got %T instead", value) 3110 } 3111 sv.VpcId = ptr.String(jtv) 3112 } 3113 3114 default: 3115 _, _ = key, value 3116 3117 } 3118 } 3119 *v = sv 3120 return nil 3121} 3122 3123func awsAwsjson11_deserializeDocumentHomeDirectoryMapEntry(v **types.HomeDirectoryMapEntry, value interface{}) error { 3124 if v == nil { 3125 return fmt.Errorf("unexpected nil of type %T", v) 3126 } 3127 if value == nil { 3128 return nil 3129 } 3130 3131 shape, ok := value.(map[string]interface{}) 3132 if !ok { 3133 return fmt.Errorf("unexpected JSON type %v", value) 3134 } 3135 3136 var sv *types.HomeDirectoryMapEntry 3137 if *v == nil { 3138 sv = &types.HomeDirectoryMapEntry{} 3139 } else { 3140 sv = *v 3141 } 3142 3143 for key, value := range shape { 3144 switch key { 3145 case "Entry": 3146 if value != nil { 3147 jtv, ok := value.(string) 3148 if !ok { 3149 return fmt.Errorf("expected MapEntry to be of type string, got %T instead", value) 3150 } 3151 sv.Entry = ptr.String(jtv) 3152 } 3153 3154 case "Target": 3155 if value != nil { 3156 jtv, ok := value.(string) 3157 if !ok { 3158 return fmt.Errorf("expected MapTarget to be of type string, got %T instead", value) 3159 } 3160 sv.Target = ptr.String(jtv) 3161 } 3162 3163 default: 3164 _, _ = key, value 3165 3166 } 3167 } 3168 *v = sv 3169 return nil 3170} 3171 3172func awsAwsjson11_deserializeDocumentHomeDirectoryMappings(v *[]types.HomeDirectoryMapEntry, value interface{}) error { 3173 if v == nil { 3174 return fmt.Errorf("unexpected nil of type %T", v) 3175 } 3176 if value == nil { 3177 return nil 3178 } 3179 3180 shape, ok := value.([]interface{}) 3181 if !ok { 3182 return fmt.Errorf("unexpected JSON type %v", value) 3183 } 3184 3185 var cv []types.HomeDirectoryMapEntry 3186 if *v == nil { 3187 cv = []types.HomeDirectoryMapEntry{} 3188 } else { 3189 cv = *v 3190 } 3191 3192 for _, value := range shape { 3193 var col types.HomeDirectoryMapEntry 3194 destAddr := &col 3195 if err := awsAwsjson11_deserializeDocumentHomeDirectoryMapEntry(&destAddr, value); err != nil { 3196 return err 3197 } 3198 col = *destAddr 3199 cv = append(cv, col) 3200 3201 } 3202 *v = cv 3203 return nil 3204} 3205 3206func awsAwsjson11_deserializeDocumentIdentityProviderDetails(v **types.IdentityProviderDetails, value interface{}) error { 3207 if v == nil { 3208 return fmt.Errorf("unexpected nil of type %T", v) 3209 } 3210 if value == nil { 3211 return nil 3212 } 3213 3214 shape, ok := value.(map[string]interface{}) 3215 if !ok { 3216 return fmt.Errorf("unexpected JSON type %v", value) 3217 } 3218 3219 var sv *types.IdentityProviderDetails 3220 if *v == nil { 3221 sv = &types.IdentityProviderDetails{} 3222 } else { 3223 sv = *v 3224 } 3225 3226 for key, value := range shape { 3227 switch key { 3228 case "InvocationRole": 3229 if value != nil { 3230 jtv, ok := value.(string) 3231 if !ok { 3232 return fmt.Errorf("expected Role to be of type string, got %T instead", value) 3233 } 3234 sv.InvocationRole = ptr.String(jtv) 3235 } 3236 3237 case "Url": 3238 if value != nil { 3239 jtv, ok := value.(string) 3240 if !ok { 3241 return fmt.Errorf("expected Url to be of type string, got %T instead", value) 3242 } 3243 sv.Url = ptr.String(jtv) 3244 } 3245 3246 default: 3247 _, _ = key, value 3248 3249 } 3250 } 3251 *v = sv 3252 return nil 3253} 3254 3255func awsAwsjson11_deserializeDocumentInternalServiceError(v **types.InternalServiceError, value interface{}) error { 3256 if v == nil { 3257 return fmt.Errorf("unexpected nil of type %T", v) 3258 } 3259 if value == nil { 3260 return nil 3261 } 3262 3263 shape, ok := value.(map[string]interface{}) 3264 if !ok { 3265 return fmt.Errorf("unexpected JSON type %v", value) 3266 } 3267 3268 var sv *types.InternalServiceError 3269 if *v == nil { 3270 sv = &types.InternalServiceError{} 3271 } else { 3272 sv = *v 3273 } 3274 3275 for key, value := range shape { 3276 switch key { 3277 case "Message": 3278 if value != nil { 3279 jtv, ok := value.(string) 3280 if !ok { 3281 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 3282 } 3283 sv.Message = ptr.String(jtv) 3284 } 3285 3286 default: 3287 _, _ = key, value 3288 3289 } 3290 } 3291 *v = sv 3292 return nil 3293} 3294 3295func awsAwsjson11_deserializeDocumentInvalidNextTokenException(v **types.InvalidNextTokenException, value interface{}) error { 3296 if v == nil { 3297 return fmt.Errorf("unexpected nil of type %T", v) 3298 } 3299 if value == nil { 3300 return nil 3301 } 3302 3303 shape, ok := value.(map[string]interface{}) 3304 if !ok { 3305 return fmt.Errorf("unexpected JSON type %v", value) 3306 } 3307 3308 var sv *types.InvalidNextTokenException 3309 if *v == nil { 3310 sv = &types.InvalidNextTokenException{} 3311 } else { 3312 sv = *v 3313 } 3314 3315 for key, value := range shape { 3316 switch key { 3317 case "Message": 3318 if value != nil { 3319 jtv, ok := value.(string) 3320 if !ok { 3321 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 3322 } 3323 sv.Message = ptr.String(jtv) 3324 } 3325 3326 default: 3327 _, _ = key, value 3328 3329 } 3330 } 3331 *v = sv 3332 return nil 3333} 3334 3335func awsAwsjson11_deserializeDocumentInvalidRequestException(v **types.InvalidRequestException, value interface{}) error { 3336 if v == nil { 3337 return fmt.Errorf("unexpected nil of type %T", v) 3338 } 3339 if value == nil { 3340 return nil 3341 } 3342 3343 shape, ok := value.(map[string]interface{}) 3344 if !ok { 3345 return fmt.Errorf("unexpected JSON type %v", value) 3346 } 3347 3348 var sv *types.InvalidRequestException 3349 if *v == nil { 3350 sv = &types.InvalidRequestException{} 3351 } else { 3352 sv = *v 3353 } 3354 3355 for key, value := range shape { 3356 switch key { 3357 case "Message": 3358 if value != nil { 3359 jtv, ok := value.(string) 3360 if !ok { 3361 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 3362 } 3363 sv.Message = ptr.String(jtv) 3364 } 3365 3366 default: 3367 _, _ = key, value 3368 3369 } 3370 } 3371 *v = sv 3372 return nil 3373} 3374 3375func awsAwsjson11_deserializeDocumentListedServer(v **types.ListedServer, value interface{}) error { 3376 if v == nil { 3377 return fmt.Errorf("unexpected nil of type %T", v) 3378 } 3379 if value == nil { 3380 return nil 3381 } 3382 3383 shape, ok := value.(map[string]interface{}) 3384 if !ok { 3385 return fmt.Errorf("unexpected JSON type %v", value) 3386 } 3387 3388 var sv *types.ListedServer 3389 if *v == nil { 3390 sv = &types.ListedServer{} 3391 } else { 3392 sv = *v 3393 } 3394 3395 for key, value := range shape { 3396 switch key { 3397 case "Arn": 3398 if value != nil { 3399 jtv, ok := value.(string) 3400 if !ok { 3401 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 3402 } 3403 sv.Arn = ptr.String(jtv) 3404 } 3405 3406 case "EndpointType": 3407 if value != nil { 3408 jtv, ok := value.(string) 3409 if !ok { 3410 return fmt.Errorf("expected EndpointType to be of type string, got %T instead", value) 3411 } 3412 sv.EndpointType = types.EndpointType(jtv) 3413 } 3414 3415 case "IdentityProviderType": 3416 if value != nil { 3417 jtv, ok := value.(string) 3418 if !ok { 3419 return fmt.Errorf("expected IdentityProviderType to be of type string, got %T instead", value) 3420 } 3421 sv.IdentityProviderType = types.IdentityProviderType(jtv) 3422 } 3423 3424 case "LoggingRole": 3425 if value != nil { 3426 jtv, ok := value.(string) 3427 if !ok { 3428 return fmt.Errorf("expected Role to be of type string, got %T instead", value) 3429 } 3430 sv.LoggingRole = ptr.String(jtv) 3431 } 3432 3433 case "ServerId": 3434 if value != nil { 3435 jtv, ok := value.(string) 3436 if !ok { 3437 return fmt.Errorf("expected ServerId to be of type string, got %T instead", value) 3438 } 3439 sv.ServerId = ptr.String(jtv) 3440 } 3441 3442 case "State": 3443 if value != nil { 3444 jtv, ok := value.(string) 3445 if !ok { 3446 return fmt.Errorf("expected State to be of type string, got %T instead", value) 3447 } 3448 sv.State = types.State(jtv) 3449 } 3450 3451 case "UserCount": 3452 if value != nil { 3453 jtv, ok := value.(json.Number) 3454 if !ok { 3455 return fmt.Errorf("expected UserCount to be json.Number, got %T instead", value) 3456 } 3457 i64, err := jtv.Int64() 3458 if err != nil { 3459 return err 3460 } 3461 sv.UserCount = ptr.Int32(int32(i64)) 3462 } 3463 3464 default: 3465 _, _ = key, value 3466 3467 } 3468 } 3469 *v = sv 3470 return nil 3471} 3472 3473func awsAwsjson11_deserializeDocumentListedServers(v *[]types.ListedServer, value interface{}) error { 3474 if v == nil { 3475 return fmt.Errorf("unexpected nil of type %T", v) 3476 } 3477 if value == nil { 3478 return nil 3479 } 3480 3481 shape, ok := value.([]interface{}) 3482 if !ok { 3483 return fmt.Errorf("unexpected JSON type %v", value) 3484 } 3485 3486 var cv []types.ListedServer 3487 if *v == nil { 3488 cv = []types.ListedServer{} 3489 } else { 3490 cv = *v 3491 } 3492 3493 for _, value := range shape { 3494 var col types.ListedServer 3495 destAddr := &col 3496 if err := awsAwsjson11_deserializeDocumentListedServer(&destAddr, value); err != nil { 3497 return err 3498 } 3499 col = *destAddr 3500 cv = append(cv, col) 3501 3502 } 3503 *v = cv 3504 return nil 3505} 3506 3507func awsAwsjson11_deserializeDocumentListedUser(v **types.ListedUser, value interface{}) error { 3508 if v == nil { 3509 return fmt.Errorf("unexpected nil of type %T", v) 3510 } 3511 if value == nil { 3512 return nil 3513 } 3514 3515 shape, ok := value.(map[string]interface{}) 3516 if !ok { 3517 return fmt.Errorf("unexpected JSON type %v", value) 3518 } 3519 3520 var sv *types.ListedUser 3521 if *v == nil { 3522 sv = &types.ListedUser{} 3523 } else { 3524 sv = *v 3525 } 3526 3527 for key, value := range shape { 3528 switch key { 3529 case "Arn": 3530 if value != nil { 3531 jtv, ok := value.(string) 3532 if !ok { 3533 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 3534 } 3535 sv.Arn = ptr.String(jtv) 3536 } 3537 3538 case "HomeDirectory": 3539 if value != nil { 3540 jtv, ok := value.(string) 3541 if !ok { 3542 return fmt.Errorf("expected HomeDirectory to be of type string, got %T instead", value) 3543 } 3544 sv.HomeDirectory = ptr.String(jtv) 3545 } 3546 3547 case "HomeDirectoryType": 3548 if value != nil { 3549 jtv, ok := value.(string) 3550 if !ok { 3551 return fmt.Errorf("expected HomeDirectoryType to be of type string, got %T instead", value) 3552 } 3553 sv.HomeDirectoryType = types.HomeDirectoryType(jtv) 3554 } 3555 3556 case "Role": 3557 if value != nil { 3558 jtv, ok := value.(string) 3559 if !ok { 3560 return fmt.Errorf("expected Role to be of type string, got %T instead", value) 3561 } 3562 sv.Role = ptr.String(jtv) 3563 } 3564 3565 case "SshPublicKeyCount": 3566 if value != nil { 3567 jtv, ok := value.(json.Number) 3568 if !ok { 3569 return fmt.Errorf("expected SshPublicKeyCount to be json.Number, got %T instead", value) 3570 } 3571 i64, err := jtv.Int64() 3572 if err != nil { 3573 return err 3574 } 3575 sv.SshPublicKeyCount = ptr.Int32(int32(i64)) 3576 } 3577 3578 case "UserName": 3579 if value != nil { 3580 jtv, ok := value.(string) 3581 if !ok { 3582 return fmt.Errorf("expected UserName to be of type string, got %T instead", value) 3583 } 3584 sv.UserName = ptr.String(jtv) 3585 } 3586 3587 default: 3588 _, _ = key, value 3589 3590 } 3591 } 3592 *v = sv 3593 return nil 3594} 3595 3596func awsAwsjson11_deserializeDocumentListedUsers(v *[]types.ListedUser, value interface{}) error { 3597 if v == nil { 3598 return fmt.Errorf("unexpected nil of type %T", v) 3599 } 3600 if value == nil { 3601 return nil 3602 } 3603 3604 shape, ok := value.([]interface{}) 3605 if !ok { 3606 return fmt.Errorf("unexpected JSON type %v", value) 3607 } 3608 3609 var cv []types.ListedUser 3610 if *v == nil { 3611 cv = []types.ListedUser{} 3612 } else { 3613 cv = *v 3614 } 3615 3616 for _, value := range shape { 3617 var col types.ListedUser 3618 destAddr := &col 3619 if err := awsAwsjson11_deserializeDocumentListedUser(&destAddr, value); err != nil { 3620 return err 3621 } 3622 col = *destAddr 3623 cv = append(cv, col) 3624 3625 } 3626 *v = cv 3627 return nil 3628} 3629 3630func awsAwsjson11_deserializeDocumentProtocols(v *[]types.Protocol, value interface{}) error { 3631 if v == nil { 3632 return fmt.Errorf("unexpected nil of type %T", v) 3633 } 3634 if value == nil { 3635 return nil 3636 } 3637 3638 shape, ok := value.([]interface{}) 3639 if !ok { 3640 return fmt.Errorf("unexpected JSON type %v", value) 3641 } 3642 3643 var cv []types.Protocol 3644 if *v == nil { 3645 cv = []types.Protocol{} 3646 } else { 3647 cv = *v 3648 } 3649 3650 for _, value := range shape { 3651 var col types.Protocol 3652 if value != nil { 3653 jtv, ok := value.(string) 3654 if !ok { 3655 return fmt.Errorf("expected Protocol to be of type string, got %T instead", value) 3656 } 3657 col = types.Protocol(jtv) 3658 } 3659 cv = append(cv, col) 3660 3661 } 3662 *v = cv 3663 return nil 3664} 3665 3666func awsAwsjson11_deserializeDocumentResourceExistsException(v **types.ResourceExistsException, value interface{}) error { 3667 if v == nil { 3668 return fmt.Errorf("unexpected nil of type %T", v) 3669 } 3670 if value == nil { 3671 return nil 3672 } 3673 3674 shape, ok := value.(map[string]interface{}) 3675 if !ok { 3676 return fmt.Errorf("unexpected JSON type %v", value) 3677 } 3678 3679 var sv *types.ResourceExistsException 3680 if *v == nil { 3681 sv = &types.ResourceExistsException{} 3682 } else { 3683 sv = *v 3684 } 3685 3686 for key, value := range shape { 3687 switch key { 3688 case "Message": 3689 if value != nil { 3690 jtv, ok := value.(string) 3691 if !ok { 3692 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 3693 } 3694 sv.Message = ptr.String(jtv) 3695 } 3696 3697 case "Resource": 3698 if value != nil { 3699 jtv, ok := value.(string) 3700 if !ok { 3701 return fmt.Errorf("expected Resource to be of type string, got %T instead", value) 3702 } 3703 sv.Resource = ptr.String(jtv) 3704 } 3705 3706 case "ResourceType": 3707 if value != nil { 3708 jtv, ok := value.(string) 3709 if !ok { 3710 return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value) 3711 } 3712 sv.ResourceType = ptr.String(jtv) 3713 } 3714 3715 default: 3716 _, _ = key, value 3717 3718 } 3719 } 3720 *v = sv 3721 return nil 3722} 3723 3724func awsAwsjson11_deserializeDocumentResourceNotFoundException(v **types.ResourceNotFoundException, value interface{}) error { 3725 if v == nil { 3726 return fmt.Errorf("unexpected nil of type %T", v) 3727 } 3728 if value == nil { 3729 return nil 3730 } 3731 3732 shape, ok := value.(map[string]interface{}) 3733 if !ok { 3734 return fmt.Errorf("unexpected JSON type %v", value) 3735 } 3736 3737 var sv *types.ResourceNotFoundException 3738 if *v == nil { 3739 sv = &types.ResourceNotFoundException{} 3740 } else { 3741 sv = *v 3742 } 3743 3744 for key, value := range shape { 3745 switch key { 3746 case "Message": 3747 if value != nil { 3748 jtv, ok := value.(string) 3749 if !ok { 3750 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 3751 } 3752 sv.Message = ptr.String(jtv) 3753 } 3754 3755 case "Resource": 3756 if value != nil { 3757 jtv, ok := value.(string) 3758 if !ok { 3759 return fmt.Errorf("expected Resource to be of type string, got %T instead", value) 3760 } 3761 sv.Resource = ptr.String(jtv) 3762 } 3763 3764 case "ResourceType": 3765 if value != nil { 3766 jtv, ok := value.(string) 3767 if !ok { 3768 return fmt.Errorf("expected ResourceType to be of type string, got %T instead", value) 3769 } 3770 sv.ResourceType = ptr.String(jtv) 3771 } 3772 3773 default: 3774 _, _ = key, value 3775 3776 } 3777 } 3778 *v = sv 3779 return nil 3780} 3781 3782func awsAwsjson11_deserializeDocumentSecurityGroupIds(v *[]string, value interface{}) error { 3783 if v == nil { 3784 return fmt.Errorf("unexpected nil of type %T", v) 3785 } 3786 if value == nil { 3787 return nil 3788 } 3789 3790 shape, ok := value.([]interface{}) 3791 if !ok { 3792 return fmt.Errorf("unexpected JSON type %v", value) 3793 } 3794 3795 var cv []string 3796 if *v == nil { 3797 cv = []string{} 3798 } else { 3799 cv = *v 3800 } 3801 3802 for _, value := range shape { 3803 var col string 3804 if value != nil { 3805 jtv, ok := value.(string) 3806 if !ok { 3807 return fmt.Errorf("expected SecurityGroupId to be of type string, got %T instead", value) 3808 } 3809 col = jtv 3810 } 3811 cv = append(cv, col) 3812 3813 } 3814 *v = cv 3815 return nil 3816} 3817 3818func awsAwsjson11_deserializeDocumentSecurityPolicyNames(v *[]string, value interface{}) error { 3819 if v == nil { 3820 return fmt.Errorf("unexpected nil of type %T", v) 3821 } 3822 if value == nil { 3823 return nil 3824 } 3825 3826 shape, ok := value.([]interface{}) 3827 if !ok { 3828 return fmt.Errorf("unexpected JSON type %v", value) 3829 } 3830 3831 var cv []string 3832 if *v == nil { 3833 cv = []string{} 3834 } else { 3835 cv = *v 3836 } 3837 3838 for _, value := range shape { 3839 var col string 3840 if value != nil { 3841 jtv, ok := value.(string) 3842 if !ok { 3843 return fmt.Errorf("expected SecurityPolicyName to be of type string, got %T instead", value) 3844 } 3845 col = jtv 3846 } 3847 cv = append(cv, col) 3848 3849 } 3850 *v = cv 3851 return nil 3852} 3853 3854func awsAwsjson11_deserializeDocumentSecurityPolicyOptions(v *[]string, value interface{}) error { 3855 if v == nil { 3856 return fmt.Errorf("unexpected nil of type %T", v) 3857 } 3858 if value == nil { 3859 return nil 3860 } 3861 3862 shape, ok := value.([]interface{}) 3863 if !ok { 3864 return fmt.Errorf("unexpected JSON type %v", value) 3865 } 3866 3867 var cv []string 3868 if *v == nil { 3869 cv = []string{} 3870 } else { 3871 cv = *v 3872 } 3873 3874 for _, value := range shape { 3875 var col string 3876 if value != nil { 3877 jtv, ok := value.(string) 3878 if !ok { 3879 return fmt.Errorf("expected SecurityPolicyOption to be of type string, got %T instead", value) 3880 } 3881 col = jtv 3882 } 3883 cv = append(cv, col) 3884 3885 } 3886 *v = cv 3887 return nil 3888} 3889 3890func awsAwsjson11_deserializeDocumentServiceUnavailableException(v **types.ServiceUnavailableException, value interface{}) error { 3891 if v == nil { 3892 return fmt.Errorf("unexpected nil of type %T", v) 3893 } 3894 if value == nil { 3895 return nil 3896 } 3897 3898 shape, ok := value.(map[string]interface{}) 3899 if !ok { 3900 return fmt.Errorf("unexpected JSON type %v", value) 3901 } 3902 3903 var sv *types.ServiceUnavailableException 3904 if *v == nil { 3905 sv = &types.ServiceUnavailableException{} 3906 } else { 3907 sv = *v 3908 } 3909 3910 for key, value := range shape { 3911 switch key { 3912 case "Message": 3913 if value != nil { 3914 jtv, ok := value.(string) 3915 if !ok { 3916 return fmt.Errorf("expected ServiceErrorMessage to be of type string, got %T instead", value) 3917 } 3918 sv.Message = ptr.String(jtv) 3919 } 3920 3921 default: 3922 _, _ = key, value 3923 3924 } 3925 } 3926 *v = sv 3927 return nil 3928} 3929 3930func awsAwsjson11_deserializeDocumentSshPublicKey(v **types.SshPublicKey, value interface{}) error { 3931 if v == nil { 3932 return fmt.Errorf("unexpected nil of type %T", v) 3933 } 3934 if value == nil { 3935 return nil 3936 } 3937 3938 shape, ok := value.(map[string]interface{}) 3939 if !ok { 3940 return fmt.Errorf("unexpected JSON type %v", value) 3941 } 3942 3943 var sv *types.SshPublicKey 3944 if *v == nil { 3945 sv = &types.SshPublicKey{} 3946 } else { 3947 sv = *v 3948 } 3949 3950 for key, value := range shape { 3951 switch key { 3952 case "DateImported": 3953 if value != nil { 3954 jtv, ok := value.(json.Number) 3955 if !ok { 3956 return fmt.Errorf("expected DateImported to be json.Number, got %T instead", value) 3957 } 3958 f64, err := jtv.Float64() 3959 if err != nil { 3960 return err 3961 } 3962 sv.DateImported = ptr.Time(smithytime.ParseEpochSeconds(f64)) 3963 } 3964 3965 case "SshPublicKeyBody": 3966 if value != nil { 3967 jtv, ok := value.(string) 3968 if !ok { 3969 return fmt.Errorf("expected SshPublicKeyBody to be of type string, got %T instead", value) 3970 } 3971 sv.SshPublicKeyBody = ptr.String(jtv) 3972 } 3973 3974 case "SshPublicKeyId": 3975 if value != nil { 3976 jtv, ok := value.(string) 3977 if !ok { 3978 return fmt.Errorf("expected SshPublicKeyId to be of type string, got %T instead", value) 3979 } 3980 sv.SshPublicKeyId = ptr.String(jtv) 3981 } 3982 3983 default: 3984 _, _ = key, value 3985 3986 } 3987 } 3988 *v = sv 3989 return nil 3990} 3991 3992func awsAwsjson11_deserializeDocumentSshPublicKeys(v *[]types.SshPublicKey, value interface{}) error { 3993 if v == nil { 3994 return fmt.Errorf("unexpected nil of type %T", v) 3995 } 3996 if value == nil { 3997 return nil 3998 } 3999 4000 shape, ok := value.([]interface{}) 4001 if !ok { 4002 return fmt.Errorf("unexpected JSON type %v", value) 4003 } 4004 4005 var cv []types.SshPublicKey 4006 if *v == nil { 4007 cv = []types.SshPublicKey{} 4008 } else { 4009 cv = *v 4010 } 4011 4012 for _, value := range shape { 4013 var col types.SshPublicKey 4014 destAddr := &col 4015 if err := awsAwsjson11_deserializeDocumentSshPublicKey(&destAddr, value); err != nil { 4016 return err 4017 } 4018 col = *destAddr 4019 cv = append(cv, col) 4020 4021 } 4022 *v = cv 4023 return nil 4024} 4025 4026func awsAwsjson11_deserializeDocumentSubnetIds(v *[]string, value interface{}) error { 4027 if v == nil { 4028 return fmt.Errorf("unexpected nil of type %T", v) 4029 } 4030 if value == nil { 4031 return nil 4032 } 4033 4034 shape, ok := value.([]interface{}) 4035 if !ok { 4036 return fmt.Errorf("unexpected JSON type %v", value) 4037 } 4038 4039 var cv []string 4040 if *v == nil { 4041 cv = []string{} 4042 } else { 4043 cv = *v 4044 } 4045 4046 for _, value := range shape { 4047 var col string 4048 if value != nil { 4049 jtv, ok := value.(string) 4050 if !ok { 4051 return fmt.Errorf("expected SubnetId to be of type string, got %T instead", value) 4052 } 4053 col = jtv 4054 } 4055 cv = append(cv, col) 4056 4057 } 4058 *v = cv 4059 return nil 4060} 4061 4062func awsAwsjson11_deserializeDocumentTag(v **types.Tag, value interface{}) error { 4063 if v == nil { 4064 return fmt.Errorf("unexpected nil of type %T", v) 4065 } 4066 if value == nil { 4067 return nil 4068 } 4069 4070 shape, ok := value.(map[string]interface{}) 4071 if !ok { 4072 return fmt.Errorf("unexpected JSON type %v", value) 4073 } 4074 4075 var sv *types.Tag 4076 if *v == nil { 4077 sv = &types.Tag{} 4078 } else { 4079 sv = *v 4080 } 4081 4082 for key, value := range shape { 4083 switch key { 4084 case "Key": 4085 if value != nil { 4086 jtv, ok := value.(string) 4087 if !ok { 4088 return fmt.Errorf("expected TagKey to be of type string, got %T instead", value) 4089 } 4090 sv.Key = ptr.String(jtv) 4091 } 4092 4093 case "Value": 4094 if value != nil { 4095 jtv, ok := value.(string) 4096 if !ok { 4097 return fmt.Errorf("expected TagValue to be of type string, got %T instead", value) 4098 } 4099 sv.Value = ptr.String(jtv) 4100 } 4101 4102 default: 4103 _, _ = key, value 4104 4105 } 4106 } 4107 *v = sv 4108 return nil 4109} 4110 4111func awsAwsjson11_deserializeDocumentTags(v *[]types.Tag, value interface{}) error { 4112 if v == nil { 4113 return fmt.Errorf("unexpected nil of type %T", v) 4114 } 4115 if value == nil { 4116 return nil 4117 } 4118 4119 shape, ok := value.([]interface{}) 4120 if !ok { 4121 return fmt.Errorf("unexpected JSON type %v", value) 4122 } 4123 4124 var cv []types.Tag 4125 if *v == nil { 4126 cv = []types.Tag{} 4127 } else { 4128 cv = *v 4129 } 4130 4131 for _, value := range shape { 4132 var col types.Tag 4133 destAddr := &col 4134 if err := awsAwsjson11_deserializeDocumentTag(&destAddr, value); err != nil { 4135 return err 4136 } 4137 col = *destAddr 4138 cv = append(cv, col) 4139 4140 } 4141 *v = cv 4142 return nil 4143} 4144 4145func awsAwsjson11_deserializeDocumentThrottlingException(v **types.ThrottlingException, value interface{}) error { 4146 if v == nil { 4147 return fmt.Errorf("unexpected nil of type %T", v) 4148 } 4149 if value == nil { 4150 return nil 4151 } 4152 4153 shape, ok := value.(map[string]interface{}) 4154 if !ok { 4155 return fmt.Errorf("unexpected JSON type %v", value) 4156 } 4157 4158 var sv *types.ThrottlingException 4159 if *v == nil { 4160 sv = &types.ThrottlingException{} 4161 } else { 4162 sv = *v 4163 } 4164 4165 for key, value := range shape { 4166 switch key { 4167 case "RetryAfterSeconds": 4168 if value != nil { 4169 jtv, ok := value.(string) 4170 if !ok { 4171 return fmt.Errorf("expected RetryAfterSeconds to be of type string, got %T instead", value) 4172 } 4173 sv.RetryAfterSeconds = ptr.String(jtv) 4174 } 4175 4176 default: 4177 _, _ = key, value 4178 4179 } 4180 } 4181 *v = sv 4182 return nil 4183} 4184 4185func awsAwsjson11_deserializeOpDocumentCreateServerOutput(v **CreateServerOutput, value interface{}) error { 4186 if v == nil { 4187 return fmt.Errorf("unexpected nil of type %T", v) 4188 } 4189 if value == nil { 4190 return nil 4191 } 4192 4193 shape, ok := value.(map[string]interface{}) 4194 if !ok { 4195 return fmt.Errorf("unexpected JSON type %v", value) 4196 } 4197 4198 var sv *CreateServerOutput 4199 if *v == nil { 4200 sv = &CreateServerOutput{} 4201 } else { 4202 sv = *v 4203 } 4204 4205 for key, value := range shape { 4206 switch key { 4207 case "ServerId": 4208 if value != nil { 4209 jtv, ok := value.(string) 4210 if !ok { 4211 return fmt.Errorf("expected ServerId to be of type string, got %T instead", value) 4212 } 4213 sv.ServerId = ptr.String(jtv) 4214 } 4215 4216 default: 4217 _, _ = key, value 4218 4219 } 4220 } 4221 *v = sv 4222 return nil 4223} 4224 4225func awsAwsjson11_deserializeOpDocumentCreateUserOutput(v **CreateUserOutput, value interface{}) error { 4226 if v == nil { 4227 return fmt.Errorf("unexpected nil of type %T", v) 4228 } 4229 if value == nil { 4230 return nil 4231 } 4232 4233 shape, ok := value.(map[string]interface{}) 4234 if !ok { 4235 return fmt.Errorf("unexpected JSON type %v", value) 4236 } 4237 4238 var sv *CreateUserOutput 4239 if *v == nil { 4240 sv = &CreateUserOutput{} 4241 } else { 4242 sv = *v 4243 } 4244 4245 for key, value := range shape { 4246 switch key { 4247 case "ServerId": 4248 if value != nil { 4249 jtv, ok := value.(string) 4250 if !ok { 4251 return fmt.Errorf("expected ServerId to be of type string, got %T instead", value) 4252 } 4253 sv.ServerId = ptr.String(jtv) 4254 } 4255 4256 case "UserName": 4257 if value != nil { 4258 jtv, ok := value.(string) 4259 if !ok { 4260 return fmt.Errorf("expected UserName to be of type string, got %T instead", value) 4261 } 4262 sv.UserName = ptr.String(jtv) 4263 } 4264 4265 default: 4266 _, _ = key, value 4267 4268 } 4269 } 4270 *v = sv 4271 return nil 4272} 4273 4274func awsAwsjson11_deserializeOpDocumentDescribeSecurityPolicyOutput(v **DescribeSecurityPolicyOutput, value interface{}) error { 4275 if v == nil { 4276 return fmt.Errorf("unexpected nil of type %T", v) 4277 } 4278 if value == nil { 4279 return nil 4280 } 4281 4282 shape, ok := value.(map[string]interface{}) 4283 if !ok { 4284 return fmt.Errorf("unexpected JSON type %v", value) 4285 } 4286 4287 var sv *DescribeSecurityPolicyOutput 4288 if *v == nil { 4289 sv = &DescribeSecurityPolicyOutput{} 4290 } else { 4291 sv = *v 4292 } 4293 4294 for key, value := range shape { 4295 switch key { 4296 case "SecurityPolicy": 4297 if err := awsAwsjson11_deserializeDocumentDescribedSecurityPolicy(&sv.SecurityPolicy, value); err != nil { 4298 return err 4299 } 4300 4301 default: 4302 _, _ = key, value 4303 4304 } 4305 } 4306 *v = sv 4307 return nil 4308} 4309 4310func awsAwsjson11_deserializeOpDocumentDescribeServerOutput(v **DescribeServerOutput, 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 *DescribeServerOutput 4324 if *v == nil { 4325 sv = &DescribeServerOutput{} 4326 } else { 4327 sv = *v 4328 } 4329 4330 for key, value := range shape { 4331 switch key { 4332 case "Server": 4333 if err := awsAwsjson11_deserializeDocumentDescribedServer(&sv.Server, value); err != nil { 4334 return err 4335 } 4336 4337 default: 4338 _, _ = key, value 4339 4340 } 4341 } 4342 *v = sv 4343 return nil 4344} 4345 4346func awsAwsjson11_deserializeOpDocumentDescribeUserOutput(v **DescribeUserOutput, value interface{}) error { 4347 if v == nil { 4348 return fmt.Errorf("unexpected nil of type %T", v) 4349 } 4350 if value == nil { 4351 return nil 4352 } 4353 4354 shape, ok := value.(map[string]interface{}) 4355 if !ok { 4356 return fmt.Errorf("unexpected JSON type %v", value) 4357 } 4358 4359 var sv *DescribeUserOutput 4360 if *v == nil { 4361 sv = &DescribeUserOutput{} 4362 } else { 4363 sv = *v 4364 } 4365 4366 for key, value := range shape { 4367 switch key { 4368 case "ServerId": 4369 if value != nil { 4370 jtv, ok := value.(string) 4371 if !ok { 4372 return fmt.Errorf("expected ServerId to be of type string, got %T instead", value) 4373 } 4374 sv.ServerId = ptr.String(jtv) 4375 } 4376 4377 case "User": 4378 if err := awsAwsjson11_deserializeDocumentDescribedUser(&sv.User, value); err != nil { 4379 return err 4380 } 4381 4382 default: 4383 _, _ = key, value 4384 4385 } 4386 } 4387 *v = sv 4388 return nil 4389} 4390 4391func awsAwsjson11_deserializeOpDocumentImportSshPublicKeyOutput(v **ImportSshPublicKeyOutput, value interface{}) error { 4392 if v == nil { 4393 return fmt.Errorf("unexpected nil of type %T", v) 4394 } 4395 if value == nil { 4396 return nil 4397 } 4398 4399 shape, ok := value.(map[string]interface{}) 4400 if !ok { 4401 return fmt.Errorf("unexpected JSON type %v", value) 4402 } 4403 4404 var sv *ImportSshPublicKeyOutput 4405 if *v == nil { 4406 sv = &ImportSshPublicKeyOutput{} 4407 } else { 4408 sv = *v 4409 } 4410 4411 for key, value := range shape { 4412 switch key { 4413 case "ServerId": 4414 if value != nil { 4415 jtv, ok := value.(string) 4416 if !ok { 4417 return fmt.Errorf("expected ServerId to be of type string, got %T instead", value) 4418 } 4419 sv.ServerId = ptr.String(jtv) 4420 } 4421 4422 case "SshPublicKeyId": 4423 if value != nil { 4424 jtv, ok := value.(string) 4425 if !ok { 4426 return fmt.Errorf("expected SshPublicKeyId to be of type string, got %T instead", value) 4427 } 4428 sv.SshPublicKeyId = ptr.String(jtv) 4429 } 4430 4431 case "UserName": 4432 if value != nil { 4433 jtv, ok := value.(string) 4434 if !ok { 4435 return fmt.Errorf("expected UserName to be of type string, got %T instead", value) 4436 } 4437 sv.UserName = ptr.String(jtv) 4438 } 4439 4440 default: 4441 _, _ = key, value 4442 4443 } 4444 } 4445 *v = sv 4446 return nil 4447} 4448 4449func awsAwsjson11_deserializeOpDocumentListSecurityPoliciesOutput(v **ListSecurityPoliciesOutput, value interface{}) error { 4450 if v == nil { 4451 return fmt.Errorf("unexpected nil of type %T", v) 4452 } 4453 if value == nil { 4454 return nil 4455 } 4456 4457 shape, ok := value.(map[string]interface{}) 4458 if !ok { 4459 return fmt.Errorf("unexpected JSON type %v", value) 4460 } 4461 4462 var sv *ListSecurityPoliciesOutput 4463 if *v == nil { 4464 sv = &ListSecurityPoliciesOutput{} 4465 } else { 4466 sv = *v 4467 } 4468 4469 for key, value := range shape { 4470 switch key { 4471 case "NextToken": 4472 if value != nil { 4473 jtv, ok := value.(string) 4474 if !ok { 4475 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 4476 } 4477 sv.NextToken = ptr.String(jtv) 4478 } 4479 4480 case "SecurityPolicyNames": 4481 if err := awsAwsjson11_deserializeDocumentSecurityPolicyNames(&sv.SecurityPolicyNames, value); err != nil { 4482 return err 4483 } 4484 4485 default: 4486 _, _ = key, value 4487 4488 } 4489 } 4490 *v = sv 4491 return nil 4492} 4493 4494func awsAwsjson11_deserializeOpDocumentListServersOutput(v **ListServersOutput, value interface{}) error { 4495 if v == nil { 4496 return fmt.Errorf("unexpected nil of type %T", v) 4497 } 4498 if value == nil { 4499 return nil 4500 } 4501 4502 shape, ok := value.(map[string]interface{}) 4503 if !ok { 4504 return fmt.Errorf("unexpected JSON type %v", value) 4505 } 4506 4507 var sv *ListServersOutput 4508 if *v == nil { 4509 sv = &ListServersOutput{} 4510 } else { 4511 sv = *v 4512 } 4513 4514 for key, value := range shape { 4515 switch key { 4516 case "NextToken": 4517 if value != nil { 4518 jtv, ok := value.(string) 4519 if !ok { 4520 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 4521 } 4522 sv.NextToken = ptr.String(jtv) 4523 } 4524 4525 case "Servers": 4526 if err := awsAwsjson11_deserializeDocumentListedServers(&sv.Servers, value); err != nil { 4527 return err 4528 } 4529 4530 default: 4531 _, _ = key, value 4532 4533 } 4534 } 4535 *v = sv 4536 return nil 4537} 4538 4539func awsAwsjson11_deserializeOpDocumentListTagsForResourceOutput(v **ListTagsForResourceOutput, value interface{}) error { 4540 if v == nil { 4541 return fmt.Errorf("unexpected nil of type %T", v) 4542 } 4543 if value == nil { 4544 return nil 4545 } 4546 4547 shape, ok := value.(map[string]interface{}) 4548 if !ok { 4549 return fmt.Errorf("unexpected JSON type %v", value) 4550 } 4551 4552 var sv *ListTagsForResourceOutput 4553 if *v == nil { 4554 sv = &ListTagsForResourceOutput{} 4555 } else { 4556 sv = *v 4557 } 4558 4559 for key, value := range shape { 4560 switch key { 4561 case "Arn": 4562 if value != nil { 4563 jtv, ok := value.(string) 4564 if !ok { 4565 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 4566 } 4567 sv.Arn = ptr.String(jtv) 4568 } 4569 4570 case "NextToken": 4571 if value != nil { 4572 jtv, ok := value.(string) 4573 if !ok { 4574 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 4575 } 4576 sv.NextToken = ptr.String(jtv) 4577 } 4578 4579 case "Tags": 4580 if err := awsAwsjson11_deserializeDocumentTags(&sv.Tags, value); err != nil { 4581 return err 4582 } 4583 4584 default: 4585 _, _ = key, value 4586 4587 } 4588 } 4589 *v = sv 4590 return nil 4591} 4592 4593func awsAwsjson11_deserializeOpDocumentListUsersOutput(v **ListUsersOutput, value interface{}) error { 4594 if v == nil { 4595 return fmt.Errorf("unexpected nil of type %T", v) 4596 } 4597 if value == nil { 4598 return nil 4599 } 4600 4601 shape, ok := value.(map[string]interface{}) 4602 if !ok { 4603 return fmt.Errorf("unexpected JSON type %v", value) 4604 } 4605 4606 var sv *ListUsersOutput 4607 if *v == nil { 4608 sv = &ListUsersOutput{} 4609 } else { 4610 sv = *v 4611 } 4612 4613 for key, value := range shape { 4614 switch key { 4615 case "NextToken": 4616 if value != nil { 4617 jtv, ok := value.(string) 4618 if !ok { 4619 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 4620 } 4621 sv.NextToken = ptr.String(jtv) 4622 } 4623 4624 case "ServerId": 4625 if value != nil { 4626 jtv, ok := value.(string) 4627 if !ok { 4628 return fmt.Errorf("expected ServerId to be of type string, got %T instead", value) 4629 } 4630 sv.ServerId = ptr.String(jtv) 4631 } 4632 4633 case "Users": 4634 if err := awsAwsjson11_deserializeDocumentListedUsers(&sv.Users, value); err != nil { 4635 return err 4636 } 4637 4638 default: 4639 _, _ = key, value 4640 4641 } 4642 } 4643 *v = sv 4644 return nil 4645} 4646 4647func awsAwsjson11_deserializeOpDocumentTestIdentityProviderOutput(v **TestIdentityProviderOutput, value interface{}) error { 4648 if v == nil { 4649 return fmt.Errorf("unexpected nil of type %T", v) 4650 } 4651 if value == nil { 4652 return nil 4653 } 4654 4655 shape, ok := value.(map[string]interface{}) 4656 if !ok { 4657 return fmt.Errorf("unexpected JSON type %v", value) 4658 } 4659 4660 var sv *TestIdentityProviderOutput 4661 if *v == nil { 4662 sv = &TestIdentityProviderOutput{} 4663 } else { 4664 sv = *v 4665 } 4666 4667 for key, value := range shape { 4668 switch key { 4669 case "Message": 4670 if value != nil { 4671 jtv, ok := value.(string) 4672 if !ok { 4673 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 4674 } 4675 sv.Message = ptr.String(jtv) 4676 } 4677 4678 case "Response": 4679 if value != nil { 4680 jtv, ok := value.(string) 4681 if !ok { 4682 return fmt.Errorf("expected Response to be of type string, got %T instead", value) 4683 } 4684 sv.Response = ptr.String(jtv) 4685 } 4686 4687 case "StatusCode": 4688 if value != nil { 4689 jtv, ok := value.(json.Number) 4690 if !ok { 4691 return fmt.Errorf("expected StatusCode to be json.Number, got %T instead", value) 4692 } 4693 i64, err := jtv.Int64() 4694 if err != nil { 4695 return err 4696 } 4697 sv.StatusCode = int32(i64) 4698 } 4699 4700 case "Url": 4701 if value != nil { 4702 jtv, ok := value.(string) 4703 if !ok { 4704 return fmt.Errorf("expected Url to be of type string, got %T instead", value) 4705 } 4706 sv.Url = ptr.String(jtv) 4707 } 4708 4709 default: 4710 _, _ = key, value 4711 4712 } 4713 } 4714 *v = sv 4715 return nil 4716} 4717 4718func awsAwsjson11_deserializeOpDocumentUpdateServerOutput(v **UpdateServerOutput, 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 *UpdateServerOutput 4732 if *v == nil { 4733 sv = &UpdateServerOutput{} 4734 } else { 4735 sv = *v 4736 } 4737 4738 for key, value := range shape { 4739 switch key { 4740 case "ServerId": 4741 if value != nil { 4742 jtv, ok := value.(string) 4743 if !ok { 4744 return fmt.Errorf("expected ServerId to be of type string, got %T instead", value) 4745 } 4746 sv.ServerId = ptr.String(jtv) 4747 } 4748 4749 default: 4750 _, _ = key, value 4751 4752 } 4753 } 4754 *v = sv 4755 return nil 4756} 4757 4758func awsAwsjson11_deserializeOpDocumentUpdateUserOutput(v **UpdateUserOutput, value interface{}) error { 4759 if v == nil { 4760 return fmt.Errorf("unexpected nil of type %T", v) 4761 } 4762 if value == nil { 4763 return nil 4764 } 4765 4766 shape, ok := value.(map[string]interface{}) 4767 if !ok { 4768 return fmt.Errorf("unexpected JSON type %v", value) 4769 } 4770 4771 var sv *UpdateUserOutput 4772 if *v == nil { 4773 sv = &UpdateUserOutput{} 4774 } else { 4775 sv = *v 4776 } 4777 4778 for key, value := range shape { 4779 switch key { 4780 case "ServerId": 4781 if value != nil { 4782 jtv, ok := value.(string) 4783 if !ok { 4784 return fmt.Errorf("expected ServerId to be of type string, got %T instead", value) 4785 } 4786 sv.ServerId = ptr.String(jtv) 4787 } 4788 4789 case "UserName": 4790 if value != nil { 4791 jtv, ok := value.(string) 4792 if !ok { 4793 return fmt.Errorf("expected UserName to be of type string, got %T instead", value) 4794 } 4795 sv.UserName = ptr.String(jtv) 4796 } 4797 4798 default: 4799 _, _ = key, value 4800 4801 } 4802 } 4803 *v = sv 4804 return nil 4805} 4806