1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package sms 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/sms/types" 12 smithy "github.com/aws/smithy-go" 13 smithyio "github.com/aws/smithy-go/io" 14 "github.com/aws/smithy-go/middleware" 15 "github.com/aws/smithy-go/ptr" 16 smithytime "github.com/aws/smithy-go/time" 17 smithyhttp "github.com/aws/smithy-go/transport/http" 18 "io" 19 "strings" 20) 21 22type awsAwsjson11_deserializeOpCreateApp struct { 23} 24 25func (*awsAwsjson11_deserializeOpCreateApp) ID() string { 26 return "OperationDeserializer" 27} 28 29func (m *awsAwsjson11_deserializeOpCreateApp) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 30 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 31) { 32 out, metadata, err = next.HandleDeserialize(ctx, in) 33 if err != nil { 34 return out, metadata, err 35 } 36 37 response, ok := out.RawResponse.(*smithyhttp.Response) 38 if !ok { 39 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 40 } 41 42 if response.StatusCode < 200 || response.StatusCode >= 300 { 43 return out, metadata, awsAwsjson11_deserializeOpErrorCreateApp(response, &metadata) 44 } 45 output := &CreateAppOutput{} 46 out.Result = output 47 48 var buff [1024]byte 49 ringBuffer := smithyio.NewRingBuffer(buff[:]) 50 51 body := io.TeeReader(response.Body, ringBuffer) 52 decoder := json.NewDecoder(body) 53 decoder.UseNumber() 54 var shape interface{} 55 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 56 var snapshot bytes.Buffer 57 io.Copy(&snapshot, ringBuffer) 58 err = &smithy.DeserializationError{ 59 Err: fmt.Errorf("failed to decode response body, %w", err), 60 Snapshot: snapshot.Bytes(), 61 } 62 return out, metadata, err 63 } 64 65 err = awsAwsjson11_deserializeOpDocumentCreateAppOutput(&output, shape) 66 if err != nil { 67 var snapshot bytes.Buffer 68 io.Copy(&snapshot, ringBuffer) 69 err = &smithy.DeserializationError{ 70 Err: fmt.Errorf("failed to decode response body, %w", err), 71 Snapshot: snapshot.Bytes(), 72 } 73 return out, metadata, err 74 } 75 76 return out, metadata, err 77} 78 79func awsAwsjson11_deserializeOpErrorCreateApp(response *smithyhttp.Response, metadata *middleware.Metadata) error { 80 var errorBuffer bytes.Buffer 81 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 82 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 83 } 84 errorBody := bytes.NewReader(errorBuffer.Bytes()) 85 86 errorCode := "UnknownError" 87 errorMessage := errorCode 88 89 code := response.Header.Get("X-Amzn-ErrorType") 90 if len(code) != 0 { 91 errorCode = restjson.SanitizeErrorCode(code) 92 } 93 94 var buff [1024]byte 95 ringBuffer := smithyio.NewRingBuffer(buff[:]) 96 97 body := io.TeeReader(errorBody, ringBuffer) 98 decoder := json.NewDecoder(body) 99 decoder.UseNumber() 100 code, message, err := restjson.GetErrorInfo(decoder) 101 if err != nil { 102 var snapshot bytes.Buffer 103 io.Copy(&snapshot, ringBuffer) 104 err = &smithy.DeserializationError{ 105 Err: fmt.Errorf("failed to decode response body, %w", err), 106 Snapshot: snapshot.Bytes(), 107 } 108 return err 109 } 110 111 errorBody.Seek(0, io.SeekStart) 112 if len(code) != 0 { 113 errorCode = restjson.SanitizeErrorCode(code) 114 } 115 if len(message) != 0 { 116 errorMessage = message 117 } 118 119 switch { 120 case strings.EqualFold("InternalError", errorCode): 121 return awsAwsjson11_deserializeErrorInternalError(response, errorBody) 122 123 case strings.EqualFold("InvalidParameterException", errorCode): 124 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 125 126 case strings.EqualFold("MissingRequiredParameterException", errorCode): 127 return awsAwsjson11_deserializeErrorMissingRequiredParameterException(response, errorBody) 128 129 case strings.EqualFold("OperationNotPermittedException", errorCode): 130 return awsAwsjson11_deserializeErrorOperationNotPermittedException(response, errorBody) 131 132 case strings.EqualFold("UnauthorizedOperationException", errorCode): 133 return awsAwsjson11_deserializeErrorUnauthorizedOperationException(response, errorBody) 134 135 default: 136 genericError := &smithy.GenericAPIError{ 137 Code: errorCode, 138 Message: errorMessage, 139 } 140 return genericError 141 142 } 143} 144 145type awsAwsjson11_deserializeOpCreateReplicationJob struct { 146} 147 148func (*awsAwsjson11_deserializeOpCreateReplicationJob) ID() string { 149 return "OperationDeserializer" 150} 151 152func (m *awsAwsjson11_deserializeOpCreateReplicationJob) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 153 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 154) { 155 out, metadata, err = next.HandleDeserialize(ctx, in) 156 if err != nil { 157 return out, metadata, err 158 } 159 160 response, ok := out.RawResponse.(*smithyhttp.Response) 161 if !ok { 162 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 163 } 164 165 if response.StatusCode < 200 || response.StatusCode >= 300 { 166 return out, metadata, awsAwsjson11_deserializeOpErrorCreateReplicationJob(response, &metadata) 167 } 168 output := &CreateReplicationJobOutput{} 169 out.Result = output 170 171 var buff [1024]byte 172 ringBuffer := smithyio.NewRingBuffer(buff[:]) 173 174 body := io.TeeReader(response.Body, ringBuffer) 175 decoder := json.NewDecoder(body) 176 decoder.UseNumber() 177 var shape interface{} 178 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 179 var snapshot bytes.Buffer 180 io.Copy(&snapshot, ringBuffer) 181 err = &smithy.DeserializationError{ 182 Err: fmt.Errorf("failed to decode response body, %w", err), 183 Snapshot: snapshot.Bytes(), 184 } 185 return out, metadata, err 186 } 187 188 err = awsAwsjson11_deserializeOpDocumentCreateReplicationJobOutput(&output, shape) 189 if err != nil { 190 var snapshot bytes.Buffer 191 io.Copy(&snapshot, ringBuffer) 192 err = &smithy.DeserializationError{ 193 Err: fmt.Errorf("failed to decode response body, %w", err), 194 Snapshot: snapshot.Bytes(), 195 } 196 return out, metadata, err 197 } 198 199 return out, metadata, err 200} 201 202func awsAwsjson11_deserializeOpErrorCreateReplicationJob(response *smithyhttp.Response, metadata *middleware.Metadata) error { 203 var errorBuffer bytes.Buffer 204 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 205 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 206 } 207 errorBody := bytes.NewReader(errorBuffer.Bytes()) 208 209 errorCode := "UnknownError" 210 errorMessage := errorCode 211 212 code := response.Header.Get("X-Amzn-ErrorType") 213 if len(code) != 0 { 214 errorCode = restjson.SanitizeErrorCode(code) 215 } 216 217 var buff [1024]byte 218 ringBuffer := smithyio.NewRingBuffer(buff[:]) 219 220 body := io.TeeReader(errorBody, ringBuffer) 221 decoder := json.NewDecoder(body) 222 decoder.UseNumber() 223 code, message, err := restjson.GetErrorInfo(decoder) 224 if err != nil { 225 var snapshot bytes.Buffer 226 io.Copy(&snapshot, ringBuffer) 227 err = &smithy.DeserializationError{ 228 Err: fmt.Errorf("failed to decode response body, %w", err), 229 Snapshot: snapshot.Bytes(), 230 } 231 return err 232 } 233 234 errorBody.Seek(0, io.SeekStart) 235 if len(code) != 0 { 236 errorCode = restjson.SanitizeErrorCode(code) 237 } 238 if len(message) != 0 { 239 errorMessage = message 240 } 241 242 switch { 243 case strings.EqualFold("InternalError", errorCode): 244 return awsAwsjson11_deserializeErrorInternalError(response, errorBody) 245 246 case strings.EqualFold("InvalidParameterException", errorCode): 247 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 248 249 case strings.EqualFold("MissingRequiredParameterException", errorCode): 250 return awsAwsjson11_deserializeErrorMissingRequiredParameterException(response, errorBody) 251 252 case strings.EqualFold("NoConnectorsAvailableException", errorCode): 253 return awsAwsjson11_deserializeErrorNoConnectorsAvailableException(response, errorBody) 254 255 case strings.EqualFold("OperationNotPermittedException", errorCode): 256 return awsAwsjson11_deserializeErrorOperationNotPermittedException(response, errorBody) 257 258 case strings.EqualFold("ReplicationJobAlreadyExistsException", errorCode): 259 return awsAwsjson11_deserializeErrorReplicationJobAlreadyExistsException(response, errorBody) 260 261 case strings.EqualFold("ServerCannotBeReplicatedException", errorCode): 262 return awsAwsjson11_deserializeErrorServerCannotBeReplicatedException(response, errorBody) 263 264 case strings.EqualFold("TemporarilyUnavailableException", errorCode): 265 return awsAwsjson11_deserializeErrorTemporarilyUnavailableException(response, errorBody) 266 267 case strings.EqualFold("UnauthorizedOperationException", errorCode): 268 return awsAwsjson11_deserializeErrorUnauthorizedOperationException(response, errorBody) 269 270 default: 271 genericError := &smithy.GenericAPIError{ 272 Code: errorCode, 273 Message: errorMessage, 274 } 275 return genericError 276 277 } 278} 279 280type awsAwsjson11_deserializeOpDeleteApp struct { 281} 282 283func (*awsAwsjson11_deserializeOpDeleteApp) ID() string { 284 return "OperationDeserializer" 285} 286 287func (m *awsAwsjson11_deserializeOpDeleteApp) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 288 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 289) { 290 out, metadata, err = next.HandleDeserialize(ctx, in) 291 if err != nil { 292 return out, metadata, err 293 } 294 295 response, ok := out.RawResponse.(*smithyhttp.Response) 296 if !ok { 297 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 298 } 299 300 if response.StatusCode < 200 || response.StatusCode >= 300 { 301 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteApp(response, &metadata) 302 } 303 output := &DeleteAppOutput{} 304 out.Result = output 305 306 var buff [1024]byte 307 ringBuffer := smithyio.NewRingBuffer(buff[:]) 308 309 body := io.TeeReader(response.Body, ringBuffer) 310 decoder := json.NewDecoder(body) 311 decoder.UseNumber() 312 var shape interface{} 313 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 314 var snapshot bytes.Buffer 315 io.Copy(&snapshot, ringBuffer) 316 err = &smithy.DeserializationError{ 317 Err: fmt.Errorf("failed to decode response body, %w", err), 318 Snapshot: snapshot.Bytes(), 319 } 320 return out, metadata, err 321 } 322 323 err = awsAwsjson11_deserializeOpDocumentDeleteAppOutput(&output, shape) 324 if err != nil { 325 var snapshot bytes.Buffer 326 io.Copy(&snapshot, ringBuffer) 327 err = &smithy.DeserializationError{ 328 Err: fmt.Errorf("failed to decode response body, %w", err), 329 Snapshot: snapshot.Bytes(), 330 } 331 return out, metadata, err 332 } 333 334 return out, metadata, err 335} 336 337func awsAwsjson11_deserializeOpErrorDeleteApp(response *smithyhttp.Response, metadata *middleware.Metadata) error { 338 var errorBuffer bytes.Buffer 339 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 340 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 341 } 342 errorBody := bytes.NewReader(errorBuffer.Bytes()) 343 344 errorCode := "UnknownError" 345 errorMessage := errorCode 346 347 code := response.Header.Get("X-Amzn-ErrorType") 348 if len(code) != 0 { 349 errorCode = restjson.SanitizeErrorCode(code) 350 } 351 352 var buff [1024]byte 353 ringBuffer := smithyio.NewRingBuffer(buff[:]) 354 355 body := io.TeeReader(errorBody, ringBuffer) 356 decoder := json.NewDecoder(body) 357 decoder.UseNumber() 358 code, message, err := restjson.GetErrorInfo(decoder) 359 if err != nil { 360 var snapshot bytes.Buffer 361 io.Copy(&snapshot, ringBuffer) 362 err = &smithy.DeserializationError{ 363 Err: fmt.Errorf("failed to decode response body, %w", err), 364 Snapshot: snapshot.Bytes(), 365 } 366 return err 367 } 368 369 errorBody.Seek(0, io.SeekStart) 370 if len(code) != 0 { 371 errorCode = restjson.SanitizeErrorCode(code) 372 } 373 if len(message) != 0 { 374 errorMessage = message 375 } 376 377 switch { 378 case strings.EqualFold("InternalError", errorCode): 379 return awsAwsjson11_deserializeErrorInternalError(response, errorBody) 380 381 case strings.EqualFold("InvalidParameterException", errorCode): 382 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 383 384 case strings.EqualFold("MissingRequiredParameterException", errorCode): 385 return awsAwsjson11_deserializeErrorMissingRequiredParameterException(response, errorBody) 386 387 case strings.EqualFold("OperationNotPermittedException", errorCode): 388 return awsAwsjson11_deserializeErrorOperationNotPermittedException(response, errorBody) 389 390 case strings.EqualFold("UnauthorizedOperationException", errorCode): 391 return awsAwsjson11_deserializeErrorUnauthorizedOperationException(response, errorBody) 392 393 default: 394 genericError := &smithy.GenericAPIError{ 395 Code: errorCode, 396 Message: errorMessage, 397 } 398 return genericError 399 400 } 401} 402 403type awsAwsjson11_deserializeOpDeleteAppLaunchConfiguration struct { 404} 405 406func (*awsAwsjson11_deserializeOpDeleteAppLaunchConfiguration) ID() string { 407 return "OperationDeserializer" 408} 409 410func (m *awsAwsjson11_deserializeOpDeleteAppLaunchConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 411 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 412) { 413 out, metadata, err = next.HandleDeserialize(ctx, in) 414 if err != nil { 415 return out, metadata, err 416 } 417 418 response, ok := out.RawResponse.(*smithyhttp.Response) 419 if !ok { 420 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 421 } 422 423 if response.StatusCode < 200 || response.StatusCode >= 300 { 424 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteAppLaunchConfiguration(response, &metadata) 425 } 426 output := &DeleteAppLaunchConfigurationOutput{} 427 out.Result = output 428 429 var buff [1024]byte 430 ringBuffer := smithyio.NewRingBuffer(buff[:]) 431 432 body := io.TeeReader(response.Body, ringBuffer) 433 decoder := json.NewDecoder(body) 434 decoder.UseNumber() 435 var shape interface{} 436 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 437 var snapshot bytes.Buffer 438 io.Copy(&snapshot, ringBuffer) 439 err = &smithy.DeserializationError{ 440 Err: fmt.Errorf("failed to decode response body, %w", err), 441 Snapshot: snapshot.Bytes(), 442 } 443 return out, metadata, err 444 } 445 446 err = awsAwsjson11_deserializeOpDocumentDeleteAppLaunchConfigurationOutput(&output, shape) 447 if err != nil { 448 var snapshot bytes.Buffer 449 io.Copy(&snapshot, ringBuffer) 450 err = &smithy.DeserializationError{ 451 Err: fmt.Errorf("failed to decode response body, %w", err), 452 Snapshot: snapshot.Bytes(), 453 } 454 return out, metadata, err 455 } 456 457 return out, metadata, err 458} 459 460func awsAwsjson11_deserializeOpErrorDeleteAppLaunchConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { 461 var errorBuffer bytes.Buffer 462 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 463 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 464 } 465 errorBody := bytes.NewReader(errorBuffer.Bytes()) 466 467 errorCode := "UnknownError" 468 errorMessage := errorCode 469 470 code := response.Header.Get("X-Amzn-ErrorType") 471 if len(code) != 0 { 472 errorCode = restjson.SanitizeErrorCode(code) 473 } 474 475 var buff [1024]byte 476 ringBuffer := smithyio.NewRingBuffer(buff[:]) 477 478 body := io.TeeReader(errorBody, ringBuffer) 479 decoder := json.NewDecoder(body) 480 decoder.UseNumber() 481 code, message, err := restjson.GetErrorInfo(decoder) 482 if err != nil { 483 var snapshot bytes.Buffer 484 io.Copy(&snapshot, ringBuffer) 485 err = &smithy.DeserializationError{ 486 Err: fmt.Errorf("failed to decode response body, %w", err), 487 Snapshot: snapshot.Bytes(), 488 } 489 return err 490 } 491 492 errorBody.Seek(0, io.SeekStart) 493 if len(code) != 0 { 494 errorCode = restjson.SanitizeErrorCode(code) 495 } 496 if len(message) != 0 { 497 errorMessage = message 498 } 499 500 switch { 501 case strings.EqualFold("InternalError", errorCode): 502 return awsAwsjson11_deserializeErrorInternalError(response, errorBody) 503 504 case strings.EqualFold("InvalidParameterException", errorCode): 505 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 506 507 case strings.EqualFold("MissingRequiredParameterException", errorCode): 508 return awsAwsjson11_deserializeErrorMissingRequiredParameterException(response, errorBody) 509 510 case strings.EqualFold("OperationNotPermittedException", errorCode): 511 return awsAwsjson11_deserializeErrorOperationNotPermittedException(response, errorBody) 512 513 case strings.EqualFold("UnauthorizedOperationException", errorCode): 514 return awsAwsjson11_deserializeErrorUnauthorizedOperationException(response, errorBody) 515 516 default: 517 genericError := &smithy.GenericAPIError{ 518 Code: errorCode, 519 Message: errorMessage, 520 } 521 return genericError 522 523 } 524} 525 526type awsAwsjson11_deserializeOpDeleteAppReplicationConfiguration struct { 527} 528 529func (*awsAwsjson11_deserializeOpDeleteAppReplicationConfiguration) ID() string { 530 return "OperationDeserializer" 531} 532 533func (m *awsAwsjson11_deserializeOpDeleteAppReplicationConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 534 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 535) { 536 out, metadata, err = next.HandleDeserialize(ctx, in) 537 if err != nil { 538 return out, metadata, err 539 } 540 541 response, ok := out.RawResponse.(*smithyhttp.Response) 542 if !ok { 543 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 544 } 545 546 if response.StatusCode < 200 || response.StatusCode >= 300 { 547 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteAppReplicationConfiguration(response, &metadata) 548 } 549 output := &DeleteAppReplicationConfigurationOutput{} 550 out.Result = output 551 552 var buff [1024]byte 553 ringBuffer := smithyio.NewRingBuffer(buff[:]) 554 555 body := io.TeeReader(response.Body, ringBuffer) 556 decoder := json.NewDecoder(body) 557 decoder.UseNumber() 558 var shape interface{} 559 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 560 var snapshot bytes.Buffer 561 io.Copy(&snapshot, ringBuffer) 562 err = &smithy.DeserializationError{ 563 Err: fmt.Errorf("failed to decode response body, %w", err), 564 Snapshot: snapshot.Bytes(), 565 } 566 return out, metadata, err 567 } 568 569 err = awsAwsjson11_deserializeOpDocumentDeleteAppReplicationConfigurationOutput(&output, shape) 570 if err != nil { 571 var snapshot bytes.Buffer 572 io.Copy(&snapshot, ringBuffer) 573 err = &smithy.DeserializationError{ 574 Err: fmt.Errorf("failed to decode response body, %w", err), 575 Snapshot: snapshot.Bytes(), 576 } 577 return out, metadata, err 578 } 579 580 return out, metadata, err 581} 582 583func awsAwsjson11_deserializeOpErrorDeleteAppReplicationConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { 584 var errorBuffer bytes.Buffer 585 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 586 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 587 } 588 errorBody := bytes.NewReader(errorBuffer.Bytes()) 589 590 errorCode := "UnknownError" 591 errorMessage := errorCode 592 593 code := response.Header.Get("X-Amzn-ErrorType") 594 if len(code) != 0 { 595 errorCode = restjson.SanitizeErrorCode(code) 596 } 597 598 var buff [1024]byte 599 ringBuffer := smithyio.NewRingBuffer(buff[:]) 600 601 body := io.TeeReader(errorBody, ringBuffer) 602 decoder := json.NewDecoder(body) 603 decoder.UseNumber() 604 code, message, err := restjson.GetErrorInfo(decoder) 605 if err != nil { 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 err 613 } 614 615 errorBody.Seek(0, io.SeekStart) 616 if len(code) != 0 { 617 errorCode = restjson.SanitizeErrorCode(code) 618 } 619 if len(message) != 0 { 620 errorMessage = message 621 } 622 623 switch { 624 case strings.EqualFold("InternalError", errorCode): 625 return awsAwsjson11_deserializeErrorInternalError(response, errorBody) 626 627 case strings.EqualFold("InvalidParameterException", errorCode): 628 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 629 630 case strings.EqualFold("MissingRequiredParameterException", errorCode): 631 return awsAwsjson11_deserializeErrorMissingRequiredParameterException(response, errorBody) 632 633 case strings.EqualFold("OperationNotPermittedException", errorCode): 634 return awsAwsjson11_deserializeErrorOperationNotPermittedException(response, errorBody) 635 636 case strings.EqualFold("UnauthorizedOperationException", errorCode): 637 return awsAwsjson11_deserializeErrorUnauthorizedOperationException(response, errorBody) 638 639 default: 640 genericError := &smithy.GenericAPIError{ 641 Code: errorCode, 642 Message: errorMessage, 643 } 644 return genericError 645 646 } 647} 648 649type awsAwsjson11_deserializeOpDeleteAppValidationConfiguration struct { 650} 651 652func (*awsAwsjson11_deserializeOpDeleteAppValidationConfiguration) ID() string { 653 return "OperationDeserializer" 654} 655 656func (m *awsAwsjson11_deserializeOpDeleteAppValidationConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 657 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 658) { 659 out, metadata, err = next.HandleDeserialize(ctx, in) 660 if err != nil { 661 return out, metadata, err 662 } 663 664 response, ok := out.RawResponse.(*smithyhttp.Response) 665 if !ok { 666 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 667 } 668 669 if response.StatusCode < 200 || response.StatusCode >= 300 { 670 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteAppValidationConfiguration(response, &metadata) 671 } 672 output := &DeleteAppValidationConfigurationOutput{} 673 out.Result = output 674 675 var buff [1024]byte 676 ringBuffer := smithyio.NewRingBuffer(buff[:]) 677 678 body := io.TeeReader(response.Body, ringBuffer) 679 decoder := json.NewDecoder(body) 680 decoder.UseNumber() 681 var shape interface{} 682 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 683 var snapshot bytes.Buffer 684 io.Copy(&snapshot, ringBuffer) 685 err = &smithy.DeserializationError{ 686 Err: fmt.Errorf("failed to decode response body, %w", err), 687 Snapshot: snapshot.Bytes(), 688 } 689 return out, metadata, err 690 } 691 692 err = awsAwsjson11_deserializeOpDocumentDeleteAppValidationConfigurationOutput(&output, shape) 693 if err != nil { 694 var snapshot bytes.Buffer 695 io.Copy(&snapshot, ringBuffer) 696 err = &smithy.DeserializationError{ 697 Err: fmt.Errorf("failed to decode response body, %w", err), 698 Snapshot: snapshot.Bytes(), 699 } 700 return out, metadata, err 701 } 702 703 return out, metadata, err 704} 705 706func awsAwsjson11_deserializeOpErrorDeleteAppValidationConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { 707 var errorBuffer bytes.Buffer 708 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 709 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 710 } 711 errorBody := bytes.NewReader(errorBuffer.Bytes()) 712 713 errorCode := "UnknownError" 714 errorMessage := errorCode 715 716 code := response.Header.Get("X-Amzn-ErrorType") 717 if len(code) != 0 { 718 errorCode = restjson.SanitizeErrorCode(code) 719 } 720 721 var buff [1024]byte 722 ringBuffer := smithyio.NewRingBuffer(buff[:]) 723 724 body := io.TeeReader(errorBody, ringBuffer) 725 decoder := json.NewDecoder(body) 726 decoder.UseNumber() 727 code, message, err := restjson.GetErrorInfo(decoder) 728 if err != nil { 729 var snapshot bytes.Buffer 730 io.Copy(&snapshot, ringBuffer) 731 err = &smithy.DeserializationError{ 732 Err: fmt.Errorf("failed to decode response body, %w", err), 733 Snapshot: snapshot.Bytes(), 734 } 735 return err 736 } 737 738 errorBody.Seek(0, io.SeekStart) 739 if len(code) != 0 { 740 errorCode = restjson.SanitizeErrorCode(code) 741 } 742 if len(message) != 0 { 743 errorMessage = message 744 } 745 746 switch { 747 case strings.EqualFold("InternalError", errorCode): 748 return awsAwsjson11_deserializeErrorInternalError(response, errorBody) 749 750 case strings.EqualFold("InvalidParameterException", errorCode): 751 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 752 753 case strings.EqualFold("MissingRequiredParameterException", errorCode): 754 return awsAwsjson11_deserializeErrorMissingRequiredParameterException(response, errorBody) 755 756 case strings.EqualFold("OperationNotPermittedException", errorCode): 757 return awsAwsjson11_deserializeErrorOperationNotPermittedException(response, errorBody) 758 759 case strings.EqualFold("UnauthorizedOperationException", errorCode): 760 return awsAwsjson11_deserializeErrorUnauthorizedOperationException(response, errorBody) 761 762 default: 763 genericError := &smithy.GenericAPIError{ 764 Code: errorCode, 765 Message: errorMessage, 766 } 767 return genericError 768 769 } 770} 771 772type awsAwsjson11_deserializeOpDeleteReplicationJob struct { 773} 774 775func (*awsAwsjson11_deserializeOpDeleteReplicationJob) ID() string { 776 return "OperationDeserializer" 777} 778 779func (m *awsAwsjson11_deserializeOpDeleteReplicationJob) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 780 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 781) { 782 out, metadata, err = next.HandleDeserialize(ctx, in) 783 if err != nil { 784 return out, metadata, err 785 } 786 787 response, ok := out.RawResponse.(*smithyhttp.Response) 788 if !ok { 789 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 790 } 791 792 if response.StatusCode < 200 || response.StatusCode >= 300 { 793 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteReplicationJob(response, &metadata) 794 } 795 output := &DeleteReplicationJobOutput{} 796 out.Result = output 797 798 var buff [1024]byte 799 ringBuffer := smithyio.NewRingBuffer(buff[:]) 800 801 body := io.TeeReader(response.Body, ringBuffer) 802 decoder := json.NewDecoder(body) 803 decoder.UseNumber() 804 var shape interface{} 805 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 806 var snapshot bytes.Buffer 807 io.Copy(&snapshot, ringBuffer) 808 err = &smithy.DeserializationError{ 809 Err: fmt.Errorf("failed to decode response body, %w", err), 810 Snapshot: snapshot.Bytes(), 811 } 812 return out, metadata, err 813 } 814 815 err = awsAwsjson11_deserializeOpDocumentDeleteReplicationJobOutput(&output, shape) 816 if err != nil { 817 var snapshot bytes.Buffer 818 io.Copy(&snapshot, ringBuffer) 819 err = &smithy.DeserializationError{ 820 Err: fmt.Errorf("failed to decode response body, %w", err), 821 Snapshot: snapshot.Bytes(), 822 } 823 return out, metadata, err 824 } 825 826 return out, metadata, err 827} 828 829func awsAwsjson11_deserializeOpErrorDeleteReplicationJob(response *smithyhttp.Response, metadata *middleware.Metadata) error { 830 var errorBuffer bytes.Buffer 831 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 832 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 833 } 834 errorBody := bytes.NewReader(errorBuffer.Bytes()) 835 836 errorCode := "UnknownError" 837 errorMessage := errorCode 838 839 code := response.Header.Get("X-Amzn-ErrorType") 840 if len(code) != 0 { 841 errorCode = restjson.SanitizeErrorCode(code) 842 } 843 844 var buff [1024]byte 845 ringBuffer := smithyio.NewRingBuffer(buff[:]) 846 847 body := io.TeeReader(errorBody, ringBuffer) 848 decoder := json.NewDecoder(body) 849 decoder.UseNumber() 850 code, message, err := restjson.GetErrorInfo(decoder) 851 if err != nil { 852 var snapshot bytes.Buffer 853 io.Copy(&snapshot, ringBuffer) 854 err = &smithy.DeserializationError{ 855 Err: fmt.Errorf("failed to decode response body, %w", err), 856 Snapshot: snapshot.Bytes(), 857 } 858 return err 859 } 860 861 errorBody.Seek(0, io.SeekStart) 862 if len(code) != 0 { 863 errorCode = restjson.SanitizeErrorCode(code) 864 } 865 if len(message) != 0 { 866 errorMessage = message 867 } 868 869 switch { 870 case strings.EqualFold("InvalidParameterException", errorCode): 871 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 872 873 case strings.EqualFold("MissingRequiredParameterException", errorCode): 874 return awsAwsjson11_deserializeErrorMissingRequiredParameterException(response, errorBody) 875 876 case strings.EqualFold("OperationNotPermittedException", errorCode): 877 return awsAwsjson11_deserializeErrorOperationNotPermittedException(response, errorBody) 878 879 case strings.EqualFold("ReplicationJobNotFoundException", errorCode): 880 return awsAwsjson11_deserializeErrorReplicationJobNotFoundException(response, errorBody) 881 882 case strings.EqualFold("UnauthorizedOperationException", errorCode): 883 return awsAwsjson11_deserializeErrorUnauthorizedOperationException(response, errorBody) 884 885 default: 886 genericError := &smithy.GenericAPIError{ 887 Code: errorCode, 888 Message: errorMessage, 889 } 890 return genericError 891 892 } 893} 894 895type awsAwsjson11_deserializeOpDeleteServerCatalog struct { 896} 897 898func (*awsAwsjson11_deserializeOpDeleteServerCatalog) ID() string { 899 return "OperationDeserializer" 900} 901 902func (m *awsAwsjson11_deserializeOpDeleteServerCatalog) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 903 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 904) { 905 out, metadata, err = next.HandleDeserialize(ctx, in) 906 if err != nil { 907 return out, metadata, err 908 } 909 910 response, ok := out.RawResponse.(*smithyhttp.Response) 911 if !ok { 912 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 913 } 914 915 if response.StatusCode < 200 || response.StatusCode >= 300 { 916 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteServerCatalog(response, &metadata) 917 } 918 output := &DeleteServerCatalogOutput{} 919 out.Result = output 920 921 var buff [1024]byte 922 ringBuffer := smithyio.NewRingBuffer(buff[:]) 923 924 body := io.TeeReader(response.Body, ringBuffer) 925 decoder := json.NewDecoder(body) 926 decoder.UseNumber() 927 var shape interface{} 928 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 929 var snapshot bytes.Buffer 930 io.Copy(&snapshot, ringBuffer) 931 err = &smithy.DeserializationError{ 932 Err: fmt.Errorf("failed to decode response body, %w", err), 933 Snapshot: snapshot.Bytes(), 934 } 935 return out, metadata, err 936 } 937 938 err = awsAwsjson11_deserializeOpDocumentDeleteServerCatalogOutput(&output, shape) 939 if err != nil { 940 var snapshot bytes.Buffer 941 io.Copy(&snapshot, ringBuffer) 942 err = &smithy.DeserializationError{ 943 Err: fmt.Errorf("failed to decode response body, %w", err), 944 Snapshot: snapshot.Bytes(), 945 } 946 return out, metadata, err 947 } 948 949 return out, metadata, err 950} 951 952func awsAwsjson11_deserializeOpErrorDeleteServerCatalog(response *smithyhttp.Response, metadata *middleware.Metadata) error { 953 var errorBuffer bytes.Buffer 954 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 955 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 956 } 957 errorBody := bytes.NewReader(errorBuffer.Bytes()) 958 959 errorCode := "UnknownError" 960 errorMessage := errorCode 961 962 code := response.Header.Get("X-Amzn-ErrorType") 963 if len(code) != 0 { 964 errorCode = restjson.SanitizeErrorCode(code) 965 } 966 967 var buff [1024]byte 968 ringBuffer := smithyio.NewRingBuffer(buff[:]) 969 970 body := io.TeeReader(errorBody, ringBuffer) 971 decoder := json.NewDecoder(body) 972 decoder.UseNumber() 973 code, message, err := restjson.GetErrorInfo(decoder) 974 if err != nil { 975 var snapshot bytes.Buffer 976 io.Copy(&snapshot, ringBuffer) 977 err = &smithy.DeserializationError{ 978 Err: fmt.Errorf("failed to decode response body, %w", err), 979 Snapshot: snapshot.Bytes(), 980 } 981 return err 982 } 983 984 errorBody.Seek(0, io.SeekStart) 985 if len(code) != 0 { 986 errorCode = restjson.SanitizeErrorCode(code) 987 } 988 if len(message) != 0 { 989 errorMessage = message 990 } 991 992 switch { 993 case strings.EqualFold("InvalidParameterException", errorCode): 994 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 995 996 case strings.EqualFold("MissingRequiredParameterException", errorCode): 997 return awsAwsjson11_deserializeErrorMissingRequiredParameterException(response, errorBody) 998 999 case strings.EqualFold("OperationNotPermittedException", errorCode): 1000 return awsAwsjson11_deserializeErrorOperationNotPermittedException(response, errorBody) 1001 1002 case strings.EqualFold("UnauthorizedOperationException", errorCode): 1003 return awsAwsjson11_deserializeErrorUnauthorizedOperationException(response, errorBody) 1004 1005 default: 1006 genericError := &smithy.GenericAPIError{ 1007 Code: errorCode, 1008 Message: errorMessage, 1009 } 1010 return genericError 1011 1012 } 1013} 1014 1015type awsAwsjson11_deserializeOpDisassociateConnector struct { 1016} 1017 1018func (*awsAwsjson11_deserializeOpDisassociateConnector) ID() string { 1019 return "OperationDeserializer" 1020} 1021 1022func (m *awsAwsjson11_deserializeOpDisassociateConnector) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1023 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1024) { 1025 out, metadata, err = next.HandleDeserialize(ctx, in) 1026 if err != nil { 1027 return out, metadata, err 1028 } 1029 1030 response, ok := out.RawResponse.(*smithyhttp.Response) 1031 if !ok { 1032 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1033 } 1034 1035 if response.StatusCode < 200 || response.StatusCode >= 300 { 1036 return out, metadata, awsAwsjson11_deserializeOpErrorDisassociateConnector(response, &metadata) 1037 } 1038 output := &DisassociateConnectorOutput{} 1039 out.Result = output 1040 1041 var buff [1024]byte 1042 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1043 1044 body := io.TeeReader(response.Body, ringBuffer) 1045 decoder := json.NewDecoder(body) 1046 decoder.UseNumber() 1047 var shape interface{} 1048 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1049 var snapshot bytes.Buffer 1050 io.Copy(&snapshot, ringBuffer) 1051 err = &smithy.DeserializationError{ 1052 Err: fmt.Errorf("failed to decode response body, %w", err), 1053 Snapshot: snapshot.Bytes(), 1054 } 1055 return out, metadata, err 1056 } 1057 1058 err = awsAwsjson11_deserializeOpDocumentDisassociateConnectorOutput(&output, shape) 1059 if err != nil { 1060 var snapshot bytes.Buffer 1061 io.Copy(&snapshot, ringBuffer) 1062 err = &smithy.DeserializationError{ 1063 Err: fmt.Errorf("failed to decode response body, %w", err), 1064 Snapshot: snapshot.Bytes(), 1065 } 1066 return out, metadata, err 1067 } 1068 1069 return out, metadata, err 1070} 1071 1072func awsAwsjson11_deserializeOpErrorDisassociateConnector(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1073 var errorBuffer bytes.Buffer 1074 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1075 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1076 } 1077 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1078 1079 errorCode := "UnknownError" 1080 errorMessage := errorCode 1081 1082 code := response.Header.Get("X-Amzn-ErrorType") 1083 if len(code) != 0 { 1084 errorCode = restjson.SanitizeErrorCode(code) 1085 } 1086 1087 var buff [1024]byte 1088 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1089 1090 body := io.TeeReader(errorBody, ringBuffer) 1091 decoder := json.NewDecoder(body) 1092 decoder.UseNumber() 1093 code, message, err := restjson.GetErrorInfo(decoder) 1094 if err != nil { 1095 var snapshot bytes.Buffer 1096 io.Copy(&snapshot, ringBuffer) 1097 err = &smithy.DeserializationError{ 1098 Err: fmt.Errorf("failed to decode response body, %w", err), 1099 Snapshot: snapshot.Bytes(), 1100 } 1101 return err 1102 } 1103 1104 errorBody.Seek(0, io.SeekStart) 1105 if len(code) != 0 { 1106 errorCode = restjson.SanitizeErrorCode(code) 1107 } 1108 if len(message) != 0 { 1109 errorMessage = message 1110 } 1111 1112 switch { 1113 case strings.EqualFold("InvalidParameterException", errorCode): 1114 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 1115 1116 case strings.EqualFold("MissingRequiredParameterException", errorCode): 1117 return awsAwsjson11_deserializeErrorMissingRequiredParameterException(response, errorBody) 1118 1119 case strings.EqualFold("OperationNotPermittedException", errorCode): 1120 return awsAwsjson11_deserializeErrorOperationNotPermittedException(response, errorBody) 1121 1122 case strings.EqualFold("UnauthorizedOperationException", errorCode): 1123 return awsAwsjson11_deserializeErrorUnauthorizedOperationException(response, errorBody) 1124 1125 default: 1126 genericError := &smithy.GenericAPIError{ 1127 Code: errorCode, 1128 Message: errorMessage, 1129 } 1130 return genericError 1131 1132 } 1133} 1134 1135type awsAwsjson11_deserializeOpGenerateChangeSet struct { 1136} 1137 1138func (*awsAwsjson11_deserializeOpGenerateChangeSet) ID() string { 1139 return "OperationDeserializer" 1140} 1141 1142func (m *awsAwsjson11_deserializeOpGenerateChangeSet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1143 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1144) { 1145 out, metadata, err = next.HandleDeserialize(ctx, in) 1146 if err != nil { 1147 return out, metadata, err 1148 } 1149 1150 response, ok := out.RawResponse.(*smithyhttp.Response) 1151 if !ok { 1152 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1153 } 1154 1155 if response.StatusCode < 200 || response.StatusCode >= 300 { 1156 return out, metadata, awsAwsjson11_deserializeOpErrorGenerateChangeSet(response, &metadata) 1157 } 1158 output := &GenerateChangeSetOutput{} 1159 out.Result = output 1160 1161 var buff [1024]byte 1162 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1163 1164 body := io.TeeReader(response.Body, ringBuffer) 1165 decoder := json.NewDecoder(body) 1166 decoder.UseNumber() 1167 var shape interface{} 1168 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1169 var snapshot bytes.Buffer 1170 io.Copy(&snapshot, ringBuffer) 1171 err = &smithy.DeserializationError{ 1172 Err: fmt.Errorf("failed to decode response body, %w", err), 1173 Snapshot: snapshot.Bytes(), 1174 } 1175 return out, metadata, err 1176 } 1177 1178 err = awsAwsjson11_deserializeOpDocumentGenerateChangeSetOutput(&output, shape) 1179 if err != nil { 1180 var snapshot bytes.Buffer 1181 io.Copy(&snapshot, ringBuffer) 1182 err = &smithy.DeserializationError{ 1183 Err: fmt.Errorf("failed to decode response body, %w", err), 1184 Snapshot: snapshot.Bytes(), 1185 } 1186 return out, metadata, err 1187 } 1188 1189 return out, metadata, err 1190} 1191 1192func awsAwsjson11_deserializeOpErrorGenerateChangeSet(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1193 var errorBuffer bytes.Buffer 1194 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1195 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1196 } 1197 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1198 1199 errorCode := "UnknownError" 1200 errorMessage := errorCode 1201 1202 code := response.Header.Get("X-Amzn-ErrorType") 1203 if len(code) != 0 { 1204 errorCode = restjson.SanitizeErrorCode(code) 1205 } 1206 1207 var buff [1024]byte 1208 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1209 1210 body := io.TeeReader(errorBody, ringBuffer) 1211 decoder := json.NewDecoder(body) 1212 decoder.UseNumber() 1213 code, message, err := restjson.GetErrorInfo(decoder) 1214 if err != nil { 1215 var snapshot bytes.Buffer 1216 io.Copy(&snapshot, ringBuffer) 1217 err = &smithy.DeserializationError{ 1218 Err: fmt.Errorf("failed to decode response body, %w", err), 1219 Snapshot: snapshot.Bytes(), 1220 } 1221 return err 1222 } 1223 1224 errorBody.Seek(0, io.SeekStart) 1225 if len(code) != 0 { 1226 errorCode = restjson.SanitizeErrorCode(code) 1227 } 1228 if len(message) != 0 { 1229 errorMessage = message 1230 } 1231 1232 switch { 1233 case strings.EqualFold("InternalError", errorCode): 1234 return awsAwsjson11_deserializeErrorInternalError(response, errorBody) 1235 1236 case strings.EqualFold("InvalidParameterException", errorCode): 1237 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 1238 1239 case strings.EqualFold("MissingRequiredParameterException", errorCode): 1240 return awsAwsjson11_deserializeErrorMissingRequiredParameterException(response, errorBody) 1241 1242 case strings.EqualFold("OperationNotPermittedException", errorCode): 1243 return awsAwsjson11_deserializeErrorOperationNotPermittedException(response, errorBody) 1244 1245 case strings.EqualFold("UnauthorizedOperationException", errorCode): 1246 return awsAwsjson11_deserializeErrorUnauthorizedOperationException(response, errorBody) 1247 1248 default: 1249 genericError := &smithy.GenericAPIError{ 1250 Code: errorCode, 1251 Message: errorMessage, 1252 } 1253 return genericError 1254 1255 } 1256} 1257 1258type awsAwsjson11_deserializeOpGenerateTemplate struct { 1259} 1260 1261func (*awsAwsjson11_deserializeOpGenerateTemplate) ID() string { 1262 return "OperationDeserializer" 1263} 1264 1265func (m *awsAwsjson11_deserializeOpGenerateTemplate) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1266 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1267) { 1268 out, metadata, err = next.HandleDeserialize(ctx, in) 1269 if err != nil { 1270 return out, metadata, err 1271 } 1272 1273 response, ok := out.RawResponse.(*smithyhttp.Response) 1274 if !ok { 1275 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1276 } 1277 1278 if response.StatusCode < 200 || response.StatusCode >= 300 { 1279 return out, metadata, awsAwsjson11_deserializeOpErrorGenerateTemplate(response, &metadata) 1280 } 1281 output := &GenerateTemplateOutput{} 1282 out.Result = output 1283 1284 var buff [1024]byte 1285 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1286 1287 body := io.TeeReader(response.Body, ringBuffer) 1288 decoder := json.NewDecoder(body) 1289 decoder.UseNumber() 1290 var shape interface{} 1291 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1292 var snapshot bytes.Buffer 1293 io.Copy(&snapshot, ringBuffer) 1294 err = &smithy.DeserializationError{ 1295 Err: fmt.Errorf("failed to decode response body, %w", err), 1296 Snapshot: snapshot.Bytes(), 1297 } 1298 return out, metadata, err 1299 } 1300 1301 err = awsAwsjson11_deserializeOpDocumentGenerateTemplateOutput(&output, shape) 1302 if err != nil { 1303 var snapshot bytes.Buffer 1304 io.Copy(&snapshot, ringBuffer) 1305 err = &smithy.DeserializationError{ 1306 Err: fmt.Errorf("failed to decode response body, %w", err), 1307 Snapshot: snapshot.Bytes(), 1308 } 1309 return out, metadata, err 1310 } 1311 1312 return out, metadata, err 1313} 1314 1315func awsAwsjson11_deserializeOpErrorGenerateTemplate(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1316 var errorBuffer bytes.Buffer 1317 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1318 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1319 } 1320 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1321 1322 errorCode := "UnknownError" 1323 errorMessage := errorCode 1324 1325 code := response.Header.Get("X-Amzn-ErrorType") 1326 if len(code) != 0 { 1327 errorCode = restjson.SanitizeErrorCode(code) 1328 } 1329 1330 var buff [1024]byte 1331 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1332 1333 body := io.TeeReader(errorBody, ringBuffer) 1334 decoder := json.NewDecoder(body) 1335 decoder.UseNumber() 1336 code, message, err := restjson.GetErrorInfo(decoder) 1337 if err != nil { 1338 var snapshot bytes.Buffer 1339 io.Copy(&snapshot, ringBuffer) 1340 err = &smithy.DeserializationError{ 1341 Err: fmt.Errorf("failed to decode response body, %w", err), 1342 Snapshot: snapshot.Bytes(), 1343 } 1344 return err 1345 } 1346 1347 errorBody.Seek(0, io.SeekStart) 1348 if len(code) != 0 { 1349 errorCode = restjson.SanitizeErrorCode(code) 1350 } 1351 if len(message) != 0 { 1352 errorMessage = message 1353 } 1354 1355 switch { 1356 case strings.EqualFold("InternalError", errorCode): 1357 return awsAwsjson11_deserializeErrorInternalError(response, errorBody) 1358 1359 case strings.EqualFold("InvalidParameterException", errorCode): 1360 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 1361 1362 case strings.EqualFold("MissingRequiredParameterException", errorCode): 1363 return awsAwsjson11_deserializeErrorMissingRequiredParameterException(response, errorBody) 1364 1365 case strings.EqualFold("OperationNotPermittedException", errorCode): 1366 return awsAwsjson11_deserializeErrorOperationNotPermittedException(response, errorBody) 1367 1368 case strings.EqualFold("UnauthorizedOperationException", errorCode): 1369 return awsAwsjson11_deserializeErrorUnauthorizedOperationException(response, errorBody) 1370 1371 default: 1372 genericError := &smithy.GenericAPIError{ 1373 Code: errorCode, 1374 Message: errorMessage, 1375 } 1376 return genericError 1377 1378 } 1379} 1380 1381type awsAwsjson11_deserializeOpGetApp struct { 1382} 1383 1384func (*awsAwsjson11_deserializeOpGetApp) ID() string { 1385 return "OperationDeserializer" 1386} 1387 1388func (m *awsAwsjson11_deserializeOpGetApp) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1389 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1390) { 1391 out, metadata, err = next.HandleDeserialize(ctx, in) 1392 if err != nil { 1393 return out, metadata, err 1394 } 1395 1396 response, ok := out.RawResponse.(*smithyhttp.Response) 1397 if !ok { 1398 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1399 } 1400 1401 if response.StatusCode < 200 || response.StatusCode >= 300 { 1402 return out, metadata, awsAwsjson11_deserializeOpErrorGetApp(response, &metadata) 1403 } 1404 output := &GetAppOutput{} 1405 out.Result = output 1406 1407 var buff [1024]byte 1408 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1409 1410 body := io.TeeReader(response.Body, ringBuffer) 1411 decoder := json.NewDecoder(body) 1412 decoder.UseNumber() 1413 var shape interface{} 1414 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1415 var snapshot bytes.Buffer 1416 io.Copy(&snapshot, ringBuffer) 1417 err = &smithy.DeserializationError{ 1418 Err: fmt.Errorf("failed to decode response body, %w", err), 1419 Snapshot: snapshot.Bytes(), 1420 } 1421 return out, metadata, err 1422 } 1423 1424 err = awsAwsjson11_deserializeOpDocumentGetAppOutput(&output, shape) 1425 if err != nil { 1426 var snapshot bytes.Buffer 1427 io.Copy(&snapshot, ringBuffer) 1428 err = &smithy.DeserializationError{ 1429 Err: fmt.Errorf("failed to decode response body, %w", err), 1430 Snapshot: snapshot.Bytes(), 1431 } 1432 return out, metadata, err 1433 } 1434 1435 return out, metadata, err 1436} 1437 1438func awsAwsjson11_deserializeOpErrorGetApp(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1439 var errorBuffer bytes.Buffer 1440 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1441 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1442 } 1443 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1444 1445 errorCode := "UnknownError" 1446 errorMessage := errorCode 1447 1448 code := response.Header.Get("X-Amzn-ErrorType") 1449 if len(code) != 0 { 1450 errorCode = restjson.SanitizeErrorCode(code) 1451 } 1452 1453 var buff [1024]byte 1454 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1455 1456 body := io.TeeReader(errorBody, ringBuffer) 1457 decoder := json.NewDecoder(body) 1458 decoder.UseNumber() 1459 code, message, err := restjson.GetErrorInfo(decoder) 1460 if err != nil { 1461 var snapshot bytes.Buffer 1462 io.Copy(&snapshot, ringBuffer) 1463 err = &smithy.DeserializationError{ 1464 Err: fmt.Errorf("failed to decode response body, %w", err), 1465 Snapshot: snapshot.Bytes(), 1466 } 1467 return err 1468 } 1469 1470 errorBody.Seek(0, io.SeekStart) 1471 if len(code) != 0 { 1472 errorCode = restjson.SanitizeErrorCode(code) 1473 } 1474 if len(message) != 0 { 1475 errorMessage = message 1476 } 1477 1478 switch { 1479 case strings.EqualFold("InternalError", errorCode): 1480 return awsAwsjson11_deserializeErrorInternalError(response, errorBody) 1481 1482 case strings.EqualFold("InvalidParameterException", errorCode): 1483 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 1484 1485 case strings.EqualFold("MissingRequiredParameterException", errorCode): 1486 return awsAwsjson11_deserializeErrorMissingRequiredParameterException(response, errorBody) 1487 1488 case strings.EqualFold("OperationNotPermittedException", errorCode): 1489 return awsAwsjson11_deserializeErrorOperationNotPermittedException(response, errorBody) 1490 1491 case strings.EqualFold("UnauthorizedOperationException", errorCode): 1492 return awsAwsjson11_deserializeErrorUnauthorizedOperationException(response, errorBody) 1493 1494 default: 1495 genericError := &smithy.GenericAPIError{ 1496 Code: errorCode, 1497 Message: errorMessage, 1498 } 1499 return genericError 1500 1501 } 1502} 1503 1504type awsAwsjson11_deserializeOpGetAppLaunchConfiguration struct { 1505} 1506 1507func (*awsAwsjson11_deserializeOpGetAppLaunchConfiguration) ID() string { 1508 return "OperationDeserializer" 1509} 1510 1511func (m *awsAwsjson11_deserializeOpGetAppLaunchConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1512 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1513) { 1514 out, metadata, err = next.HandleDeserialize(ctx, in) 1515 if err != nil { 1516 return out, metadata, err 1517 } 1518 1519 response, ok := out.RawResponse.(*smithyhttp.Response) 1520 if !ok { 1521 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1522 } 1523 1524 if response.StatusCode < 200 || response.StatusCode >= 300 { 1525 return out, metadata, awsAwsjson11_deserializeOpErrorGetAppLaunchConfiguration(response, &metadata) 1526 } 1527 output := &GetAppLaunchConfigurationOutput{} 1528 out.Result = output 1529 1530 var buff [1024]byte 1531 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1532 1533 body := io.TeeReader(response.Body, ringBuffer) 1534 decoder := json.NewDecoder(body) 1535 decoder.UseNumber() 1536 var shape interface{} 1537 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1538 var snapshot bytes.Buffer 1539 io.Copy(&snapshot, ringBuffer) 1540 err = &smithy.DeserializationError{ 1541 Err: fmt.Errorf("failed to decode response body, %w", err), 1542 Snapshot: snapshot.Bytes(), 1543 } 1544 return out, metadata, err 1545 } 1546 1547 err = awsAwsjson11_deserializeOpDocumentGetAppLaunchConfigurationOutput(&output, shape) 1548 if err != nil { 1549 var snapshot bytes.Buffer 1550 io.Copy(&snapshot, ringBuffer) 1551 err = &smithy.DeserializationError{ 1552 Err: fmt.Errorf("failed to decode response body, %w", err), 1553 Snapshot: snapshot.Bytes(), 1554 } 1555 return out, metadata, err 1556 } 1557 1558 return out, metadata, err 1559} 1560 1561func awsAwsjson11_deserializeOpErrorGetAppLaunchConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1562 var errorBuffer bytes.Buffer 1563 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1564 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1565 } 1566 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1567 1568 errorCode := "UnknownError" 1569 errorMessage := errorCode 1570 1571 code := response.Header.Get("X-Amzn-ErrorType") 1572 if len(code) != 0 { 1573 errorCode = restjson.SanitizeErrorCode(code) 1574 } 1575 1576 var buff [1024]byte 1577 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1578 1579 body := io.TeeReader(errorBody, ringBuffer) 1580 decoder := json.NewDecoder(body) 1581 decoder.UseNumber() 1582 code, message, err := restjson.GetErrorInfo(decoder) 1583 if err != nil { 1584 var snapshot bytes.Buffer 1585 io.Copy(&snapshot, ringBuffer) 1586 err = &smithy.DeserializationError{ 1587 Err: fmt.Errorf("failed to decode response body, %w", err), 1588 Snapshot: snapshot.Bytes(), 1589 } 1590 return err 1591 } 1592 1593 errorBody.Seek(0, io.SeekStart) 1594 if len(code) != 0 { 1595 errorCode = restjson.SanitizeErrorCode(code) 1596 } 1597 if len(message) != 0 { 1598 errorMessage = message 1599 } 1600 1601 switch { 1602 case strings.EqualFold("InternalError", errorCode): 1603 return awsAwsjson11_deserializeErrorInternalError(response, errorBody) 1604 1605 case strings.EqualFold("InvalidParameterException", errorCode): 1606 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 1607 1608 case strings.EqualFold("MissingRequiredParameterException", errorCode): 1609 return awsAwsjson11_deserializeErrorMissingRequiredParameterException(response, errorBody) 1610 1611 case strings.EqualFold("OperationNotPermittedException", errorCode): 1612 return awsAwsjson11_deserializeErrorOperationNotPermittedException(response, errorBody) 1613 1614 case strings.EqualFold("UnauthorizedOperationException", errorCode): 1615 return awsAwsjson11_deserializeErrorUnauthorizedOperationException(response, errorBody) 1616 1617 default: 1618 genericError := &smithy.GenericAPIError{ 1619 Code: errorCode, 1620 Message: errorMessage, 1621 } 1622 return genericError 1623 1624 } 1625} 1626 1627type awsAwsjson11_deserializeOpGetAppReplicationConfiguration struct { 1628} 1629 1630func (*awsAwsjson11_deserializeOpGetAppReplicationConfiguration) ID() string { 1631 return "OperationDeserializer" 1632} 1633 1634func (m *awsAwsjson11_deserializeOpGetAppReplicationConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1635 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1636) { 1637 out, metadata, err = next.HandleDeserialize(ctx, in) 1638 if err != nil { 1639 return out, metadata, err 1640 } 1641 1642 response, ok := out.RawResponse.(*smithyhttp.Response) 1643 if !ok { 1644 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1645 } 1646 1647 if response.StatusCode < 200 || response.StatusCode >= 300 { 1648 return out, metadata, awsAwsjson11_deserializeOpErrorGetAppReplicationConfiguration(response, &metadata) 1649 } 1650 output := &GetAppReplicationConfigurationOutput{} 1651 out.Result = output 1652 1653 var buff [1024]byte 1654 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1655 1656 body := io.TeeReader(response.Body, ringBuffer) 1657 decoder := json.NewDecoder(body) 1658 decoder.UseNumber() 1659 var shape interface{} 1660 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1661 var snapshot bytes.Buffer 1662 io.Copy(&snapshot, ringBuffer) 1663 err = &smithy.DeserializationError{ 1664 Err: fmt.Errorf("failed to decode response body, %w", err), 1665 Snapshot: snapshot.Bytes(), 1666 } 1667 return out, metadata, err 1668 } 1669 1670 err = awsAwsjson11_deserializeOpDocumentGetAppReplicationConfigurationOutput(&output, shape) 1671 if err != nil { 1672 var snapshot bytes.Buffer 1673 io.Copy(&snapshot, ringBuffer) 1674 err = &smithy.DeserializationError{ 1675 Err: fmt.Errorf("failed to decode response body, %w", err), 1676 Snapshot: snapshot.Bytes(), 1677 } 1678 return out, metadata, err 1679 } 1680 1681 return out, metadata, err 1682} 1683 1684func awsAwsjson11_deserializeOpErrorGetAppReplicationConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1685 var errorBuffer bytes.Buffer 1686 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1687 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1688 } 1689 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1690 1691 errorCode := "UnknownError" 1692 errorMessage := errorCode 1693 1694 code := response.Header.Get("X-Amzn-ErrorType") 1695 if len(code) != 0 { 1696 errorCode = restjson.SanitizeErrorCode(code) 1697 } 1698 1699 var buff [1024]byte 1700 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1701 1702 body := io.TeeReader(errorBody, ringBuffer) 1703 decoder := json.NewDecoder(body) 1704 decoder.UseNumber() 1705 code, message, err := restjson.GetErrorInfo(decoder) 1706 if err != nil { 1707 var snapshot bytes.Buffer 1708 io.Copy(&snapshot, ringBuffer) 1709 err = &smithy.DeserializationError{ 1710 Err: fmt.Errorf("failed to decode response body, %w", err), 1711 Snapshot: snapshot.Bytes(), 1712 } 1713 return err 1714 } 1715 1716 errorBody.Seek(0, io.SeekStart) 1717 if len(code) != 0 { 1718 errorCode = restjson.SanitizeErrorCode(code) 1719 } 1720 if len(message) != 0 { 1721 errorMessage = message 1722 } 1723 1724 switch { 1725 case strings.EqualFold("InternalError", errorCode): 1726 return awsAwsjson11_deserializeErrorInternalError(response, errorBody) 1727 1728 case strings.EqualFold("InvalidParameterException", errorCode): 1729 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 1730 1731 case strings.EqualFold("MissingRequiredParameterException", errorCode): 1732 return awsAwsjson11_deserializeErrorMissingRequiredParameterException(response, errorBody) 1733 1734 case strings.EqualFold("OperationNotPermittedException", errorCode): 1735 return awsAwsjson11_deserializeErrorOperationNotPermittedException(response, errorBody) 1736 1737 case strings.EqualFold("UnauthorizedOperationException", errorCode): 1738 return awsAwsjson11_deserializeErrorUnauthorizedOperationException(response, errorBody) 1739 1740 default: 1741 genericError := &smithy.GenericAPIError{ 1742 Code: errorCode, 1743 Message: errorMessage, 1744 } 1745 return genericError 1746 1747 } 1748} 1749 1750type awsAwsjson11_deserializeOpGetAppValidationConfiguration struct { 1751} 1752 1753func (*awsAwsjson11_deserializeOpGetAppValidationConfiguration) ID() string { 1754 return "OperationDeserializer" 1755} 1756 1757func (m *awsAwsjson11_deserializeOpGetAppValidationConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1758 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1759) { 1760 out, metadata, err = next.HandleDeserialize(ctx, in) 1761 if err != nil { 1762 return out, metadata, err 1763 } 1764 1765 response, ok := out.RawResponse.(*smithyhttp.Response) 1766 if !ok { 1767 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1768 } 1769 1770 if response.StatusCode < 200 || response.StatusCode >= 300 { 1771 return out, metadata, awsAwsjson11_deserializeOpErrorGetAppValidationConfiguration(response, &metadata) 1772 } 1773 output := &GetAppValidationConfigurationOutput{} 1774 out.Result = output 1775 1776 var buff [1024]byte 1777 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1778 1779 body := io.TeeReader(response.Body, ringBuffer) 1780 decoder := json.NewDecoder(body) 1781 decoder.UseNumber() 1782 var shape interface{} 1783 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1784 var snapshot bytes.Buffer 1785 io.Copy(&snapshot, ringBuffer) 1786 err = &smithy.DeserializationError{ 1787 Err: fmt.Errorf("failed to decode response body, %w", err), 1788 Snapshot: snapshot.Bytes(), 1789 } 1790 return out, metadata, err 1791 } 1792 1793 err = awsAwsjson11_deserializeOpDocumentGetAppValidationConfigurationOutput(&output, shape) 1794 if err != nil { 1795 var snapshot bytes.Buffer 1796 io.Copy(&snapshot, ringBuffer) 1797 err = &smithy.DeserializationError{ 1798 Err: fmt.Errorf("failed to decode response body, %w", err), 1799 Snapshot: snapshot.Bytes(), 1800 } 1801 return out, metadata, err 1802 } 1803 1804 return out, metadata, err 1805} 1806 1807func awsAwsjson11_deserializeOpErrorGetAppValidationConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1808 var errorBuffer bytes.Buffer 1809 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1810 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1811 } 1812 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1813 1814 errorCode := "UnknownError" 1815 errorMessage := errorCode 1816 1817 code := response.Header.Get("X-Amzn-ErrorType") 1818 if len(code) != 0 { 1819 errorCode = restjson.SanitizeErrorCode(code) 1820 } 1821 1822 var buff [1024]byte 1823 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1824 1825 body := io.TeeReader(errorBody, ringBuffer) 1826 decoder := json.NewDecoder(body) 1827 decoder.UseNumber() 1828 code, message, err := restjson.GetErrorInfo(decoder) 1829 if err != nil { 1830 var snapshot bytes.Buffer 1831 io.Copy(&snapshot, ringBuffer) 1832 err = &smithy.DeserializationError{ 1833 Err: fmt.Errorf("failed to decode response body, %w", err), 1834 Snapshot: snapshot.Bytes(), 1835 } 1836 return err 1837 } 1838 1839 errorBody.Seek(0, io.SeekStart) 1840 if len(code) != 0 { 1841 errorCode = restjson.SanitizeErrorCode(code) 1842 } 1843 if len(message) != 0 { 1844 errorMessage = message 1845 } 1846 1847 switch { 1848 case strings.EqualFold("InternalError", errorCode): 1849 return awsAwsjson11_deserializeErrorInternalError(response, errorBody) 1850 1851 case strings.EqualFold("InvalidParameterException", errorCode): 1852 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 1853 1854 case strings.EqualFold("MissingRequiredParameterException", errorCode): 1855 return awsAwsjson11_deserializeErrorMissingRequiredParameterException(response, errorBody) 1856 1857 case strings.EqualFold("OperationNotPermittedException", errorCode): 1858 return awsAwsjson11_deserializeErrorOperationNotPermittedException(response, errorBody) 1859 1860 case strings.EqualFold("UnauthorizedOperationException", errorCode): 1861 return awsAwsjson11_deserializeErrorUnauthorizedOperationException(response, errorBody) 1862 1863 default: 1864 genericError := &smithy.GenericAPIError{ 1865 Code: errorCode, 1866 Message: errorMessage, 1867 } 1868 return genericError 1869 1870 } 1871} 1872 1873type awsAwsjson11_deserializeOpGetAppValidationOutput struct { 1874} 1875 1876func (*awsAwsjson11_deserializeOpGetAppValidationOutput) ID() string { 1877 return "OperationDeserializer" 1878} 1879 1880func (m *awsAwsjson11_deserializeOpGetAppValidationOutput) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1881 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1882) { 1883 out, metadata, err = next.HandleDeserialize(ctx, in) 1884 if err != nil { 1885 return out, metadata, err 1886 } 1887 1888 response, ok := out.RawResponse.(*smithyhttp.Response) 1889 if !ok { 1890 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1891 } 1892 1893 if response.StatusCode < 200 || response.StatusCode >= 300 { 1894 return out, metadata, awsAwsjson11_deserializeOpErrorGetAppValidationOutput(response, &metadata) 1895 } 1896 output := &GetAppValidationOutputOutput{} 1897 out.Result = output 1898 1899 var buff [1024]byte 1900 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1901 1902 body := io.TeeReader(response.Body, ringBuffer) 1903 decoder := json.NewDecoder(body) 1904 decoder.UseNumber() 1905 var shape interface{} 1906 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1907 var snapshot bytes.Buffer 1908 io.Copy(&snapshot, ringBuffer) 1909 err = &smithy.DeserializationError{ 1910 Err: fmt.Errorf("failed to decode response body, %w", err), 1911 Snapshot: snapshot.Bytes(), 1912 } 1913 return out, metadata, err 1914 } 1915 1916 err = awsAwsjson11_deserializeOpDocumentGetAppValidationOutputOutput(&output, shape) 1917 if err != nil { 1918 var snapshot bytes.Buffer 1919 io.Copy(&snapshot, ringBuffer) 1920 err = &smithy.DeserializationError{ 1921 Err: fmt.Errorf("failed to decode response body, %w", err), 1922 Snapshot: snapshot.Bytes(), 1923 } 1924 return out, metadata, err 1925 } 1926 1927 return out, metadata, err 1928} 1929 1930func awsAwsjson11_deserializeOpErrorGetAppValidationOutput(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1931 var errorBuffer bytes.Buffer 1932 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1933 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1934 } 1935 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1936 1937 errorCode := "UnknownError" 1938 errorMessage := errorCode 1939 1940 code := response.Header.Get("X-Amzn-ErrorType") 1941 if len(code) != 0 { 1942 errorCode = restjson.SanitizeErrorCode(code) 1943 } 1944 1945 var buff [1024]byte 1946 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1947 1948 body := io.TeeReader(errorBody, ringBuffer) 1949 decoder := json.NewDecoder(body) 1950 decoder.UseNumber() 1951 code, message, err := restjson.GetErrorInfo(decoder) 1952 if err != nil { 1953 var snapshot bytes.Buffer 1954 io.Copy(&snapshot, ringBuffer) 1955 err = &smithy.DeserializationError{ 1956 Err: fmt.Errorf("failed to decode response body, %w", err), 1957 Snapshot: snapshot.Bytes(), 1958 } 1959 return err 1960 } 1961 1962 errorBody.Seek(0, io.SeekStart) 1963 if len(code) != 0 { 1964 errorCode = restjson.SanitizeErrorCode(code) 1965 } 1966 if len(message) != 0 { 1967 errorMessage = message 1968 } 1969 1970 switch { 1971 case strings.EqualFold("InternalError", errorCode): 1972 return awsAwsjson11_deserializeErrorInternalError(response, errorBody) 1973 1974 case strings.EqualFold("InvalidParameterException", errorCode): 1975 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 1976 1977 case strings.EqualFold("MissingRequiredParameterException", errorCode): 1978 return awsAwsjson11_deserializeErrorMissingRequiredParameterException(response, errorBody) 1979 1980 case strings.EqualFold("OperationNotPermittedException", errorCode): 1981 return awsAwsjson11_deserializeErrorOperationNotPermittedException(response, errorBody) 1982 1983 case strings.EqualFold("UnauthorizedOperationException", errorCode): 1984 return awsAwsjson11_deserializeErrorUnauthorizedOperationException(response, errorBody) 1985 1986 default: 1987 genericError := &smithy.GenericAPIError{ 1988 Code: errorCode, 1989 Message: errorMessage, 1990 } 1991 return genericError 1992 1993 } 1994} 1995 1996type awsAwsjson11_deserializeOpGetConnectors struct { 1997} 1998 1999func (*awsAwsjson11_deserializeOpGetConnectors) ID() string { 2000 return "OperationDeserializer" 2001} 2002 2003func (m *awsAwsjson11_deserializeOpGetConnectors) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2004 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2005) { 2006 out, metadata, err = next.HandleDeserialize(ctx, in) 2007 if err != nil { 2008 return out, metadata, err 2009 } 2010 2011 response, ok := out.RawResponse.(*smithyhttp.Response) 2012 if !ok { 2013 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2014 } 2015 2016 if response.StatusCode < 200 || response.StatusCode >= 300 { 2017 return out, metadata, awsAwsjson11_deserializeOpErrorGetConnectors(response, &metadata) 2018 } 2019 output := &GetConnectorsOutput{} 2020 out.Result = output 2021 2022 var buff [1024]byte 2023 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2024 2025 body := io.TeeReader(response.Body, ringBuffer) 2026 decoder := json.NewDecoder(body) 2027 decoder.UseNumber() 2028 var shape interface{} 2029 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2030 var snapshot bytes.Buffer 2031 io.Copy(&snapshot, ringBuffer) 2032 err = &smithy.DeserializationError{ 2033 Err: fmt.Errorf("failed to decode response body, %w", err), 2034 Snapshot: snapshot.Bytes(), 2035 } 2036 return out, metadata, err 2037 } 2038 2039 err = awsAwsjson11_deserializeOpDocumentGetConnectorsOutput(&output, shape) 2040 if err != nil { 2041 var snapshot bytes.Buffer 2042 io.Copy(&snapshot, ringBuffer) 2043 err = &smithy.DeserializationError{ 2044 Err: fmt.Errorf("failed to decode response body, %w", err), 2045 Snapshot: snapshot.Bytes(), 2046 } 2047 return out, metadata, err 2048 } 2049 2050 return out, metadata, err 2051} 2052 2053func awsAwsjson11_deserializeOpErrorGetConnectors(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2054 var errorBuffer bytes.Buffer 2055 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2056 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2057 } 2058 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2059 2060 errorCode := "UnknownError" 2061 errorMessage := errorCode 2062 2063 code := response.Header.Get("X-Amzn-ErrorType") 2064 if len(code) != 0 { 2065 errorCode = restjson.SanitizeErrorCode(code) 2066 } 2067 2068 var buff [1024]byte 2069 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2070 2071 body := io.TeeReader(errorBody, ringBuffer) 2072 decoder := json.NewDecoder(body) 2073 decoder.UseNumber() 2074 code, message, err := restjson.GetErrorInfo(decoder) 2075 if err != nil { 2076 var snapshot bytes.Buffer 2077 io.Copy(&snapshot, ringBuffer) 2078 err = &smithy.DeserializationError{ 2079 Err: fmt.Errorf("failed to decode response body, %w", err), 2080 Snapshot: snapshot.Bytes(), 2081 } 2082 return err 2083 } 2084 2085 errorBody.Seek(0, io.SeekStart) 2086 if len(code) != 0 { 2087 errorCode = restjson.SanitizeErrorCode(code) 2088 } 2089 if len(message) != 0 { 2090 errorMessage = message 2091 } 2092 2093 switch { 2094 case strings.EqualFold("UnauthorizedOperationException", errorCode): 2095 return awsAwsjson11_deserializeErrorUnauthorizedOperationException(response, errorBody) 2096 2097 default: 2098 genericError := &smithy.GenericAPIError{ 2099 Code: errorCode, 2100 Message: errorMessage, 2101 } 2102 return genericError 2103 2104 } 2105} 2106 2107type awsAwsjson11_deserializeOpGetReplicationJobs struct { 2108} 2109 2110func (*awsAwsjson11_deserializeOpGetReplicationJobs) ID() string { 2111 return "OperationDeserializer" 2112} 2113 2114func (m *awsAwsjson11_deserializeOpGetReplicationJobs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2115 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2116) { 2117 out, metadata, err = next.HandleDeserialize(ctx, in) 2118 if err != nil { 2119 return out, metadata, err 2120 } 2121 2122 response, ok := out.RawResponse.(*smithyhttp.Response) 2123 if !ok { 2124 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2125 } 2126 2127 if response.StatusCode < 200 || response.StatusCode >= 300 { 2128 return out, metadata, awsAwsjson11_deserializeOpErrorGetReplicationJobs(response, &metadata) 2129 } 2130 output := &GetReplicationJobsOutput{} 2131 out.Result = output 2132 2133 var buff [1024]byte 2134 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2135 2136 body := io.TeeReader(response.Body, ringBuffer) 2137 decoder := json.NewDecoder(body) 2138 decoder.UseNumber() 2139 var shape interface{} 2140 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2141 var snapshot bytes.Buffer 2142 io.Copy(&snapshot, ringBuffer) 2143 err = &smithy.DeserializationError{ 2144 Err: fmt.Errorf("failed to decode response body, %w", err), 2145 Snapshot: snapshot.Bytes(), 2146 } 2147 return out, metadata, err 2148 } 2149 2150 err = awsAwsjson11_deserializeOpDocumentGetReplicationJobsOutput(&output, shape) 2151 if err != nil { 2152 var snapshot bytes.Buffer 2153 io.Copy(&snapshot, ringBuffer) 2154 err = &smithy.DeserializationError{ 2155 Err: fmt.Errorf("failed to decode response body, %w", err), 2156 Snapshot: snapshot.Bytes(), 2157 } 2158 return out, metadata, err 2159 } 2160 2161 return out, metadata, err 2162} 2163 2164func awsAwsjson11_deserializeOpErrorGetReplicationJobs(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2165 var errorBuffer bytes.Buffer 2166 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2167 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2168 } 2169 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2170 2171 errorCode := "UnknownError" 2172 errorMessage := errorCode 2173 2174 code := response.Header.Get("X-Amzn-ErrorType") 2175 if len(code) != 0 { 2176 errorCode = restjson.SanitizeErrorCode(code) 2177 } 2178 2179 var buff [1024]byte 2180 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2181 2182 body := io.TeeReader(errorBody, ringBuffer) 2183 decoder := json.NewDecoder(body) 2184 decoder.UseNumber() 2185 code, message, err := restjson.GetErrorInfo(decoder) 2186 if err != nil { 2187 var snapshot bytes.Buffer 2188 io.Copy(&snapshot, ringBuffer) 2189 err = &smithy.DeserializationError{ 2190 Err: fmt.Errorf("failed to decode response body, %w", err), 2191 Snapshot: snapshot.Bytes(), 2192 } 2193 return err 2194 } 2195 2196 errorBody.Seek(0, io.SeekStart) 2197 if len(code) != 0 { 2198 errorCode = restjson.SanitizeErrorCode(code) 2199 } 2200 if len(message) != 0 { 2201 errorMessage = message 2202 } 2203 2204 switch { 2205 case strings.EqualFold("InvalidParameterException", errorCode): 2206 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 2207 2208 case strings.EqualFold("MissingRequiredParameterException", errorCode): 2209 return awsAwsjson11_deserializeErrorMissingRequiredParameterException(response, errorBody) 2210 2211 case strings.EqualFold("UnauthorizedOperationException", errorCode): 2212 return awsAwsjson11_deserializeErrorUnauthorizedOperationException(response, errorBody) 2213 2214 default: 2215 genericError := &smithy.GenericAPIError{ 2216 Code: errorCode, 2217 Message: errorMessage, 2218 } 2219 return genericError 2220 2221 } 2222} 2223 2224type awsAwsjson11_deserializeOpGetReplicationRuns struct { 2225} 2226 2227func (*awsAwsjson11_deserializeOpGetReplicationRuns) ID() string { 2228 return "OperationDeserializer" 2229} 2230 2231func (m *awsAwsjson11_deserializeOpGetReplicationRuns) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2232 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2233) { 2234 out, metadata, err = next.HandleDeserialize(ctx, in) 2235 if err != nil { 2236 return out, metadata, err 2237 } 2238 2239 response, ok := out.RawResponse.(*smithyhttp.Response) 2240 if !ok { 2241 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2242 } 2243 2244 if response.StatusCode < 200 || response.StatusCode >= 300 { 2245 return out, metadata, awsAwsjson11_deserializeOpErrorGetReplicationRuns(response, &metadata) 2246 } 2247 output := &GetReplicationRunsOutput{} 2248 out.Result = output 2249 2250 var buff [1024]byte 2251 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2252 2253 body := io.TeeReader(response.Body, ringBuffer) 2254 decoder := json.NewDecoder(body) 2255 decoder.UseNumber() 2256 var shape interface{} 2257 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2258 var snapshot bytes.Buffer 2259 io.Copy(&snapshot, ringBuffer) 2260 err = &smithy.DeserializationError{ 2261 Err: fmt.Errorf("failed to decode response body, %w", err), 2262 Snapshot: snapshot.Bytes(), 2263 } 2264 return out, metadata, err 2265 } 2266 2267 err = awsAwsjson11_deserializeOpDocumentGetReplicationRunsOutput(&output, shape) 2268 if err != nil { 2269 var snapshot bytes.Buffer 2270 io.Copy(&snapshot, ringBuffer) 2271 err = &smithy.DeserializationError{ 2272 Err: fmt.Errorf("failed to decode response body, %w", err), 2273 Snapshot: snapshot.Bytes(), 2274 } 2275 return out, metadata, err 2276 } 2277 2278 return out, metadata, err 2279} 2280 2281func awsAwsjson11_deserializeOpErrorGetReplicationRuns(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2282 var errorBuffer bytes.Buffer 2283 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2284 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2285 } 2286 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2287 2288 errorCode := "UnknownError" 2289 errorMessage := errorCode 2290 2291 code := response.Header.Get("X-Amzn-ErrorType") 2292 if len(code) != 0 { 2293 errorCode = restjson.SanitizeErrorCode(code) 2294 } 2295 2296 var buff [1024]byte 2297 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2298 2299 body := io.TeeReader(errorBody, ringBuffer) 2300 decoder := json.NewDecoder(body) 2301 decoder.UseNumber() 2302 code, message, err := restjson.GetErrorInfo(decoder) 2303 if err != nil { 2304 var snapshot bytes.Buffer 2305 io.Copy(&snapshot, ringBuffer) 2306 err = &smithy.DeserializationError{ 2307 Err: fmt.Errorf("failed to decode response body, %w", err), 2308 Snapshot: snapshot.Bytes(), 2309 } 2310 return err 2311 } 2312 2313 errorBody.Seek(0, io.SeekStart) 2314 if len(code) != 0 { 2315 errorCode = restjson.SanitizeErrorCode(code) 2316 } 2317 if len(message) != 0 { 2318 errorMessage = message 2319 } 2320 2321 switch { 2322 case strings.EqualFold("InvalidParameterException", errorCode): 2323 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 2324 2325 case strings.EqualFold("MissingRequiredParameterException", errorCode): 2326 return awsAwsjson11_deserializeErrorMissingRequiredParameterException(response, errorBody) 2327 2328 case strings.EqualFold("UnauthorizedOperationException", errorCode): 2329 return awsAwsjson11_deserializeErrorUnauthorizedOperationException(response, errorBody) 2330 2331 default: 2332 genericError := &smithy.GenericAPIError{ 2333 Code: errorCode, 2334 Message: errorMessage, 2335 } 2336 return genericError 2337 2338 } 2339} 2340 2341type awsAwsjson11_deserializeOpGetServers struct { 2342} 2343 2344func (*awsAwsjson11_deserializeOpGetServers) ID() string { 2345 return "OperationDeserializer" 2346} 2347 2348func (m *awsAwsjson11_deserializeOpGetServers) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2349 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2350) { 2351 out, metadata, err = next.HandleDeserialize(ctx, in) 2352 if err != nil { 2353 return out, metadata, err 2354 } 2355 2356 response, ok := out.RawResponse.(*smithyhttp.Response) 2357 if !ok { 2358 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2359 } 2360 2361 if response.StatusCode < 200 || response.StatusCode >= 300 { 2362 return out, metadata, awsAwsjson11_deserializeOpErrorGetServers(response, &metadata) 2363 } 2364 output := &GetServersOutput{} 2365 out.Result = output 2366 2367 var buff [1024]byte 2368 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2369 2370 body := io.TeeReader(response.Body, ringBuffer) 2371 decoder := json.NewDecoder(body) 2372 decoder.UseNumber() 2373 var shape interface{} 2374 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2375 var snapshot bytes.Buffer 2376 io.Copy(&snapshot, ringBuffer) 2377 err = &smithy.DeserializationError{ 2378 Err: fmt.Errorf("failed to decode response body, %w", err), 2379 Snapshot: snapshot.Bytes(), 2380 } 2381 return out, metadata, err 2382 } 2383 2384 err = awsAwsjson11_deserializeOpDocumentGetServersOutput(&output, shape) 2385 if err != nil { 2386 var snapshot bytes.Buffer 2387 io.Copy(&snapshot, ringBuffer) 2388 err = &smithy.DeserializationError{ 2389 Err: fmt.Errorf("failed to decode response body, %w", err), 2390 Snapshot: snapshot.Bytes(), 2391 } 2392 return out, metadata, err 2393 } 2394 2395 return out, metadata, err 2396} 2397 2398func awsAwsjson11_deserializeOpErrorGetServers(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2399 var errorBuffer bytes.Buffer 2400 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2401 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2402 } 2403 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2404 2405 errorCode := "UnknownError" 2406 errorMessage := errorCode 2407 2408 code := response.Header.Get("X-Amzn-ErrorType") 2409 if len(code) != 0 { 2410 errorCode = restjson.SanitizeErrorCode(code) 2411 } 2412 2413 var buff [1024]byte 2414 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2415 2416 body := io.TeeReader(errorBody, ringBuffer) 2417 decoder := json.NewDecoder(body) 2418 decoder.UseNumber() 2419 code, message, err := restjson.GetErrorInfo(decoder) 2420 if err != nil { 2421 var snapshot bytes.Buffer 2422 io.Copy(&snapshot, ringBuffer) 2423 err = &smithy.DeserializationError{ 2424 Err: fmt.Errorf("failed to decode response body, %w", err), 2425 Snapshot: snapshot.Bytes(), 2426 } 2427 return err 2428 } 2429 2430 errorBody.Seek(0, io.SeekStart) 2431 if len(code) != 0 { 2432 errorCode = restjson.SanitizeErrorCode(code) 2433 } 2434 if len(message) != 0 { 2435 errorMessage = message 2436 } 2437 2438 switch { 2439 case strings.EqualFold("InternalError", errorCode): 2440 return awsAwsjson11_deserializeErrorInternalError(response, errorBody) 2441 2442 case strings.EqualFold("InvalidParameterException", errorCode): 2443 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 2444 2445 case strings.EqualFold("MissingRequiredParameterException", errorCode): 2446 return awsAwsjson11_deserializeErrorMissingRequiredParameterException(response, errorBody) 2447 2448 case strings.EqualFold("UnauthorizedOperationException", errorCode): 2449 return awsAwsjson11_deserializeErrorUnauthorizedOperationException(response, errorBody) 2450 2451 default: 2452 genericError := &smithy.GenericAPIError{ 2453 Code: errorCode, 2454 Message: errorMessage, 2455 } 2456 return genericError 2457 2458 } 2459} 2460 2461type awsAwsjson11_deserializeOpImportAppCatalog struct { 2462} 2463 2464func (*awsAwsjson11_deserializeOpImportAppCatalog) ID() string { 2465 return "OperationDeserializer" 2466} 2467 2468func (m *awsAwsjson11_deserializeOpImportAppCatalog) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2469 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2470) { 2471 out, metadata, err = next.HandleDeserialize(ctx, in) 2472 if err != nil { 2473 return out, metadata, err 2474 } 2475 2476 response, ok := out.RawResponse.(*smithyhttp.Response) 2477 if !ok { 2478 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2479 } 2480 2481 if response.StatusCode < 200 || response.StatusCode >= 300 { 2482 return out, metadata, awsAwsjson11_deserializeOpErrorImportAppCatalog(response, &metadata) 2483 } 2484 output := &ImportAppCatalogOutput{} 2485 out.Result = output 2486 2487 var buff [1024]byte 2488 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2489 2490 body := io.TeeReader(response.Body, ringBuffer) 2491 decoder := json.NewDecoder(body) 2492 decoder.UseNumber() 2493 var shape interface{} 2494 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2495 var snapshot bytes.Buffer 2496 io.Copy(&snapshot, ringBuffer) 2497 err = &smithy.DeserializationError{ 2498 Err: fmt.Errorf("failed to decode response body, %w", err), 2499 Snapshot: snapshot.Bytes(), 2500 } 2501 return out, metadata, err 2502 } 2503 2504 err = awsAwsjson11_deserializeOpDocumentImportAppCatalogOutput(&output, shape) 2505 if err != nil { 2506 var snapshot bytes.Buffer 2507 io.Copy(&snapshot, ringBuffer) 2508 err = &smithy.DeserializationError{ 2509 Err: fmt.Errorf("failed to decode response body, %w", err), 2510 Snapshot: snapshot.Bytes(), 2511 } 2512 return out, metadata, err 2513 } 2514 2515 return out, metadata, err 2516} 2517 2518func awsAwsjson11_deserializeOpErrorImportAppCatalog(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2519 var errorBuffer bytes.Buffer 2520 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2521 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2522 } 2523 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2524 2525 errorCode := "UnknownError" 2526 errorMessage := errorCode 2527 2528 code := response.Header.Get("X-Amzn-ErrorType") 2529 if len(code) != 0 { 2530 errorCode = restjson.SanitizeErrorCode(code) 2531 } 2532 2533 var buff [1024]byte 2534 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2535 2536 body := io.TeeReader(errorBody, ringBuffer) 2537 decoder := json.NewDecoder(body) 2538 decoder.UseNumber() 2539 code, message, err := restjson.GetErrorInfo(decoder) 2540 if err != nil { 2541 var snapshot bytes.Buffer 2542 io.Copy(&snapshot, ringBuffer) 2543 err = &smithy.DeserializationError{ 2544 Err: fmt.Errorf("failed to decode response body, %w", err), 2545 Snapshot: snapshot.Bytes(), 2546 } 2547 return err 2548 } 2549 2550 errorBody.Seek(0, io.SeekStart) 2551 if len(code) != 0 { 2552 errorCode = restjson.SanitizeErrorCode(code) 2553 } 2554 if len(message) != 0 { 2555 errorMessage = message 2556 } 2557 2558 switch { 2559 case strings.EqualFold("InternalError", errorCode): 2560 return awsAwsjson11_deserializeErrorInternalError(response, errorBody) 2561 2562 case strings.EqualFold("InvalidParameterException", errorCode): 2563 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 2564 2565 case strings.EqualFold("MissingRequiredParameterException", errorCode): 2566 return awsAwsjson11_deserializeErrorMissingRequiredParameterException(response, errorBody) 2567 2568 case strings.EqualFold("OperationNotPermittedException", errorCode): 2569 return awsAwsjson11_deserializeErrorOperationNotPermittedException(response, errorBody) 2570 2571 case strings.EqualFold("UnauthorizedOperationException", errorCode): 2572 return awsAwsjson11_deserializeErrorUnauthorizedOperationException(response, errorBody) 2573 2574 default: 2575 genericError := &smithy.GenericAPIError{ 2576 Code: errorCode, 2577 Message: errorMessage, 2578 } 2579 return genericError 2580 2581 } 2582} 2583 2584type awsAwsjson11_deserializeOpImportServerCatalog struct { 2585} 2586 2587func (*awsAwsjson11_deserializeOpImportServerCatalog) ID() string { 2588 return "OperationDeserializer" 2589} 2590 2591func (m *awsAwsjson11_deserializeOpImportServerCatalog) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2592 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2593) { 2594 out, metadata, err = next.HandleDeserialize(ctx, in) 2595 if err != nil { 2596 return out, metadata, err 2597 } 2598 2599 response, ok := out.RawResponse.(*smithyhttp.Response) 2600 if !ok { 2601 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2602 } 2603 2604 if response.StatusCode < 200 || response.StatusCode >= 300 { 2605 return out, metadata, awsAwsjson11_deserializeOpErrorImportServerCatalog(response, &metadata) 2606 } 2607 output := &ImportServerCatalogOutput{} 2608 out.Result = output 2609 2610 var buff [1024]byte 2611 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2612 2613 body := io.TeeReader(response.Body, ringBuffer) 2614 decoder := json.NewDecoder(body) 2615 decoder.UseNumber() 2616 var shape interface{} 2617 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2618 var snapshot bytes.Buffer 2619 io.Copy(&snapshot, ringBuffer) 2620 err = &smithy.DeserializationError{ 2621 Err: fmt.Errorf("failed to decode response body, %w", err), 2622 Snapshot: snapshot.Bytes(), 2623 } 2624 return out, metadata, err 2625 } 2626 2627 err = awsAwsjson11_deserializeOpDocumentImportServerCatalogOutput(&output, shape) 2628 if err != nil { 2629 var snapshot bytes.Buffer 2630 io.Copy(&snapshot, ringBuffer) 2631 err = &smithy.DeserializationError{ 2632 Err: fmt.Errorf("failed to decode response body, %w", err), 2633 Snapshot: snapshot.Bytes(), 2634 } 2635 return out, metadata, err 2636 } 2637 2638 return out, metadata, err 2639} 2640 2641func awsAwsjson11_deserializeOpErrorImportServerCatalog(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2642 var errorBuffer bytes.Buffer 2643 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2644 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2645 } 2646 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2647 2648 errorCode := "UnknownError" 2649 errorMessage := errorCode 2650 2651 code := response.Header.Get("X-Amzn-ErrorType") 2652 if len(code) != 0 { 2653 errorCode = restjson.SanitizeErrorCode(code) 2654 } 2655 2656 var buff [1024]byte 2657 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2658 2659 body := io.TeeReader(errorBody, ringBuffer) 2660 decoder := json.NewDecoder(body) 2661 decoder.UseNumber() 2662 code, message, err := restjson.GetErrorInfo(decoder) 2663 if err != nil { 2664 var snapshot bytes.Buffer 2665 io.Copy(&snapshot, ringBuffer) 2666 err = &smithy.DeserializationError{ 2667 Err: fmt.Errorf("failed to decode response body, %w", err), 2668 Snapshot: snapshot.Bytes(), 2669 } 2670 return err 2671 } 2672 2673 errorBody.Seek(0, io.SeekStart) 2674 if len(code) != 0 { 2675 errorCode = restjson.SanitizeErrorCode(code) 2676 } 2677 if len(message) != 0 { 2678 errorMessage = message 2679 } 2680 2681 switch { 2682 case strings.EqualFold("InvalidParameterException", errorCode): 2683 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 2684 2685 case strings.EqualFold("MissingRequiredParameterException", errorCode): 2686 return awsAwsjson11_deserializeErrorMissingRequiredParameterException(response, errorBody) 2687 2688 case strings.EqualFold("NoConnectorsAvailableException", errorCode): 2689 return awsAwsjson11_deserializeErrorNoConnectorsAvailableException(response, errorBody) 2690 2691 case strings.EqualFold("OperationNotPermittedException", errorCode): 2692 return awsAwsjson11_deserializeErrorOperationNotPermittedException(response, errorBody) 2693 2694 case strings.EqualFold("UnauthorizedOperationException", errorCode): 2695 return awsAwsjson11_deserializeErrorUnauthorizedOperationException(response, errorBody) 2696 2697 default: 2698 genericError := &smithy.GenericAPIError{ 2699 Code: errorCode, 2700 Message: errorMessage, 2701 } 2702 return genericError 2703 2704 } 2705} 2706 2707type awsAwsjson11_deserializeOpLaunchApp struct { 2708} 2709 2710func (*awsAwsjson11_deserializeOpLaunchApp) ID() string { 2711 return "OperationDeserializer" 2712} 2713 2714func (m *awsAwsjson11_deserializeOpLaunchApp) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2715 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2716) { 2717 out, metadata, err = next.HandleDeserialize(ctx, in) 2718 if err != nil { 2719 return out, metadata, err 2720 } 2721 2722 response, ok := out.RawResponse.(*smithyhttp.Response) 2723 if !ok { 2724 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2725 } 2726 2727 if response.StatusCode < 200 || response.StatusCode >= 300 { 2728 return out, metadata, awsAwsjson11_deserializeOpErrorLaunchApp(response, &metadata) 2729 } 2730 output := &LaunchAppOutput{} 2731 out.Result = output 2732 2733 var buff [1024]byte 2734 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2735 2736 body := io.TeeReader(response.Body, ringBuffer) 2737 decoder := json.NewDecoder(body) 2738 decoder.UseNumber() 2739 var shape interface{} 2740 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2741 var snapshot bytes.Buffer 2742 io.Copy(&snapshot, ringBuffer) 2743 err = &smithy.DeserializationError{ 2744 Err: fmt.Errorf("failed to decode response body, %w", err), 2745 Snapshot: snapshot.Bytes(), 2746 } 2747 return out, metadata, err 2748 } 2749 2750 err = awsAwsjson11_deserializeOpDocumentLaunchAppOutput(&output, shape) 2751 if err != nil { 2752 var snapshot bytes.Buffer 2753 io.Copy(&snapshot, ringBuffer) 2754 err = &smithy.DeserializationError{ 2755 Err: fmt.Errorf("failed to decode response body, %w", err), 2756 Snapshot: snapshot.Bytes(), 2757 } 2758 return out, metadata, err 2759 } 2760 2761 return out, metadata, err 2762} 2763 2764func awsAwsjson11_deserializeOpErrorLaunchApp(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2765 var errorBuffer bytes.Buffer 2766 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2767 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2768 } 2769 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2770 2771 errorCode := "UnknownError" 2772 errorMessage := errorCode 2773 2774 code := response.Header.Get("X-Amzn-ErrorType") 2775 if len(code) != 0 { 2776 errorCode = restjson.SanitizeErrorCode(code) 2777 } 2778 2779 var buff [1024]byte 2780 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2781 2782 body := io.TeeReader(errorBody, ringBuffer) 2783 decoder := json.NewDecoder(body) 2784 decoder.UseNumber() 2785 code, message, err := restjson.GetErrorInfo(decoder) 2786 if err != nil { 2787 var snapshot bytes.Buffer 2788 io.Copy(&snapshot, ringBuffer) 2789 err = &smithy.DeserializationError{ 2790 Err: fmt.Errorf("failed to decode response body, %w", err), 2791 Snapshot: snapshot.Bytes(), 2792 } 2793 return err 2794 } 2795 2796 errorBody.Seek(0, io.SeekStart) 2797 if len(code) != 0 { 2798 errorCode = restjson.SanitizeErrorCode(code) 2799 } 2800 if len(message) != 0 { 2801 errorMessage = message 2802 } 2803 2804 switch { 2805 case strings.EqualFold("InternalError", errorCode): 2806 return awsAwsjson11_deserializeErrorInternalError(response, errorBody) 2807 2808 case strings.EqualFold("InvalidParameterException", errorCode): 2809 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 2810 2811 case strings.EqualFold("MissingRequiredParameterException", errorCode): 2812 return awsAwsjson11_deserializeErrorMissingRequiredParameterException(response, errorBody) 2813 2814 case strings.EqualFold("OperationNotPermittedException", errorCode): 2815 return awsAwsjson11_deserializeErrorOperationNotPermittedException(response, errorBody) 2816 2817 case strings.EqualFold("UnauthorizedOperationException", errorCode): 2818 return awsAwsjson11_deserializeErrorUnauthorizedOperationException(response, errorBody) 2819 2820 default: 2821 genericError := &smithy.GenericAPIError{ 2822 Code: errorCode, 2823 Message: errorMessage, 2824 } 2825 return genericError 2826 2827 } 2828} 2829 2830type awsAwsjson11_deserializeOpListApps struct { 2831} 2832 2833func (*awsAwsjson11_deserializeOpListApps) ID() string { 2834 return "OperationDeserializer" 2835} 2836 2837func (m *awsAwsjson11_deserializeOpListApps) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2838 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2839) { 2840 out, metadata, err = next.HandleDeserialize(ctx, in) 2841 if err != nil { 2842 return out, metadata, err 2843 } 2844 2845 response, ok := out.RawResponse.(*smithyhttp.Response) 2846 if !ok { 2847 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2848 } 2849 2850 if response.StatusCode < 200 || response.StatusCode >= 300 { 2851 return out, metadata, awsAwsjson11_deserializeOpErrorListApps(response, &metadata) 2852 } 2853 output := &ListAppsOutput{} 2854 out.Result = output 2855 2856 var buff [1024]byte 2857 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2858 2859 body := io.TeeReader(response.Body, ringBuffer) 2860 decoder := json.NewDecoder(body) 2861 decoder.UseNumber() 2862 var shape interface{} 2863 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2864 var snapshot bytes.Buffer 2865 io.Copy(&snapshot, ringBuffer) 2866 err = &smithy.DeserializationError{ 2867 Err: fmt.Errorf("failed to decode response body, %w", err), 2868 Snapshot: snapshot.Bytes(), 2869 } 2870 return out, metadata, err 2871 } 2872 2873 err = awsAwsjson11_deserializeOpDocumentListAppsOutput(&output, shape) 2874 if err != nil { 2875 var snapshot bytes.Buffer 2876 io.Copy(&snapshot, ringBuffer) 2877 err = &smithy.DeserializationError{ 2878 Err: fmt.Errorf("failed to decode response body, %w", err), 2879 Snapshot: snapshot.Bytes(), 2880 } 2881 return out, metadata, err 2882 } 2883 2884 return out, metadata, err 2885} 2886 2887func awsAwsjson11_deserializeOpErrorListApps(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2888 var errorBuffer bytes.Buffer 2889 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2890 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2891 } 2892 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2893 2894 errorCode := "UnknownError" 2895 errorMessage := errorCode 2896 2897 code := response.Header.Get("X-Amzn-ErrorType") 2898 if len(code) != 0 { 2899 errorCode = restjson.SanitizeErrorCode(code) 2900 } 2901 2902 var buff [1024]byte 2903 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2904 2905 body := io.TeeReader(errorBody, ringBuffer) 2906 decoder := json.NewDecoder(body) 2907 decoder.UseNumber() 2908 code, message, err := restjson.GetErrorInfo(decoder) 2909 if err != nil { 2910 var snapshot bytes.Buffer 2911 io.Copy(&snapshot, ringBuffer) 2912 err = &smithy.DeserializationError{ 2913 Err: fmt.Errorf("failed to decode response body, %w", err), 2914 Snapshot: snapshot.Bytes(), 2915 } 2916 return err 2917 } 2918 2919 errorBody.Seek(0, io.SeekStart) 2920 if len(code) != 0 { 2921 errorCode = restjson.SanitizeErrorCode(code) 2922 } 2923 if len(message) != 0 { 2924 errorMessage = message 2925 } 2926 2927 switch { 2928 case strings.EqualFold("InternalError", errorCode): 2929 return awsAwsjson11_deserializeErrorInternalError(response, errorBody) 2930 2931 case strings.EqualFold("InvalidParameterException", errorCode): 2932 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 2933 2934 case strings.EqualFold("MissingRequiredParameterException", errorCode): 2935 return awsAwsjson11_deserializeErrorMissingRequiredParameterException(response, errorBody) 2936 2937 case strings.EqualFold("OperationNotPermittedException", errorCode): 2938 return awsAwsjson11_deserializeErrorOperationNotPermittedException(response, errorBody) 2939 2940 case strings.EqualFold("UnauthorizedOperationException", errorCode): 2941 return awsAwsjson11_deserializeErrorUnauthorizedOperationException(response, errorBody) 2942 2943 default: 2944 genericError := &smithy.GenericAPIError{ 2945 Code: errorCode, 2946 Message: errorMessage, 2947 } 2948 return genericError 2949 2950 } 2951} 2952 2953type awsAwsjson11_deserializeOpNotifyAppValidationOutput struct { 2954} 2955 2956func (*awsAwsjson11_deserializeOpNotifyAppValidationOutput) ID() string { 2957 return "OperationDeserializer" 2958} 2959 2960func (m *awsAwsjson11_deserializeOpNotifyAppValidationOutput) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2961 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2962) { 2963 out, metadata, err = next.HandleDeserialize(ctx, in) 2964 if err != nil { 2965 return out, metadata, err 2966 } 2967 2968 response, ok := out.RawResponse.(*smithyhttp.Response) 2969 if !ok { 2970 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2971 } 2972 2973 if response.StatusCode < 200 || response.StatusCode >= 300 { 2974 return out, metadata, awsAwsjson11_deserializeOpErrorNotifyAppValidationOutput(response, &metadata) 2975 } 2976 output := &NotifyAppValidationOutputOutput{} 2977 out.Result = output 2978 2979 var buff [1024]byte 2980 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2981 2982 body := io.TeeReader(response.Body, ringBuffer) 2983 decoder := json.NewDecoder(body) 2984 decoder.UseNumber() 2985 var shape interface{} 2986 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2987 var snapshot bytes.Buffer 2988 io.Copy(&snapshot, ringBuffer) 2989 err = &smithy.DeserializationError{ 2990 Err: fmt.Errorf("failed to decode response body, %w", err), 2991 Snapshot: snapshot.Bytes(), 2992 } 2993 return out, metadata, err 2994 } 2995 2996 err = awsAwsjson11_deserializeOpDocumentNotifyAppValidationOutputOutput(&output, shape) 2997 if err != nil { 2998 var snapshot bytes.Buffer 2999 io.Copy(&snapshot, ringBuffer) 3000 err = &smithy.DeserializationError{ 3001 Err: fmt.Errorf("failed to decode response body, %w", err), 3002 Snapshot: snapshot.Bytes(), 3003 } 3004 return out, metadata, err 3005 } 3006 3007 return out, metadata, err 3008} 3009 3010func awsAwsjson11_deserializeOpErrorNotifyAppValidationOutput(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3011 var errorBuffer bytes.Buffer 3012 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3013 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3014 } 3015 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3016 3017 errorCode := "UnknownError" 3018 errorMessage := errorCode 3019 3020 code := response.Header.Get("X-Amzn-ErrorType") 3021 if len(code) != 0 { 3022 errorCode = restjson.SanitizeErrorCode(code) 3023 } 3024 3025 var buff [1024]byte 3026 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3027 3028 body := io.TeeReader(errorBody, ringBuffer) 3029 decoder := json.NewDecoder(body) 3030 decoder.UseNumber() 3031 code, message, err := restjson.GetErrorInfo(decoder) 3032 if err != nil { 3033 var snapshot bytes.Buffer 3034 io.Copy(&snapshot, ringBuffer) 3035 err = &smithy.DeserializationError{ 3036 Err: fmt.Errorf("failed to decode response body, %w", err), 3037 Snapshot: snapshot.Bytes(), 3038 } 3039 return err 3040 } 3041 3042 errorBody.Seek(0, io.SeekStart) 3043 if len(code) != 0 { 3044 errorCode = restjson.SanitizeErrorCode(code) 3045 } 3046 if len(message) != 0 { 3047 errorMessage = message 3048 } 3049 3050 switch { 3051 case strings.EqualFold("InternalError", errorCode): 3052 return awsAwsjson11_deserializeErrorInternalError(response, errorBody) 3053 3054 case strings.EqualFold("InvalidParameterException", errorCode): 3055 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 3056 3057 case strings.EqualFold("MissingRequiredParameterException", errorCode): 3058 return awsAwsjson11_deserializeErrorMissingRequiredParameterException(response, errorBody) 3059 3060 case strings.EqualFold("OperationNotPermittedException", errorCode): 3061 return awsAwsjson11_deserializeErrorOperationNotPermittedException(response, errorBody) 3062 3063 case strings.EqualFold("UnauthorizedOperationException", errorCode): 3064 return awsAwsjson11_deserializeErrorUnauthorizedOperationException(response, errorBody) 3065 3066 default: 3067 genericError := &smithy.GenericAPIError{ 3068 Code: errorCode, 3069 Message: errorMessage, 3070 } 3071 return genericError 3072 3073 } 3074} 3075 3076type awsAwsjson11_deserializeOpPutAppLaunchConfiguration struct { 3077} 3078 3079func (*awsAwsjson11_deserializeOpPutAppLaunchConfiguration) ID() string { 3080 return "OperationDeserializer" 3081} 3082 3083func (m *awsAwsjson11_deserializeOpPutAppLaunchConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3084 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3085) { 3086 out, metadata, err = next.HandleDeserialize(ctx, in) 3087 if err != nil { 3088 return out, metadata, err 3089 } 3090 3091 response, ok := out.RawResponse.(*smithyhttp.Response) 3092 if !ok { 3093 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3094 } 3095 3096 if response.StatusCode < 200 || response.StatusCode >= 300 { 3097 return out, metadata, awsAwsjson11_deserializeOpErrorPutAppLaunchConfiguration(response, &metadata) 3098 } 3099 output := &PutAppLaunchConfigurationOutput{} 3100 out.Result = output 3101 3102 var buff [1024]byte 3103 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3104 3105 body := io.TeeReader(response.Body, ringBuffer) 3106 decoder := json.NewDecoder(body) 3107 decoder.UseNumber() 3108 var shape interface{} 3109 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3110 var snapshot bytes.Buffer 3111 io.Copy(&snapshot, ringBuffer) 3112 err = &smithy.DeserializationError{ 3113 Err: fmt.Errorf("failed to decode response body, %w", err), 3114 Snapshot: snapshot.Bytes(), 3115 } 3116 return out, metadata, err 3117 } 3118 3119 err = awsAwsjson11_deserializeOpDocumentPutAppLaunchConfigurationOutput(&output, shape) 3120 if err != nil { 3121 var snapshot bytes.Buffer 3122 io.Copy(&snapshot, ringBuffer) 3123 err = &smithy.DeserializationError{ 3124 Err: fmt.Errorf("failed to decode response body, %w", err), 3125 Snapshot: snapshot.Bytes(), 3126 } 3127 return out, metadata, err 3128 } 3129 3130 return out, metadata, err 3131} 3132 3133func awsAwsjson11_deserializeOpErrorPutAppLaunchConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3134 var errorBuffer bytes.Buffer 3135 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3136 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3137 } 3138 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3139 3140 errorCode := "UnknownError" 3141 errorMessage := errorCode 3142 3143 code := response.Header.Get("X-Amzn-ErrorType") 3144 if len(code) != 0 { 3145 errorCode = restjson.SanitizeErrorCode(code) 3146 } 3147 3148 var buff [1024]byte 3149 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3150 3151 body := io.TeeReader(errorBody, ringBuffer) 3152 decoder := json.NewDecoder(body) 3153 decoder.UseNumber() 3154 code, message, err := restjson.GetErrorInfo(decoder) 3155 if err != nil { 3156 var snapshot bytes.Buffer 3157 io.Copy(&snapshot, ringBuffer) 3158 err = &smithy.DeserializationError{ 3159 Err: fmt.Errorf("failed to decode response body, %w", err), 3160 Snapshot: snapshot.Bytes(), 3161 } 3162 return err 3163 } 3164 3165 errorBody.Seek(0, io.SeekStart) 3166 if len(code) != 0 { 3167 errorCode = restjson.SanitizeErrorCode(code) 3168 } 3169 if len(message) != 0 { 3170 errorMessage = message 3171 } 3172 3173 switch { 3174 case strings.EqualFold("InternalError", errorCode): 3175 return awsAwsjson11_deserializeErrorInternalError(response, errorBody) 3176 3177 case strings.EqualFold("InvalidParameterException", errorCode): 3178 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 3179 3180 case strings.EqualFold("MissingRequiredParameterException", errorCode): 3181 return awsAwsjson11_deserializeErrorMissingRequiredParameterException(response, errorBody) 3182 3183 case strings.EqualFold("OperationNotPermittedException", errorCode): 3184 return awsAwsjson11_deserializeErrorOperationNotPermittedException(response, errorBody) 3185 3186 case strings.EqualFold("UnauthorizedOperationException", errorCode): 3187 return awsAwsjson11_deserializeErrorUnauthorizedOperationException(response, errorBody) 3188 3189 default: 3190 genericError := &smithy.GenericAPIError{ 3191 Code: errorCode, 3192 Message: errorMessage, 3193 } 3194 return genericError 3195 3196 } 3197} 3198 3199type awsAwsjson11_deserializeOpPutAppReplicationConfiguration struct { 3200} 3201 3202func (*awsAwsjson11_deserializeOpPutAppReplicationConfiguration) ID() string { 3203 return "OperationDeserializer" 3204} 3205 3206func (m *awsAwsjson11_deserializeOpPutAppReplicationConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3207 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3208) { 3209 out, metadata, err = next.HandleDeserialize(ctx, in) 3210 if err != nil { 3211 return out, metadata, err 3212 } 3213 3214 response, ok := out.RawResponse.(*smithyhttp.Response) 3215 if !ok { 3216 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3217 } 3218 3219 if response.StatusCode < 200 || response.StatusCode >= 300 { 3220 return out, metadata, awsAwsjson11_deserializeOpErrorPutAppReplicationConfiguration(response, &metadata) 3221 } 3222 output := &PutAppReplicationConfigurationOutput{} 3223 out.Result = output 3224 3225 var buff [1024]byte 3226 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3227 3228 body := io.TeeReader(response.Body, ringBuffer) 3229 decoder := json.NewDecoder(body) 3230 decoder.UseNumber() 3231 var shape interface{} 3232 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3233 var snapshot bytes.Buffer 3234 io.Copy(&snapshot, ringBuffer) 3235 err = &smithy.DeserializationError{ 3236 Err: fmt.Errorf("failed to decode response body, %w", err), 3237 Snapshot: snapshot.Bytes(), 3238 } 3239 return out, metadata, err 3240 } 3241 3242 err = awsAwsjson11_deserializeOpDocumentPutAppReplicationConfigurationOutput(&output, shape) 3243 if err != nil { 3244 var snapshot bytes.Buffer 3245 io.Copy(&snapshot, ringBuffer) 3246 err = &smithy.DeserializationError{ 3247 Err: fmt.Errorf("failed to decode response body, %w", err), 3248 Snapshot: snapshot.Bytes(), 3249 } 3250 return out, metadata, err 3251 } 3252 3253 return out, metadata, err 3254} 3255 3256func awsAwsjson11_deserializeOpErrorPutAppReplicationConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3257 var errorBuffer bytes.Buffer 3258 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3259 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3260 } 3261 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3262 3263 errorCode := "UnknownError" 3264 errorMessage := errorCode 3265 3266 code := response.Header.Get("X-Amzn-ErrorType") 3267 if len(code) != 0 { 3268 errorCode = restjson.SanitizeErrorCode(code) 3269 } 3270 3271 var buff [1024]byte 3272 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3273 3274 body := io.TeeReader(errorBody, ringBuffer) 3275 decoder := json.NewDecoder(body) 3276 decoder.UseNumber() 3277 code, message, err := restjson.GetErrorInfo(decoder) 3278 if err != nil { 3279 var snapshot bytes.Buffer 3280 io.Copy(&snapshot, ringBuffer) 3281 err = &smithy.DeserializationError{ 3282 Err: fmt.Errorf("failed to decode response body, %w", err), 3283 Snapshot: snapshot.Bytes(), 3284 } 3285 return err 3286 } 3287 3288 errorBody.Seek(0, io.SeekStart) 3289 if len(code) != 0 { 3290 errorCode = restjson.SanitizeErrorCode(code) 3291 } 3292 if len(message) != 0 { 3293 errorMessage = message 3294 } 3295 3296 switch { 3297 case strings.EqualFold("InternalError", errorCode): 3298 return awsAwsjson11_deserializeErrorInternalError(response, errorBody) 3299 3300 case strings.EqualFold("InvalidParameterException", errorCode): 3301 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 3302 3303 case strings.EqualFold("MissingRequiredParameterException", errorCode): 3304 return awsAwsjson11_deserializeErrorMissingRequiredParameterException(response, errorBody) 3305 3306 case strings.EqualFold("OperationNotPermittedException", errorCode): 3307 return awsAwsjson11_deserializeErrorOperationNotPermittedException(response, errorBody) 3308 3309 case strings.EqualFold("UnauthorizedOperationException", errorCode): 3310 return awsAwsjson11_deserializeErrorUnauthorizedOperationException(response, errorBody) 3311 3312 default: 3313 genericError := &smithy.GenericAPIError{ 3314 Code: errorCode, 3315 Message: errorMessage, 3316 } 3317 return genericError 3318 3319 } 3320} 3321 3322type awsAwsjson11_deserializeOpPutAppValidationConfiguration struct { 3323} 3324 3325func (*awsAwsjson11_deserializeOpPutAppValidationConfiguration) ID() string { 3326 return "OperationDeserializer" 3327} 3328 3329func (m *awsAwsjson11_deserializeOpPutAppValidationConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3330 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3331) { 3332 out, metadata, err = next.HandleDeserialize(ctx, in) 3333 if err != nil { 3334 return out, metadata, err 3335 } 3336 3337 response, ok := out.RawResponse.(*smithyhttp.Response) 3338 if !ok { 3339 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3340 } 3341 3342 if response.StatusCode < 200 || response.StatusCode >= 300 { 3343 return out, metadata, awsAwsjson11_deserializeOpErrorPutAppValidationConfiguration(response, &metadata) 3344 } 3345 output := &PutAppValidationConfigurationOutput{} 3346 out.Result = output 3347 3348 var buff [1024]byte 3349 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3350 3351 body := io.TeeReader(response.Body, ringBuffer) 3352 decoder := json.NewDecoder(body) 3353 decoder.UseNumber() 3354 var shape interface{} 3355 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3356 var snapshot bytes.Buffer 3357 io.Copy(&snapshot, ringBuffer) 3358 err = &smithy.DeserializationError{ 3359 Err: fmt.Errorf("failed to decode response body, %w", err), 3360 Snapshot: snapshot.Bytes(), 3361 } 3362 return out, metadata, err 3363 } 3364 3365 err = awsAwsjson11_deserializeOpDocumentPutAppValidationConfigurationOutput(&output, shape) 3366 if err != nil { 3367 var snapshot bytes.Buffer 3368 io.Copy(&snapshot, ringBuffer) 3369 err = &smithy.DeserializationError{ 3370 Err: fmt.Errorf("failed to decode response body, %w", err), 3371 Snapshot: snapshot.Bytes(), 3372 } 3373 return out, metadata, err 3374 } 3375 3376 return out, metadata, err 3377} 3378 3379func awsAwsjson11_deserializeOpErrorPutAppValidationConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3380 var errorBuffer bytes.Buffer 3381 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3382 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3383 } 3384 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3385 3386 errorCode := "UnknownError" 3387 errorMessage := errorCode 3388 3389 code := response.Header.Get("X-Amzn-ErrorType") 3390 if len(code) != 0 { 3391 errorCode = restjson.SanitizeErrorCode(code) 3392 } 3393 3394 var buff [1024]byte 3395 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3396 3397 body := io.TeeReader(errorBody, ringBuffer) 3398 decoder := json.NewDecoder(body) 3399 decoder.UseNumber() 3400 code, message, err := restjson.GetErrorInfo(decoder) 3401 if err != nil { 3402 var snapshot bytes.Buffer 3403 io.Copy(&snapshot, ringBuffer) 3404 err = &smithy.DeserializationError{ 3405 Err: fmt.Errorf("failed to decode response body, %w", err), 3406 Snapshot: snapshot.Bytes(), 3407 } 3408 return err 3409 } 3410 3411 errorBody.Seek(0, io.SeekStart) 3412 if len(code) != 0 { 3413 errorCode = restjson.SanitizeErrorCode(code) 3414 } 3415 if len(message) != 0 { 3416 errorMessage = message 3417 } 3418 3419 switch { 3420 case strings.EqualFold("InternalError", errorCode): 3421 return awsAwsjson11_deserializeErrorInternalError(response, errorBody) 3422 3423 case strings.EqualFold("InvalidParameterException", errorCode): 3424 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 3425 3426 case strings.EqualFold("MissingRequiredParameterException", errorCode): 3427 return awsAwsjson11_deserializeErrorMissingRequiredParameterException(response, errorBody) 3428 3429 case strings.EqualFold("OperationNotPermittedException", errorCode): 3430 return awsAwsjson11_deserializeErrorOperationNotPermittedException(response, errorBody) 3431 3432 case strings.EqualFold("UnauthorizedOperationException", errorCode): 3433 return awsAwsjson11_deserializeErrorUnauthorizedOperationException(response, errorBody) 3434 3435 default: 3436 genericError := &smithy.GenericAPIError{ 3437 Code: errorCode, 3438 Message: errorMessage, 3439 } 3440 return genericError 3441 3442 } 3443} 3444 3445type awsAwsjson11_deserializeOpStartAppReplication struct { 3446} 3447 3448func (*awsAwsjson11_deserializeOpStartAppReplication) ID() string { 3449 return "OperationDeserializer" 3450} 3451 3452func (m *awsAwsjson11_deserializeOpStartAppReplication) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3453 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3454) { 3455 out, metadata, err = next.HandleDeserialize(ctx, in) 3456 if err != nil { 3457 return out, metadata, err 3458 } 3459 3460 response, ok := out.RawResponse.(*smithyhttp.Response) 3461 if !ok { 3462 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3463 } 3464 3465 if response.StatusCode < 200 || response.StatusCode >= 300 { 3466 return out, metadata, awsAwsjson11_deserializeOpErrorStartAppReplication(response, &metadata) 3467 } 3468 output := &StartAppReplicationOutput{} 3469 out.Result = output 3470 3471 var buff [1024]byte 3472 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3473 3474 body := io.TeeReader(response.Body, ringBuffer) 3475 decoder := json.NewDecoder(body) 3476 decoder.UseNumber() 3477 var shape interface{} 3478 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3479 var snapshot bytes.Buffer 3480 io.Copy(&snapshot, ringBuffer) 3481 err = &smithy.DeserializationError{ 3482 Err: fmt.Errorf("failed to decode response body, %w", err), 3483 Snapshot: snapshot.Bytes(), 3484 } 3485 return out, metadata, err 3486 } 3487 3488 err = awsAwsjson11_deserializeOpDocumentStartAppReplicationOutput(&output, shape) 3489 if err != nil { 3490 var snapshot bytes.Buffer 3491 io.Copy(&snapshot, ringBuffer) 3492 err = &smithy.DeserializationError{ 3493 Err: fmt.Errorf("failed to decode response body, %w", err), 3494 Snapshot: snapshot.Bytes(), 3495 } 3496 return out, metadata, err 3497 } 3498 3499 return out, metadata, err 3500} 3501 3502func awsAwsjson11_deserializeOpErrorStartAppReplication(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3503 var errorBuffer bytes.Buffer 3504 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3505 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3506 } 3507 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3508 3509 errorCode := "UnknownError" 3510 errorMessage := errorCode 3511 3512 code := response.Header.Get("X-Amzn-ErrorType") 3513 if len(code) != 0 { 3514 errorCode = restjson.SanitizeErrorCode(code) 3515 } 3516 3517 var buff [1024]byte 3518 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3519 3520 body := io.TeeReader(errorBody, ringBuffer) 3521 decoder := json.NewDecoder(body) 3522 decoder.UseNumber() 3523 code, message, err := restjson.GetErrorInfo(decoder) 3524 if err != nil { 3525 var snapshot bytes.Buffer 3526 io.Copy(&snapshot, ringBuffer) 3527 err = &smithy.DeserializationError{ 3528 Err: fmt.Errorf("failed to decode response body, %w", err), 3529 Snapshot: snapshot.Bytes(), 3530 } 3531 return err 3532 } 3533 3534 errorBody.Seek(0, io.SeekStart) 3535 if len(code) != 0 { 3536 errorCode = restjson.SanitizeErrorCode(code) 3537 } 3538 if len(message) != 0 { 3539 errorMessage = message 3540 } 3541 3542 switch { 3543 case strings.EqualFold("InternalError", errorCode): 3544 return awsAwsjson11_deserializeErrorInternalError(response, errorBody) 3545 3546 case strings.EqualFold("InvalidParameterException", errorCode): 3547 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 3548 3549 case strings.EqualFold("MissingRequiredParameterException", errorCode): 3550 return awsAwsjson11_deserializeErrorMissingRequiredParameterException(response, errorBody) 3551 3552 case strings.EqualFold("OperationNotPermittedException", errorCode): 3553 return awsAwsjson11_deserializeErrorOperationNotPermittedException(response, errorBody) 3554 3555 case strings.EqualFold("UnauthorizedOperationException", errorCode): 3556 return awsAwsjson11_deserializeErrorUnauthorizedOperationException(response, errorBody) 3557 3558 default: 3559 genericError := &smithy.GenericAPIError{ 3560 Code: errorCode, 3561 Message: errorMessage, 3562 } 3563 return genericError 3564 3565 } 3566} 3567 3568type awsAwsjson11_deserializeOpStartOnDemandAppReplication struct { 3569} 3570 3571func (*awsAwsjson11_deserializeOpStartOnDemandAppReplication) ID() string { 3572 return "OperationDeserializer" 3573} 3574 3575func (m *awsAwsjson11_deserializeOpStartOnDemandAppReplication) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3576 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3577) { 3578 out, metadata, err = next.HandleDeserialize(ctx, in) 3579 if err != nil { 3580 return out, metadata, err 3581 } 3582 3583 response, ok := out.RawResponse.(*smithyhttp.Response) 3584 if !ok { 3585 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3586 } 3587 3588 if response.StatusCode < 200 || response.StatusCode >= 300 { 3589 return out, metadata, awsAwsjson11_deserializeOpErrorStartOnDemandAppReplication(response, &metadata) 3590 } 3591 output := &StartOnDemandAppReplicationOutput{} 3592 out.Result = output 3593 3594 var buff [1024]byte 3595 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3596 3597 body := io.TeeReader(response.Body, ringBuffer) 3598 decoder := json.NewDecoder(body) 3599 decoder.UseNumber() 3600 var shape interface{} 3601 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3602 var snapshot bytes.Buffer 3603 io.Copy(&snapshot, ringBuffer) 3604 err = &smithy.DeserializationError{ 3605 Err: fmt.Errorf("failed to decode response body, %w", err), 3606 Snapshot: snapshot.Bytes(), 3607 } 3608 return out, metadata, err 3609 } 3610 3611 err = awsAwsjson11_deserializeOpDocumentStartOnDemandAppReplicationOutput(&output, shape) 3612 if err != nil { 3613 var snapshot bytes.Buffer 3614 io.Copy(&snapshot, ringBuffer) 3615 err = &smithy.DeserializationError{ 3616 Err: fmt.Errorf("failed to decode response body, %w", err), 3617 Snapshot: snapshot.Bytes(), 3618 } 3619 return out, metadata, err 3620 } 3621 3622 return out, metadata, err 3623} 3624 3625func awsAwsjson11_deserializeOpErrorStartOnDemandAppReplication(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3626 var errorBuffer bytes.Buffer 3627 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3628 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3629 } 3630 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3631 3632 errorCode := "UnknownError" 3633 errorMessage := errorCode 3634 3635 code := response.Header.Get("X-Amzn-ErrorType") 3636 if len(code) != 0 { 3637 errorCode = restjson.SanitizeErrorCode(code) 3638 } 3639 3640 var buff [1024]byte 3641 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3642 3643 body := io.TeeReader(errorBody, ringBuffer) 3644 decoder := json.NewDecoder(body) 3645 decoder.UseNumber() 3646 code, message, err := restjson.GetErrorInfo(decoder) 3647 if err != nil { 3648 var snapshot bytes.Buffer 3649 io.Copy(&snapshot, ringBuffer) 3650 err = &smithy.DeserializationError{ 3651 Err: fmt.Errorf("failed to decode response body, %w", err), 3652 Snapshot: snapshot.Bytes(), 3653 } 3654 return err 3655 } 3656 3657 errorBody.Seek(0, io.SeekStart) 3658 if len(code) != 0 { 3659 errorCode = restjson.SanitizeErrorCode(code) 3660 } 3661 if len(message) != 0 { 3662 errorMessage = message 3663 } 3664 3665 switch { 3666 case strings.EqualFold("InternalError", errorCode): 3667 return awsAwsjson11_deserializeErrorInternalError(response, errorBody) 3668 3669 case strings.EqualFold("InvalidParameterException", errorCode): 3670 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 3671 3672 case strings.EqualFold("MissingRequiredParameterException", errorCode): 3673 return awsAwsjson11_deserializeErrorMissingRequiredParameterException(response, errorBody) 3674 3675 case strings.EqualFold("OperationNotPermittedException", errorCode): 3676 return awsAwsjson11_deserializeErrorOperationNotPermittedException(response, errorBody) 3677 3678 case strings.EqualFold("UnauthorizedOperationException", errorCode): 3679 return awsAwsjson11_deserializeErrorUnauthorizedOperationException(response, errorBody) 3680 3681 default: 3682 genericError := &smithy.GenericAPIError{ 3683 Code: errorCode, 3684 Message: errorMessage, 3685 } 3686 return genericError 3687 3688 } 3689} 3690 3691type awsAwsjson11_deserializeOpStartOnDemandReplicationRun struct { 3692} 3693 3694func (*awsAwsjson11_deserializeOpStartOnDemandReplicationRun) ID() string { 3695 return "OperationDeserializer" 3696} 3697 3698func (m *awsAwsjson11_deserializeOpStartOnDemandReplicationRun) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3699 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3700) { 3701 out, metadata, err = next.HandleDeserialize(ctx, in) 3702 if err != nil { 3703 return out, metadata, err 3704 } 3705 3706 response, ok := out.RawResponse.(*smithyhttp.Response) 3707 if !ok { 3708 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3709 } 3710 3711 if response.StatusCode < 200 || response.StatusCode >= 300 { 3712 return out, metadata, awsAwsjson11_deserializeOpErrorStartOnDemandReplicationRun(response, &metadata) 3713 } 3714 output := &StartOnDemandReplicationRunOutput{} 3715 out.Result = output 3716 3717 var buff [1024]byte 3718 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3719 3720 body := io.TeeReader(response.Body, ringBuffer) 3721 decoder := json.NewDecoder(body) 3722 decoder.UseNumber() 3723 var shape interface{} 3724 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3725 var snapshot bytes.Buffer 3726 io.Copy(&snapshot, ringBuffer) 3727 err = &smithy.DeserializationError{ 3728 Err: fmt.Errorf("failed to decode response body, %w", err), 3729 Snapshot: snapshot.Bytes(), 3730 } 3731 return out, metadata, err 3732 } 3733 3734 err = awsAwsjson11_deserializeOpDocumentStartOnDemandReplicationRunOutput(&output, shape) 3735 if err != nil { 3736 var snapshot bytes.Buffer 3737 io.Copy(&snapshot, ringBuffer) 3738 err = &smithy.DeserializationError{ 3739 Err: fmt.Errorf("failed to decode response body, %w", err), 3740 Snapshot: snapshot.Bytes(), 3741 } 3742 return out, metadata, err 3743 } 3744 3745 return out, metadata, err 3746} 3747 3748func awsAwsjson11_deserializeOpErrorStartOnDemandReplicationRun(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3749 var errorBuffer bytes.Buffer 3750 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3751 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3752 } 3753 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3754 3755 errorCode := "UnknownError" 3756 errorMessage := errorCode 3757 3758 code := response.Header.Get("X-Amzn-ErrorType") 3759 if len(code) != 0 { 3760 errorCode = restjson.SanitizeErrorCode(code) 3761 } 3762 3763 var buff [1024]byte 3764 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3765 3766 body := io.TeeReader(errorBody, ringBuffer) 3767 decoder := json.NewDecoder(body) 3768 decoder.UseNumber() 3769 code, message, err := restjson.GetErrorInfo(decoder) 3770 if err != nil { 3771 var snapshot bytes.Buffer 3772 io.Copy(&snapshot, ringBuffer) 3773 err = &smithy.DeserializationError{ 3774 Err: fmt.Errorf("failed to decode response body, %w", err), 3775 Snapshot: snapshot.Bytes(), 3776 } 3777 return err 3778 } 3779 3780 errorBody.Seek(0, io.SeekStart) 3781 if len(code) != 0 { 3782 errorCode = restjson.SanitizeErrorCode(code) 3783 } 3784 if len(message) != 0 { 3785 errorMessage = message 3786 } 3787 3788 switch { 3789 case strings.EqualFold("DryRunOperationException", errorCode): 3790 return awsAwsjson11_deserializeErrorDryRunOperationException(response, errorBody) 3791 3792 case strings.EqualFold("InvalidParameterException", errorCode): 3793 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 3794 3795 case strings.EqualFold("MissingRequiredParameterException", errorCode): 3796 return awsAwsjson11_deserializeErrorMissingRequiredParameterException(response, errorBody) 3797 3798 case strings.EqualFold("OperationNotPermittedException", errorCode): 3799 return awsAwsjson11_deserializeErrorOperationNotPermittedException(response, errorBody) 3800 3801 case strings.EqualFold("ReplicationRunLimitExceededException", errorCode): 3802 return awsAwsjson11_deserializeErrorReplicationRunLimitExceededException(response, errorBody) 3803 3804 case strings.EqualFold("UnauthorizedOperationException", errorCode): 3805 return awsAwsjson11_deserializeErrorUnauthorizedOperationException(response, errorBody) 3806 3807 default: 3808 genericError := &smithy.GenericAPIError{ 3809 Code: errorCode, 3810 Message: errorMessage, 3811 } 3812 return genericError 3813 3814 } 3815} 3816 3817type awsAwsjson11_deserializeOpStopAppReplication struct { 3818} 3819 3820func (*awsAwsjson11_deserializeOpStopAppReplication) ID() string { 3821 return "OperationDeserializer" 3822} 3823 3824func (m *awsAwsjson11_deserializeOpStopAppReplication) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3825 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3826) { 3827 out, metadata, err = next.HandleDeserialize(ctx, in) 3828 if err != nil { 3829 return out, metadata, err 3830 } 3831 3832 response, ok := out.RawResponse.(*smithyhttp.Response) 3833 if !ok { 3834 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3835 } 3836 3837 if response.StatusCode < 200 || response.StatusCode >= 300 { 3838 return out, metadata, awsAwsjson11_deserializeOpErrorStopAppReplication(response, &metadata) 3839 } 3840 output := &StopAppReplicationOutput{} 3841 out.Result = output 3842 3843 var buff [1024]byte 3844 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3845 3846 body := io.TeeReader(response.Body, ringBuffer) 3847 decoder := json.NewDecoder(body) 3848 decoder.UseNumber() 3849 var shape interface{} 3850 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3851 var snapshot bytes.Buffer 3852 io.Copy(&snapshot, ringBuffer) 3853 err = &smithy.DeserializationError{ 3854 Err: fmt.Errorf("failed to decode response body, %w", err), 3855 Snapshot: snapshot.Bytes(), 3856 } 3857 return out, metadata, err 3858 } 3859 3860 err = awsAwsjson11_deserializeOpDocumentStopAppReplicationOutput(&output, shape) 3861 if err != nil { 3862 var snapshot bytes.Buffer 3863 io.Copy(&snapshot, ringBuffer) 3864 err = &smithy.DeserializationError{ 3865 Err: fmt.Errorf("failed to decode response body, %w", err), 3866 Snapshot: snapshot.Bytes(), 3867 } 3868 return out, metadata, err 3869 } 3870 3871 return out, metadata, err 3872} 3873 3874func awsAwsjson11_deserializeOpErrorStopAppReplication(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3875 var errorBuffer bytes.Buffer 3876 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3877 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3878 } 3879 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3880 3881 errorCode := "UnknownError" 3882 errorMessage := errorCode 3883 3884 code := response.Header.Get("X-Amzn-ErrorType") 3885 if len(code) != 0 { 3886 errorCode = restjson.SanitizeErrorCode(code) 3887 } 3888 3889 var buff [1024]byte 3890 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3891 3892 body := io.TeeReader(errorBody, ringBuffer) 3893 decoder := json.NewDecoder(body) 3894 decoder.UseNumber() 3895 code, message, err := restjson.GetErrorInfo(decoder) 3896 if err != nil { 3897 var snapshot bytes.Buffer 3898 io.Copy(&snapshot, ringBuffer) 3899 err = &smithy.DeserializationError{ 3900 Err: fmt.Errorf("failed to decode response body, %w", err), 3901 Snapshot: snapshot.Bytes(), 3902 } 3903 return err 3904 } 3905 3906 errorBody.Seek(0, io.SeekStart) 3907 if len(code) != 0 { 3908 errorCode = restjson.SanitizeErrorCode(code) 3909 } 3910 if len(message) != 0 { 3911 errorMessage = message 3912 } 3913 3914 switch { 3915 case strings.EqualFold("InternalError", errorCode): 3916 return awsAwsjson11_deserializeErrorInternalError(response, errorBody) 3917 3918 case strings.EqualFold("InvalidParameterException", errorCode): 3919 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 3920 3921 case strings.EqualFold("MissingRequiredParameterException", errorCode): 3922 return awsAwsjson11_deserializeErrorMissingRequiredParameterException(response, errorBody) 3923 3924 case strings.EqualFold("OperationNotPermittedException", errorCode): 3925 return awsAwsjson11_deserializeErrorOperationNotPermittedException(response, errorBody) 3926 3927 case strings.EqualFold("UnauthorizedOperationException", errorCode): 3928 return awsAwsjson11_deserializeErrorUnauthorizedOperationException(response, errorBody) 3929 3930 default: 3931 genericError := &smithy.GenericAPIError{ 3932 Code: errorCode, 3933 Message: errorMessage, 3934 } 3935 return genericError 3936 3937 } 3938} 3939 3940type awsAwsjson11_deserializeOpTerminateApp struct { 3941} 3942 3943func (*awsAwsjson11_deserializeOpTerminateApp) ID() string { 3944 return "OperationDeserializer" 3945} 3946 3947func (m *awsAwsjson11_deserializeOpTerminateApp) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3948 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3949) { 3950 out, metadata, err = next.HandleDeserialize(ctx, in) 3951 if err != nil { 3952 return out, metadata, err 3953 } 3954 3955 response, ok := out.RawResponse.(*smithyhttp.Response) 3956 if !ok { 3957 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3958 } 3959 3960 if response.StatusCode < 200 || response.StatusCode >= 300 { 3961 return out, metadata, awsAwsjson11_deserializeOpErrorTerminateApp(response, &metadata) 3962 } 3963 output := &TerminateAppOutput{} 3964 out.Result = output 3965 3966 var buff [1024]byte 3967 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3968 3969 body := io.TeeReader(response.Body, ringBuffer) 3970 decoder := json.NewDecoder(body) 3971 decoder.UseNumber() 3972 var shape interface{} 3973 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3974 var snapshot bytes.Buffer 3975 io.Copy(&snapshot, ringBuffer) 3976 err = &smithy.DeserializationError{ 3977 Err: fmt.Errorf("failed to decode response body, %w", err), 3978 Snapshot: snapshot.Bytes(), 3979 } 3980 return out, metadata, err 3981 } 3982 3983 err = awsAwsjson11_deserializeOpDocumentTerminateAppOutput(&output, shape) 3984 if err != nil { 3985 var snapshot bytes.Buffer 3986 io.Copy(&snapshot, ringBuffer) 3987 err = &smithy.DeserializationError{ 3988 Err: fmt.Errorf("failed to decode response body, %w", err), 3989 Snapshot: snapshot.Bytes(), 3990 } 3991 return out, metadata, err 3992 } 3993 3994 return out, metadata, err 3995} 3996 3997func awsAwsjson11_deserializeOpErrorTerminateApp(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3998 var errorBuffer bytes.Buffer 3999 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4000 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4001 } 4002 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4003 4004 errorCode := "UnknownError" 4005 errorMessage := errorCode 4006 4007 code := response.Header.Get("X-Amzn-ErrorType") 4008 if len(code) != 0 { 4009 errorCode = restjson.SanitizeErrorCode(code) 4010 } 4011 4012 var buff [1024]byte 4013 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4014 4015 body := io.TeeReader(errorBody, ringBuffer) 4016 decoder := json.NewDecoder(body) 4017 decoder.UseNumber() 4018 code, message, err := restjson.GetErrorInfo(decoder) 4019 if err != nil { 4020 var snapshot bytes.Buffer 4021 io.Copy(&snapshot, ringBuffer) 4022 err = &smithy.DeserializationError{ 4023 Err: fmt.Errorf("failed to decode response body, %w", err), 4024 Snapshot: snapshot.Bytes(), 4025 } 4026 return err 4027 } 4028 4029 errorBody.Seek(0, io.SeekStart) 4030 if len(code) != 0 { 4031 errorCode = restjson.SanitizeErrorCode(code) 4032 } 4033 if len(message) != 0 { 4034 errorMessage = message 4035 } 4036 4037 switch { 4038 case strings.EqualFold("InternalError", errorCode): 4039 return awsAwsjson11_deserializeErrorInternalError(response, errorBody) 4040 4041 case strings.EqualFold("InvalidParameterException", errorCode): 4042 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 4043 4044 case strings.EqualFold("MissingRequiredParameterException", errorCode): 4045 return awsAwsjson11_deserializeErrorMissingRequiredParameterException(response, errorBody) 4046 4047 case strings.EqualFold("OperationNotPermittedException", errorCode): 4048 return awsAwsjson11_deserializeErrorOperationNotPermittedException(response, errorBody) 4049 4050 case strings.EqualFold("UnauthorizedOperationException", errorCode): 4051 return awsAwsjson11_deserializeErrorUnauthorizedOperationException(response, errorBody) 4052 4053 default: 4054 genericError := &smithy.GenericAPIError{ 4055 Code: errorCode, 4056 Message: errorMessage, 4057 } 4058 return genericError 4059 4060 } 4061} 4062 4063type awsAwsjson11_deserializeOpUpdateApp struct { 4064} 4065 4066func (*awsAwsjson11_deserializeOpUpdateApp) ID() string { 4067 return "OperationDeserializer" 4068} 4069 4070func (m *awsAwsjson11_deserializeOpUpdateApp) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4071 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4072) { 4073 out, metadata, err = next.HandleDeserialize(ctx, in) 4074 if err != nil { 4075 return out, metadata, err 4076 } 4077 4078 response, ok := out.RawResponse.(*smithyhttp.Response) 4079 if !ok { 4080 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4081 } 4082 4083 if response.StatusCode < 200 || response.StatusCode >= 300 { 4084 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateApp(response, &metadata) 4085 } 4086 output := &UpdateAppOutput{} 4087 out.Result = output 4088 4089 var buff [1024]byte 4090 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4091 4092 body := io.TeeReader(response.Body, ringBuffer) 4093 decoder := json.NewDecoder(body) 4094 decoder.UseNumber() 4095 var shape interface{} 4096 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4097 var snapshot bytes.Buffer 4098 io.Copy(&snapshot, ringBuffer) 4099 err = &smithy.DeserializationError{ 4100 Err: fmt.Errorf("failed to decode response body, %w", err), 4101 Snapshot: snapshot.Bytes(), 4102 } 4103 return out, metadata, err 4104 } 4105 4106 err = awsAwsjson11_deserializeOpDocumentUpdateAppOutput(&output, shape) 4107 if err != nil { 4108 var snapshot bytes.Buffer 4109 io.Copy(&snapshot, ringBuffer) 4110 err = &smithy.DeserializationError{ 4111 Err: fmt.Errorf("failed to decode response body, %w", err), 4112 Snapshot: snapshot.Bytes(), 4113 } 4114 return out, metadata, err 4115 } 4116 4117 return out, metadata, err 4118} 4119 4120func awsAwsjson11_deserializeOpErrorUpdateApp(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4121 var errorBuffer bytes.Buffer 4122 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4123 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4124 } 4125 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4126 4127 errorCode := "UnknownError" 4128 errorMessage := errorCode 4129 4130 code := response.Header.Get("X-Amzn-ErrorType") 4131 if len(code) != 0 { 4132 errorCode = restjson.SanitizeErrorCode(code) 4133 } 4134 4135 var buff [1024]byte 4136 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4137 4138 body := io.TeeReader(errorBody, ringBuffer) 4139 decoder := json.NewDecoder(body) 4140 decoder.UseNumber() 4141 code, message, err := restjson.GetErrorInfo(decoder) 4142 if err != nil { 4143 var snapshot bytes.Buffer 4144 io.Copy(&snapshot, ringBuffer) 4145 err = &smithy.DeserializationError{ 4146 Err: fmt.Errorf("failed to decode response body, %w", err), 4147 Snapshot: snapshot.Bytes(), 4148 } 4149 return err 4150 } 4151 4152 errorBody.Seek(0, io.SeekStart) 4153 if len(code) != 0 { 4154 errorCode = restjson.SanitizeErrorCode(code) 4155 } 4156 if len(message) != 0 { 4157 errorMessage = message 4158 } 4159 4160 switch { 4161 case strings.EqualFold("InternalError", errorCode): 4162 return awsAwsjson11_deserializeErrorInternalError(response, errorBody) 4163 4164 case strings.EqualFold("InvalidParameterException", errorCode): 4165 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 4166 4167 case strings.EqualFold("MissingRequiredParameterException", errorCode): 4168 return awsAwsjson11_deserializeErrorMissingRequiredParameterException(response, errorBody) 4169 4170 case strings.EqualFold("OperationNotPermittedException", errorCode): 4171 return awsAwsjson11_deserializeErrorOperationNotPermittedException(response, errorBody) 4172 4173 case strings.EqualFold("UnauthorizedOperationException", errorCode): 4174 return awsAwsjson11_deserializeErrorUnauthorizedOperationException(response, errorBody) 4175 4176 default: 4177 genericError := &smithy.GenericAPIError{ 4178 Code: errorCode, 4179 Message: errorMessage, 4180 } 4181 return genericError 4182 4183 } 4184} 4185 4186type awsAwsjson11_deserializeOpUpdateReplicationJob struct { 4187} 4188 4189func (*awsAwsjson11_deserializeOpUpdateReplicationJob) ID() string { 4190 return "OperationDeserializer" 4191} 4192 4193func (m *awsAwsjson11_deserializeOpUpdateReplicationJob) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4194 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4195) { 4196 out, metadata, err = next.HandleDeserialize(ctx, in) 4197 if err != nil { 4198 return out, metadata, err 4199 } 4200 4201 response, ok := out.RawResponse.(*smithyhttp.Response) 4202 if !ok { 4203 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4204 } 4205 4206 if response.StatusCode < 200 || response.StatusCode >= 300 { 4207 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateReplicationJob(response, &metadata) 4208 } 4209 output := &UpdateReplicationJobOutput{} 4210 out.Result = output 4211 4212 var buff [1024]byte 4213 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4214 4215 body := io.TeeReader(response.Body, ringBuffer) 4216 decoder := json.NewDecoder(body) 4217 decoder.UseNumber() 4218 var shape interface{} 4219 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4220 var snapshot bytes.Buffer 4221 io.Copy(&snapshot, ringBuffer) 4222 err = &smithy.DeserializationError{ 4223 Err: fmt.Errorf("failed to decode response body, %w", err), 4224 Snapshot: snapshot.Bytes(), 4225 } 4226 return out, metadata, err 4227 } 4228 4229 err = awsAwsjson11_deserializeOpDocumentUpdateReplicationJobOutput(&output, shape) 4230 if err != nil { 4231 var snapshot bytes.Buffer 4232 io.Copy(&snapshot, ringBuffer) 4233 err = &smithy.DeserializationError{ 4234 Err: fmt.Errorf("failed to decode response body, %w", err), 4235 Snapshot: snapshot.Bytes(), 4236 } 4237 return out, metadata, err 4238 } 4239 4240 return out, metadata, err 4241} 4242 4243func awsAwsjson11_deserializeOpErrorUpdateReplicationJob(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4244 var errorBuffer bytes.Buffer 4245 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4246 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4247 } 4248 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4249 4250 errorCode := "UnknownError" 4251 errorMessage := errorCode 4252 4253 code := response.Header.Get("X-Amzn-ErrorType") 4254 if len(code) != 0 { 4255 errorCode = restjson.SanitizeErrorCode(code) 4256 } 4257 4258 var buff [1024]byte 4259 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4260 4261 body := io.TeeReader(errorBody, ringBuffer) 4262 decoder := json.NewDecoder(body) 4263 decoder.UseNumber() 4264 code, message, err := restjson.GetErrorInfo(decoder) 4265 if err != nil { 4266 var snapshot bytes.Buffer 4267 io.Copy(&snapshot, ringBuffer) 4268 err = &smithy.DeserializationError{ 4269 Err: fmt.Errorf("failed to decode response body, %w", err), 4270 Snapshot: snapshot.Bytes(), 4271 } 4272 return err 4273 } 4274 4275 errorBody.Seek(0, io.SeekStart) 4276 if len(code) != 0 { 4277 errorCode = restjson.SanitizeErrorCode(code) 4278 } 4279 if len(message) != 0 { 4280 errorMessage = message 4281 } 4282 4283 switch { 4284 case strings.EqualFold("InternalError", errorCode): 4285 return awsAwsjson11_deserializeErrorInternalError(response, errorBody) 4286 4287 case strings.EqualFold("InvalidParameterException", errorCode): 4288 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 4289 4290 case strings.EqualFold("MissingRequiredParameterException", errorCode): 4291 return awsAwsjson11_deserializeErrorMissingRequiredParameterException(response, errorBody) 4292 4293 case strings.EqualFold("OperationNotPermittedException", errorCode): 4294 return awsAwsjson11_deserializeErrorOperationNotPermittedException(response, errorBody) 4295 4296 case strings.EqualFold("ReplicationJobNotFoundException", errorCode): 4297 return awsAwsjson11_deserializeErrorReplicationJobNotFoundException(response, errorBody) 4298 4299 case strings.EqualFold("ServerCannotBeReplicatedException", errorCode): 4300 return awsAwsjson11_deserializeErrorServerCannotBeReplicatedException(response, errorBody) 4301 4302 case strings.EqualFold("TemporarilyUnavailableException", errorCode): 4303 return awsAwsjson11_deserializeErrorTemporarilyUnavailableException(response, errorBody) 4304 4305 case strings.EqualFold("UnauthorizedOperationException", errorCode): 4306 return awsAwsjson11_deserializeErrorUnauthorizedOperationException(response, errorBody) 4307 4308 default: 4309 genericError := &smithy.GenericAPIError{ 4310 Code: errorCode, 4311 Message: errorMessage, 4312 } 4313 return genericError 4314 4315 } 4316} 4317 4318func awsAwsjson11_deserializeErrorDryRunOperationException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4319 var buff [1024]byte 4320 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4321 4322 body := io.TeeReader(errorBody, ringBuffer) 4323 decoder := json.NewDecoder(body) 4324 decoder.UseNumber() 4325 var shape interface{} 4326 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4327 var snapshot bytes.Buffer 4328 io.Copy(&snapshot, ringBuffer) 4329 err = &smithy.DeserializationError{ 4330 Err: fmt.Errorf("failed to decode response body, %w", err), 4331 Snapshot: snapshot.Bytes(), 4332 } 4333 return err 4334 } 4335 4336 output := &types.DryRunOperationException{} 4337 err := awsAwsjson11_deserializeDocumentDryRunOperationException(&output, shape) 4338 4339 if err != nil { 4340 var snapshot bytes.Buffer 4341 io.Copy(&snapshot, ringBuffer) 4342 err = &smithy.DeserializationError{ 4343 Err: fmt.Errorf("failed to decode response body, %w", err), 4344 Snapshot: snapshot.Bytes(), 4345 } 4346 return err 4347 } 4348 4349 errorBody.Seek(0, io.SeekStart) 4350 return output 4351} 4352 4353func awsAwsjson11_deserializeErrorInternalError(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4354 var buff [1024]byte 4355 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4356 4357 body := io.TeeReader(errorBody, ringBuffer) 4358 decoder := json.NewDecoder(body) 4359 decoder.UseNumber() 4360 var shape interface{} 4361 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4362 var snapshot bytes.Buffer 4363 io.Copy(&snapshot, ringBuffer) 4364 err = &smithy.DeserializationError{ 4365 Err: fmt.Errorf("failed to decode response body, %w", err), 4366 Snapshot: snapshot.Bytes(), 4367 } 4368 return err 4369 } 4370 4371 output := &types.InternalError{} 4372 err := awsAwsjson11_deserializeDocumentInternalError(&output, shape) 4373 4374 if err != nil { 4375 var snapshot bytes.Buffer 4376 io.Copy(&snapshot, ringBuffer) 4377 err = &smithy.DeserializationError{ 4378 Err: fmt.Errorf("failed to decode response body, %w", err), 4379 Snapshot: snapshot.Bytes(), 4380 } 4381 return err 4382 } 4383 4384 errorBody.Seek(0, io.SeekStart) 4385 return output 4386} 4387 4388func awsAwsjson11_deserializeErrorInvalidParameterException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4389 var buff [1024]byte 4390 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4391 4392 body := io.TeeReader(errorBody, ringBuffer) 4393 decoder := json.NewDecoder(body) 4394 decoder.UseNumber() 4395 var shape interface{} 4396 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4397 var snapshot bytes.Buffer 4398 io.Copy(&snapshot, ringBuffer) 4399 err = &smithy.DeserializationError{ 4400 Err: fmt.Errorf("failed to decode response body, %w", err), 4401 Snapshot: snapshot.Bytes(), 4402 } 4403 return err 4404 } 4405 4406 output := &types.InvalidParameterException{} 4407 err := awsAwsjson11_deserializeDocumentInvalidParameterException(&output, shape) 4408 4409 if err != nil { 4410 var snapshot bytes.Buffer 4411 io.Copy(&snapshot, ringBuffer) 4412 err = &smithy.DeserializationError{ 4413 Err: fmt.Errorf("failed to decode response body, %w", err), 4414 Snapshot: snapshot.Bytes(), 4415 } 4416 return err 4417 } 4418 4419 errorBody.Seek(0, io.SeekStart) 4420 return output 4421} 4422 4423func awsAwsjson11_deserializeErrorMissingRequiredParameterException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4424 var buff [1024]byte 4425 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4426 4427 body := io.TeeReader(errorBody, ringBuffer) 4428 decoder := json.NewDecoder(body) 4429 decoder.UseNumber() 4430 var shape interface{} 4431 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4432 var snapshot bytes.Buffer 4433 io.Copy(&snapshot, ringBuffer) 4434 err = &smithy.DeserializationError{ 4435 Err: fmt.Errorf("failed to decode response body, %w", err), 4436 Snapshot: snapshot.Bytes(), 4437 } 4438 return err 4439 } 4440 4441 output := &types.MissingRequiredParameterException{} 4442 err := awsAwsjson11_deserializeDocumentMissingRequiredParameterException(&output, shape) 4443 4444 if err != nil { 4445 var snapshot bytes.Buffer 4446 io.Copy(&snapshot, ringBuffer) 4447 err = &smithy.DeserializationError{ 4448 Err: fmt.Errorf("failed to decode response body, %w", err), 4449 Snapshot: snapshot.Bytes(), 4450 } 4451 return err 4452 } 4453 4454 errorBody.Seek(0, io.SeekStart) 4455 return output 4456} 4457 4458func awsAwsjson11_deserializeErrorNoConnectorsAvailableException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4459 var buff [1024]byte 4460 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4461 4462 body := io.TeeReader(errorBody, ringBuffer) 4463 decoder := json.NewDecoder(body) 4464 decoder.UseNumber() 4465 var shape interface{} 4466 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4467 var snapshot bytes.Buffer 4468 io.Copy(&snapshot, ringBuffer) 4469 err = &smithy.DeserializationError{ 4470 Err: fmt.Errorf("failed to decode response body, %w", err), 4471 Snapshot: snapshot.Bytes(), 4472 } 4473 return err 4474 } 4475 4476 output := &types.NoConnectorsAvailableException{} 4477 err := awsAwsjson11_deserializeDocumentNoConnectorsAvailableException(&output, shape) 4478 4479 if err != nil { 4480 var snapshot bytes.Buffer 4481 io.Copy(&snapshot, ringBuffer) 4482 err = &smithy.DeserializationError{ 4483 Err: fmt.Errorf("failed to decode response body, %w", err), 4484 Snapshot: snapshot.Bytes(), 4485 } 4486 return err 4487 } 4488 4489 errorBody.Seek(0, io.SeekStart) 4490 return output 4491} 4492 4493func awsAwsjson11_deserializeErrorOperationNotPermittedException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4494 var buff [1024]byte 4495 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4496 4497 body := io.TeeReader(errorBody, ringBuffer) 4498 decoder := json.NewDecoder(body) 4499 decoder.UseNumber() 4500 var shape interface{} 4501 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4502 var snapshot bytes.Buffer 4503 io.Copy(&snapshot, ringBuffer) 4504 err = &smithy.DeserializationError{ 4505 Err: fmt.Errorf("failed to decode response body, %w", err), 4506 Snapshot: snapshot.Bytes(), 4507 } 4508 return err 4509 } 4510 4511 output := &types.OperationNotPermittedException{} 4512 err := awsAwsjson11_deserializeDocumentOperationNotPermittedException(&output, shape) 4513 4514 if err != nil { 4515 var snapshot bytes.Buffer 4516 io.Copy(&snapshot, ringBuffer) 4517 err = &smithy.DeserializationError{ 4518 Err: fmt.Errorf("failed to decode response body, %w", err), 4519 Snapshot: snapshot.Bytes(), 4520 } 4521 return err 4522 } 4523 4524 errorBody.Seek(0, io.SeekStart) 4525 return output 4526} 4527 4528func awsAwsjson11_deserializeErrorReplicationJobAlreadyExistsException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4529 var buff [1024]byte 4530 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4531 4532 body := io.TeeReader(errorBody, ringBuffer) 4533 decoder := json.NewDecoder(body) 4534 decoder.UseNumber() 4535 var shape interface{} 4536 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4537 var snapshot bytes.Buffer 4538 io.Copy(&snapshot, ringBuffer) 4539 err = &smithy.DeserializationError{ 4540 Err: fmt.Errorf("failed to decode response body, %w", err), 4541 Snapshot: snapshot.Bytes(), 4542 } 4543 return err 4544 } 4545 4546 output := &types.ReplicationJobAlreadyExistsException{} 4547 err := awsAwsjson11_deserializeDocumentReplicationJobAlreadyExistsException(&output, shape) 4548 4549 if err != nil { 4550 var snapshot bytes.Buffer 4551 io.Copy(&snapshot, ringBuffer) 4552 err = &smithy.DeserializationError{ 4553 Err: fmt.Errorf("failed to decode response body, %w", err), 4554 Snapshot: snapshot.Bytes(), 4555 } 4556 return err 4557 } 4558 4559 errorBody.Seek(0, io.SeekStart) 4560 return output 4561} 4562 4563func awsAwsjson11_deserializeErrorReplicationJobNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4564 var buff [1024]byte 4565 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4566 4567 body := io.TeeReader(errorBody, ringBuffer) 4568 decoder := json.NewDecoder(body) 4569 decoder.UseNumber() 4570 var shape interface{} 4571 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4572 var snapshot bytes.Buffer 4573 io.Copy(&snapshot, ringBuffer) 4574 err = &smithy.DeserializationError{ 4575 Err: fmt.Errorf("failed to decode response body, %w", err), 4576 Snapshot: snapshot.Bytes(), 4577 } 4578 return err 4579 } 4580 4581 output := &types.ReplicationJobNotFoundException{} 4582 err := awsAwsjson11_deserializeDocumentReplicationJobNotFoundException(&output, shape) 4583 4584 if err != nil { 4585 var snapshot bytes.Buffer 4586 io.Copy(&snapshot, ringBuffer) 4587 err = &smithy.DeserializationError{ 4588 Err: fmt.Errorf("failed to decode response body, %w", err), 4589 Snapshot: snapshot.Bytes(), 4590 } 4591 return err 4592 } 4593 4594 errorBody.Seek(0, io.SeekStart) 4595 return output 4596} 4597 4598func awsAwsjson11_deserializeErrorReplicationRunLimitExceededException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4599 var buff [1024]byte 4600 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4601 4602 body := io.TeeReader(errorBody, ringBuffer) 4603 decoder := json.NewDecoder(body) 4604 decoder.UseNumber() 4605 var shape interface{} 4606 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4607 var snapshot bytes.Buffer 4608 io.Copy(&snapshot, ringBuffer) 4609 err = &smithy.DeserializationError{ 4610 Err: fmt.Errorf("failed to decode response body, %w", err), 4611 Snapshot: snapshot.Bytes(), 4612 } 4613 return err 4614 } 4615 4616 output := &types.ReplicationRunLimitExceededException{} 4617 err := awsAwsjson11_deserializeDocumentReplicationRunLimitExceededException(&output, shape) 4618 4619 if err != nil { 4620 var snapshot bytes.Buffer 4621 io.Copy(&snapshot, ringBuffer) 4622 err = &smithy.DeserializationError{ 4623 Err: fmt.Errorf("failed to decode response body, %w", err), 4624 Snapshot: snapshot.Bytes(), 4625 } 4626 return err 4627 } 4628 4629 errorBody.Seek(0, io.SeekStart) 4630 return output 4631} 4632 4633func awsAwsjson11_deserializeErrorServerCannotBeReplicatedException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4634 var buff [1024]byte 4635 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4636 4637 body := io.TeeReader(errorBody, ringBuffer) 4638 decoder := json.NewDecoder(body) 4639 decoder.UseNumber() 4640 var shape interface{} 4641 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4642 var snapshot bytes.Buffer 4643 io.Copy(&snapshot, ringBuffer) 4644 err = &smithy.DeserializationError{ 4645 Err: fmt.Errorf("failed to decode response body, %w", err), 4646 Snapshot: snapshot.Bytes(), 4647 } 4648 return err 4649 } 4650 4651 output := &types.ServerCannotBeReplicatedException{} 4652 err := awsAwsjson11_deserializeDocumentServerCannotBeReplicatedException(&output, shape) 4653 4654 if err != nil { 4655 var snapshot bytes.Buffer 4656 io.Copy(&snapshot, ringBuffer) 4657 err = &smithy.DeserializationError{ 4658 Err: fmt.Errorf("failed to decode response body, %w", err), 4659 Snapshot: snapshot.Bytes(), 4660 } 4661 return err 4662 } 4663 4664 errorBody.Seek(0, io.SeekStart) 4665 return output 4666} 4667 4668func awsAwsjson11_deserializeErrorTemporarilyUnavailableException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4669 var buff [1024]byte 4670 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4671 4672 body := io.TeeReader(errorBody, ringBuffer) 4673 decoder := json.NewDecoder(body) 4674 decoder.UseNumber() 4675 var shape interface{} 4676 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4677 var snapshot bytes.Buffer 4678 io.Copy(&snapshot, ringBuffer) 4679 err = &smithy.DeserializationError{ 4680 Err: fmt.Errorf("failed to decode response body, %w", err), 4681 Snapshot: snapshot.Bytes(), 4682 } 4683 return err 4684 } 4685 4686 output := &types.TemporarilyUnavailableException{} 4687 err := awsAwsjson11_deserializeDocumentTemporarilyUnavailableException(&output, shape) 4688 4689 if err != nil { 4690 var snapshot bytes.Buffer 4691 io.Copy(&snapshot, ringBuffer) 4692 err = &smithy.DeserializationError{ 4693 Err: fmt.Errorf("failed to decode response body, %w", err), 4694 Snapshot: snapshot.Bytes(), 4695 } 4696 return err 4697 } 4698 4699 errorBody.Seek(0, io.SeekStart) 4700 return output 4701} 4702 4703func awsAwsjson11_deserializeErrorUnauthorizedOperationException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4704 var buff [1024]byte 4705 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4706 4707 body := io.TeeReader(errorBody, ringBuffer) 4708 decoder := json.NewDecoder(body) 4709 decoder.UseNumber() 4710 var shape interface{} 4711 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4712 var snapshot bytes.Buffer 4713 io.Copy(&snapshot, ringBuffer) 4714 err = &smithy.DeserializationError{ 4715 Err: fmt.Errorf("failed to decode response body, %w", err), 4716 Snapshot: snapshot.Bytes(), 4717 } 4718 return err 4719 } 4720 4721 output := &types.UnauthorizedOperationException{} 4722 err := awsAwsjson11_deserializeDocumentUnauthorizedOperationException(&output, shape) 4723 4724 if err != nil { 4725 var snapshot bytes.Buffer 4726 io.Copy(&snapshot, ringBuffer) 4727 err = &smithy.DeserializationError{ 4728 Err: fmt.Errorf("failed to decode response body, %w", err), 4729 Snapshot: snapshot.Bytes(), 4730 } 4731 return err 4732 } 4733 4734 errorBody.Seek(0, io.SeekStart) 4735 return output 4736} 4737 4738func awsAwsjson11_deserializeDocumentApps(v *[]types.AppSummary, value interface{}) error { 4739 if v == nil { 4740 return fmt.Errorf("unexpected nil of type %T", v) 4741 } 4742 if value == nil { 4743 return nil 4744 } 4745 4746 shape, ok := value.([]interface{}) 4747 if !ok { 4748 return fmt.Errorf("unexpected JSON type %v", value) 4749 } 4750 4751 var cv []types.AppSummary 4752 if *v == nil { 4753 cv = []types.AppSummary{} 4754 } else { 4755 cv = *v 4756 } 4757 4758 for _, value := range shape { 4759 var col types.AppSummary 4760 destAddr := &col 4761 if err := awsAwsjson11_deserializeDocumentAppSummary(&destAddr, value); err != nil { 4762 return err 4763 } 4764 col = *destAddr 4765 cv = append(cv, col) 4766 4767 } 4768 *v = cv 4769 return nil 4770} 4771 4772func awsAwsjson11_deserializeDocumentAppSummary(v **types.AppSummary, value interface{}) error { 4773 if v == nil { 4774 return fmt.Errorf("unexpected nil of type %T", v) 4775 } 4776 if value == nil { 4777 return nil 4778 } 4779 4780 shape, ok := value.(map[string]interface{}) 4781 if !ok { 4782 return fmt.Errorf("unexpected JSON type %v", value) 4783 } 4784 4785 var sv *types.AppSummary 4786 if *v == nil { 4787 sv = &types.AppSummary{} 4788 } else { 4789 sv = *v 4790 } 4791 4792 for key, value := range shape { 4793 switch key { 4794 case "appId": 4795 if value != nil { 4796 jtv, ok := value.(string) 4797 if !ok { 4798 return fmt.Errorf("expected AppId to be of type string, got %T instead", value) 4799 } 4800 sv.AppId = ptr.String(jtv) 4801 } 4802 4803 case "creationTime": 4804 if value != nil { 4805 switch jtv := value.(type) { 4806 case json.Number: 4807 f64, err := jtv.Float64() 4808 if err != nil { 4809 return err 4810 } 4811 sv.CreationTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 4812 4813 default: 4814 return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value) 4815 4816 } 4817 } 4818 4819 case "description": 4820 if value != nil { 4821 jtv, ok := value.(string) 4822 if !ok { 4823 return fmt.Errorf("expected AppDescription to be of type string, got %T instead", value) 4824 } 4825 sv.Description = ptr.String(jtv) 4826 } 4827 4828 case "importedAppId": 4829 if value != nil { 4830 jtv, ok := value.(string) 4831 if !ok { 4832 return fmt.Errorf("expected ImportedAppId to be of type string, got %T instead", value) 4833 } 4834 sv.ImportedAppId = ptr.String(jtv) 4835 } 4836 4837 case "lastModified": 4838 if value != nil { 4839 switch jtv := value.(type) { 4840 case json.Number: 4841 f64, err := jtv.Float64() 4842 if err != nil { 4843 return err 4844 } 4845 sv.LastModified = ptr.Time(smithytime.ParseEpochSeconds(f64)) 4846 4847 default: 4848 return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value) 4849 4850 } 4851 } 4852 4853 case "latestReplicationTime": 4854 if value != nil { 4855 switch jtv := value.(type) { 4856 case json.Number: 4857 f64, err := jtv.Float64() 4858 if err != nil { 4859 return err 4860 } 4861 sv.LatestReplicationTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 4862 4863 default: 4864 return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value) 4865 4866 } 4867 } 4868 4869 case "launchConfigurationStatus": 4870 if value != nil { 4871 jtv, ok := value.(string) 4872 if !ok { 4873 return fmt.Errorf("expected AppLaunchConfigurationStatus to be of type string, got %T instead", value) 4874 } 4875 sv.LaunchConfigurationStatus = types.AppLaunchConfigurationStatus(jtv) 4876 } 4877 4878 case "launchDetails": 4879 if err := awsAwsjson11_deserializeDocumentLaunchDetails(&sv.LaunchDetails, value); err != nil { 4880 return err 4881 } 4882 4883 case "launchStatus": 4884 if value != nil { 4885 jtv, ok := value.(string) 4886 if !ok { 4887 return fmt.Errorf("expected AppLaunchStatus to be of type string, got %T instead", value) 4888 } 4889 sv.LaunchStatus = types.AppLaunchStatus(jtv) 4890 } 4891 4892 case "launchStatusMessage": 4893 if value != nil { 4894 jtv, ok := value.(string) 4895 if !ok { 4896 return fmt.Errorf("expected AppLaunchStatusMessage to be of type string, got %T instead", value) 4897 } 4898 sv.LaunchStatusMessage = ptr.String(jtv) 4899 } 4900 4901 case "name": 4902 if value != nil { 4903 jtv, ok := value.(string) 4904 if !ok { 4905 return fmt.Errorf("expected AppName to be of type string, got %T instead", value) 4906 } 4907 sv.Name = ptr.String(jtv) 4908 } 4909 4910 case "replicationConfigurationStatus": 4911 if value != nil { 4912 jtv, ok := value.(string) 4913 if !ok { 4914 return fmt.Errorf("expected AppReplicationConfigurationStatus to be of type string, got %T instead", value) 4915 } 4916 sv.ReplicationConfigurationStatus = types.AppReplicationConfigurationStatus(jtv) 4917 } 4918 4919 case "replicationStatus": 4920 if value != nil { 4921 jtv, ok := value.(string) 4922 if !ok { 4923 return fmt.Errorf("expected AppReplicationStatus to be of type string, got %T instead", value) 4924 } 4925 sv.ReplicationStatus = types.AppReplicationStatus(jtv) 4926 } 4927 4928 case "replicationStatusMessage": 4929 if value != nil { 4930 jtv, ok := value.(string) 4931 if !ok { 4932 return fmt.Errorf("expected AppReplicationStatusMessage to be of type string, got %T instead", value) 4933 } 4934 sv.ReplicationStatusMessage = ptr.String(jtv) 4935 } 4936 4937 case "roleName": 4938 if value != nil { 4939 jtv, ok := value.(string) 4940 if !ok { 4941 return fmt.Errorf("expected RoleName to be of type string, got %T instead", value) 4942 } 4943 sv.RoleName = ptr.String(jtv) 4944 } 4945 4946 case "status": 4947 if value != nil { 4948 jtv, ok := value.(string) 4949 if !ok { 4950 return fmt.Errorf("expected AppStatus to be of type string, got %T instead", value) 4951 } 4952 sv.Status = types.AppStatus(jtv) 4953 } 4954 4955 case "statusMessage": 4956 if value != nil { 4957 jtv, ok := value.(string) 4958 if !ok { 4959 return fmt.Errorf("expected AppStatusMessage to be of type string, got %T instead", value) 4960 } 4961 sv.StatusMessage = ptr.String(jtv) 4962 } 4963 4964 case "totalServerGroups": 4965 if value != nil { 4966 jtv, ok := value.(json.Number) 4967 if !ok { 4968 return fmt.Errorf("expected TotalServerGroups to be json.Number, got %T instead", value) 4969 } 4970 i64, err := jtv.Int64() 4971 if err != nil { 4972 return err 4973 } 4974 sv.TotalServerGroups = ptr.Int32(int32(i64)) 4975 } 4976 4977 case "totalServers": 4978 if value != nil { 4979 jtv, ok := value.(json.Number) 4980 if !ok { 4981 return fmt.Errorf("expected TotalServers to be json.Number, got %T instead", value) 4982 } 4983 i64, err := jtv.Int64() 4984 if err != nil { 4985 return err 4986 } 4987 sv.TotalServers = ptr.Int32(int32(i64)) 4988 } 4989 4990 default: 4991 _, _ = key, value 4992 4993 } 4994 } 4995 *v = sv 4996 return nil 4997} 4998 4999func awsAwsjson11_deserializeDocumentAppValidationConfiguration(v **types.AppValidationConfiguration, value interface{}) error { 5000 if v == nil { 5001 return fmt.Errorf("unexpected nil of type %T", v) 5002 } 5003 if value == nil { 5004 return nil 5005 } 5006 5007 shape, ok := value.(map[string]interface{}) 5008 if !ok { 5009 return fmt.Errorf("unexpected JSON type %v", value) 5010 } 5011 5012 var sv *types.AppValidationConfiguration 5013 if *v == nil { 5014 sv = &types.AppValidationConfiguration{} 5015 } else { 5016 sv = *v 5017 } 5018 5019 for key, value := range shape { 5020 switch key { 5021 case "appValidationStrategy": 5022 if value != nil { 5023 jtv, ok := value.(string) 5024 if !ok { 5025 return fmt.Errorf("expected AppValidationStrategy to be of type string, got %T instead", value) 5026 } 5027 sv.AppValidationStrategy = types.AppValidationStrategy(jtv) 5028 } 5029 5030 case "name": 5031 if value != nil { 5032 jtv, ok := value.(string) 5033 if !ok { 5034 return fmt.Errorf("expected NonEmptyStringWithMaxLen255 to be of type string, got %T instead", value) 5035 } 5036 sv.Name = ptr.String(jtv) 5037 } 5038 5039 case "ssmValidationParameters": 5040 if err := awsAwsjson11_deserializeDocumentSSMValidationParameters(&sv.SsmValidationParameters, value); err != nil { 5041 return err 5042 } 5043 5044 case "validationId": 5045 if value != nil { 5046 jtv, ok := value.(string) 5047 if !ok { 5048 return fmt.Errorf("expected ValidationId to be of type string, got %T instead", value) 5049 } 5050 sv.ValidationId = ptr.String(jtv) 5051 } 5052 5053 default: 5054 _, _ = key, value 5055 5056 } 5057 } 5058 *v = sv 5059 return nil 5060} 5061 5062func awsAwsjson11_deserializeDocumentAppValidationConfigurations(v *[]types.AppValidationConfiguration, value interface{}) error { 5063 if v == nil { 5064 return fmt.Errorf("unexpected nil of type %T", v) 5065 } 5066 if value == nil { 5067 return nil 5068 } 5069 5070 shape, ok := value.([]interface{}) 5071 if !ok { 5072 return fmt.Errorf("unexpected JSON type %v", value) 5073 } 5074 5075 var cv []types.AppValidationConfiguration 5076 if *v == nil { 5077 cv = []types.AppValidationConfiguration{} 5078 } else { 5079 cv = *v 5080 } 5081 5082 for _, value := range shape { 5083 var col types.AppValidationConfiguration 5084 destAddr := &col 5085 if err := awsAwsjson11_deserializeDocumentAppValidationConfiguration(&destAddr, value); err != nil { 5086 return err 5087 } 5088 col = *destAddr 5089 cv = append(cv, col) 5090 5091 } 5092 *v = cv 5093 return nil 5094} 5095 5096func awsAwsjson11_deserializeDocumentAppValidationOutput(v **types.AppValidationOutput, value interface{}) error { 5097 if v == nil { 5098 return fmt.Errorf("unexpected nil of type %T", v) 5099 } 5100 if value == nil { 5101 return nil 5102 } 5103 5104 shape, ok := value.(map[string]interface{}) 5105 if !ok { 5106 return fmt.Errorf("unexpected JSON type %v", value) 5107 } 5108 5109 var sv *types.AppValidationOutput 5110 if *v == nil { 5111 sv = &types.AppValidationOutput{} 5112 } else { 5113 sv = *v 5114 } 5115 5116 for key, value := range shape { 5117 switch key { 5118 case "ssmOutput": 5119 if err := awsAwsjson11_deserializeDocumentSSMOutput(&sv.SsmOutput, value); err != nil { 5120 return err 5121 } 5122 5123 default: 5124 _, _ = key, value 5125 5126 } 5127 } 5128 *v = sv 5129 return nil 5130} 5131 5132func awsAwsjson11_deserializeDocumentConnector(v **types.Connector, value interface{}) error { 5133 if v == nil { 5134 return fmt.Errorf("unexpected nil of type %T", v) 5135 } 5136 if value == nil { 5137 return nil 5138 } 5139 5140 shape, ok := value.(map[string]interface{}) 5141 if !ok { 5142 return fmt.Errorf("unexpected JSON type %v", value) 5143 } 5144 5145 var sv *types.Connector 5146 if *v == nil { 5147 sv = &types.Connector{} 5148 } else { 5149 sv = *v 5150 } 5151 5152 for key, value := range shape { 5153 switch key { 5154 case "associatedOn": 5155 if value != nil { 5156 switch jtv := value.(type) { 5157 case json.Number: 5158 f64, err := jtv.Float64() 5159 if err != nil { 5160 return err 5161 } 5162 sv.AssociatedOn = ptr.Time(smithytime.ParseEpochSeconds(f64)) 5163 5164 default: 5165 return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value) 5166 5167 } 5168 } 5169 5170 case "capabilityList": 5171 if err := awsAwsjson11_deserializeDocumentConnectorCapabilityList(&sv.CapabilityList, value); err != nil { 5172 return err 5173 } 5174 5175 case "connectorId": 5176 if value != nil { 5177 jtv, ok := value.(string) 5178 if !ok { 5179 return fmt.Errorf("expected ConnectorId to be of type string, got %T instead", value) 5180 } 5181 sv.ConnectorId = ptr.String(jtv) 5182 } 5183 5184 case "ipAddress": 5185 if value != nil { 5186 jtv, ok := value.(string) 5187 if !ok { 5188 return fmt.Errorf("expected IpAddress to be of type string, got %T instead", value) 5189 } 5190 sv.IpAddress = ptr.String(jtv) 5191 } 5192 5193 case "macAddress": 5194 if value != nil { 5195 jtv, ok := value.(string) 5196 if !ok { 5197 return fmt.Errorf("expected MacAddress to be of type string, got %T instead", value) 5198 } 5199 sv.MacAddress = ptr.String(jtv) 5200 } 5201 5202 case "status": 5203 if value != nil { 5204 jtv, ok := value.(string) 5205 if !ok { 5206 return fmt.Errorf("expected ConnectorStatus to be of type string, got %T instead", value) 5207 } 5208 sv.Status = types.ConnectorStatus(jtv) 5209 } 5210 5211 case "version": 5212 if value != nil { 5213 jtv, ok := value.(string) 5214 if !ok { 5215 return fmt.Errorf("expected ConnectorVersion to be of type string, got %T instead", value) 5216 } 5217 sv.Version = ptr.String(jtv) 5218 } 5219 5220 case "vmManagerId": 5221 if value != nil { 5222 jtv, ok := value.(string) 5223 if !ok { 5224 return fmt.Errorf("expected VmManagerId to be of type string, got %T instead", value) 5225 } 5226 sv.VmManagerId = ptr.String(jtv) 5227 } 5228 5229 case "vmManagerName": 5230 if value != nil { 5231 jtv, ok := value.(string) 5232 if !ok { 5233 return fmt.Errorf("expected VmManagerName to be of type string, got %T instead", value) 5234 } 5235 sv.VmManagerName = ptr.String(jtv) 5236 } 5237 5238 case "vmManagerType": 5239 if value != nil { 5240 jtv, ok := value.(string) 5241 if !ok { 5242 return fmt.Errorf("expected VmManagerType to be of type string, got %T instead", value) 5243 } 5244 sv.VmManagerType = types.VmManagerType(jtv) 5245 } 5246 5247 default: 5248 _, _ = key, value 5249 5250 } 5251 } 5252 *v = sv 5253 return nil 5254} 5255 5256func awsAwsjson11_deserializeDocumentConnectorCapabilityList(v *[]types.ConnectorCapability, value interface{}) error { 5257 if v == nil { 5258 return fmt.Errorf("unexpected nil of type %T", v) 5259 } 5260 if value == nil { 5261 return nil 5262 } 5263 5264 shape, ok := value.([]interface{}) 5265 if !ok { 5266 return fmt.Errorf("unexpected JSON type %v", value) 5267 } 5268 5269 var cv []types.ConnectorCapability 5270 if *v == nil { 5271 cv = []types.ConnectorCapability{} 5272 } else { 5273 cv = *v 5274 } 5275 5276 for _, value := range shape { 5277 var col types.ConnectorCapability 5278 if value != nil { 5279 jtv, ok := value.(string) 5280 if !ok { 5281 return fmt.Errorf("expected ConnectorCapability to be of type string, got %T instead", value) 5282 } 5283 col = types.ConnectorCapability(jtv) 5284 } 5285 cv = append(cv, col) 5286 5287 } 5288 *v = cv 5289 return nil 5290} 5291 5292func awsAwsjson11_deserializeDocumentConnectorList(v *[]types.Connector, value interface{}) error { 5293 if v == nil { 5294 return fmt.Errorf("unexpected nil of type %T", v) 5295 } 5296 if value == nil { 5297 return nil 5298 } 5299 5300 shape, ok := value.([]interface{}) 5301 if !ok { 5302 return fmt.Errorf("unexpected JSON type %v", value) 5303 } 5304 5305 var cv []types.Connector 5306 if *v == nil { 5307 cv = []types.Connector{} 5308 } else { 5309 cv = *v 5310 } 5311 5312 for _, value := range shape { 5313 var col types.Connector 5314 destAddr := &col 5315 if err := awsAwsjson11_deserializeDocumentConnector(&destAddr, value); err != nil { 5316 return err 5317 } 5318 col = *destAddr 5319 cv = append(cv, col) 5320 5321 } 5322 *v = cv 5323 return nil 5324} 5325 5326func awsAwsjson11_deserializeDocumentDryRunOperationException(v **types.DryRunOperationException, value interface{}) error { 5327 if v == nil { 5328 return fmt.Errorf("unexpected nil of type %T", v) 5329 } 5330 if value == nil { 5331 return nil 5332 } 5333 5334 shape, ok := value.(map[string]interface{}) 5335 if !ok { 5336 return fmt.Errorf("unexpected JSON type %v", value) 5337 } 5338 5339 var sv *types.DryRunOperationException 5340 if *v == nil { 5341 sv = &types.DryRunOperationException{} 5342 } else { 5343 sv = *v 5344 } 5345 5346 for key, value := range shape { 5347 switch key { 5348 case "message": 5349 if value != nil { 5350 jtv, ok := value.(string) 5351 if !ok { 5352 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 5353 } 5354 sv.Message = ptr.String(jtv) 5355 } 5356 5357 default: 5358 _, _ = key, value 5359 5360 } 5361 } 5362 *v = sv 5363 return nil 5364} 5365 5366func awsAwsjson11_deserializeDocumentInternalError(v **types.InternalError, value interface{}) error { 5367 if v == nil { 5368 return fmt.Errorf("unexpected nil of type %T", v) 5369 } 5370 if value == nil { 5371 return nil 5372 } 5373 5374 shape, ok := value.(map[string]interface{}) 5375 if !ok { 5376 return fmt.Errorf("unexpected JSON type %v", value) 5377 } 5378 5379 var sv *types.InternalError 5380 if *v == nil { 5381 sv = &types.InternalError{} 5382 } else { 5383 sv = *v 5384 } 5385 5386 for key, value := range shape { 5387 switch key { 5388 case "message": 5389 if value != nil { 5390 jtv, ok := value.(string) 5391 if !ok { 5392 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 5393 } 5394 sv.Message = ptr.String(jtv) 5395 } 5396 5397 default: 5398 _, _ = key, value 5399 5400 } 5401 } 5402 *v = sv 5403 return nil 5404} 5405 5406func awsAwsjson11_deserializeDocumentInvalidParameterException(v **types.InvalidParameterException, value interface{}) error { 5407 if v == nil { 5408 return fmt.Errorf("unexpected nil of type %T", v) 5409 } 5410 if value == nil { 5411 return nil 5412 } 5413 5414 shape, ok := value.(map[string]interface{}) 5415 if !ok { 5416 return fmt.Errorf("unexpected JSON type %v", value) 5417 } 5418 5419 var sv *types.InvalidParameterException 5420 if *v == nil { 5421 sv = &types.InvalidParameterException{} 5422 } else { 5423 sv = *v 5424 } 5425 5426 for key, value := range shape { 5427 switch key { 5428 case "message": 5429 if value != nil { 5430 jtv, ok := value.(string) 5431 if !ok { 5432 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 5433 } 5434 sv.Message = ptr.String(jtv) 5435 } 5436 5437 default: 5438 _, _ = key, value 5439 5440 } 5441 } 5442 *v = sv 5443 return nil 5444} 5445 5446func awsAwsjson11_deserializeDocumentLaunchDetails(v **types.LaunchDetails, value interface{}) error { 5447 if v == nil { 5448 return fmt.Errorf("unexpected nil of type %T", v) 5449 } 5450 if value == nil { 5451 return nil 5452 } 5453 5454 shape, ok := value.(map[string]interface{}) 5455 if !ok { 5456 return fmt.Errorf("unexpected JSON type %v", value) 5457 } 5458 5459 var sv *types.LaunchDetails 5460 if *v == nil { 5461 sv = &types.LaunchDetails{} 5462 } else { 5463 sv = *v 5464 } 5465 5466 for key, value := range shape { 5467 switch key { 5468 case "latestLaunchTime": 5469 if value != nil { 5470 switch jtv := value.(type) { 5471 case json.Number: 5472 f64, err := jtv.Float64() 5473 if err != nil { 5474 return err 5475 } 5476 sv.LatestLaunchTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 5477 5478 default: 5479 return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value) 5480 5481 } 5482 } 5483 5484 case "stackId": 5485 if value != nil { 5486 jtv, ok := value.(string) 5487 if !ok { 5488 return fmt.Errorf("expected StackId to be of type string, got %T instead", value) 5489 } 5490 sv.StackId = ptr.String(jtv) 5491 } 5492 5493 case "stackName": 5494 if value != nil { 5495 jtv, ok := value.(string) 5496 if !ok { 5497 return fmt.Errorf("expected StackName to be of type string, got %T instead", value) 5498 } 5499 sv.StackName = ptr.String(jtv) 5500 } 5501 5502 default: 5503 _, _ = key, value 5504 5505 } 5506 } 5507 *v = sv 5508 return nil 5509} 5510 5511func awsAwsjson11_deserializeDocumentMissingRequiredParameterException(v **types.MissingRequiredParameterException, value interface{}) error { 5512 if v == nil { 5513 return fmt.Errorf("unexpected nil of type %T", v) 5514 } 5515 if value == nil { 5516 return nil 5517 } 5518 5519 shape, ok := value.(map[string]interface{}) 5520 if !ok { 5521 return fmt.Errorf("unexpected JSON type %v", value) 5522 } 5523 5524 var sv *types.MissingRequiredParameterException 5525 if *v == nil { 5526 sv = &types.MissingRequiredParameterException{} 5527 } else { 5528 sv = *v 5529 } 5530 5531 for key, value := range shape { 5532 switch key { 5533 case "message": 5534 if value != nil { 5535 jtv, ok := value.(string) 5536 if !ok { 5537 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 5538 } 5539 sv.Message = ptr.String(jtv) 5540 } 5541 5542 default: 5543 _, _ = key, value 5544 5545 } 5546 } 5547 *v = sv 5548 return nil 5549} 5550 5551func awsAwsjson11_deserializeDocumentNoConnectorsAvailableException(v **types.NoConnectorsAvailableException, value interface{}) error { 5552 if v == nil { 5553 return fmt.Errorf("unexpected nil of type %T", v) 5554 } 5555 if value == nil { 5556 return nil 5557 } 5558 5559 shape, ok := value.(map[string]interface{}) 5560 if !ok { 5561 return fmt.Errorf("unexpected JSON type %v", value) 5562 } 5563 5564 var sv *types.NoConnectorsAvailableException 5565 if *v == nil { 5566 sv = &types.NoConnectorsAvailableException{} 5567 } else { 5568 sv = *v 5569 } 5570 5571 for key, value := range shape { 5572 switch key { 5573 case "message": 5574 if value != nil { 5575 jtv, ok := value.(string) 5576 if !ok { 5577 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 5578 } 5579 sv.Message = ptr.String(jtv) 5580 } 5581 5582 default: 5583 _, _ = key, value 5584 5585 } 5586 } 5587 *v = sv 5588 return nil 5589} 5590 5591func awsAwsjson11_deserializeDocumentOperationNotPermittedException(v **types.OperationNotPermittedException, value interface{}) error { 5592 if v == nil { 5593 return fmt.Errorf("unexpected nil of type %T", v) 5594 } 5595 if value == nil { 5596 return nil 5597 } 5598 5599 shape, ok := value.(map[string]interface{}) 5600 if !ok { 5601 return fmt.Errorf("unexpected JSON type %v", value) 5602 } 5603 5604 var sv *types.OperationNotPermittedException 5605 if *v == nil { 5606 sv = &types.OperationNotPermittedException{} 5607 } else { 5608 sv = *v 5609 } 5610 5611 for key, value := range shape { 5612 switch key { 5613 case "message": 5614 if value != nil { 5615 jtv, ok := value.(string) 5616 if !ok { 5617 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 5618 } 5619 sv.Message = ptr.String(jtv) 5620 } 5621 5622 default: 5623 _, _ = key, value 5624 5625 } 5626 } 5627 *v = sv 5628 return nil 5629} 5630 5631func awsAwsjson11_deserializeDocumentReplicationJob(v **types.ReplicationJob, value interface{}) error { 5632 if v == nil { 5633 return fmt.Errorf("unexpected nil of type %T", v) 5634 } 5635 if value == nil { 5636 return nil 5637 } 5638 5639 shape, ok := value.(map[string]interface{}) 5640 if !ok { 5641 return fmt.Errorf("unexpected JSON type %v", value) 5642 } 5643 5644 var sv *types.ReplicationJob 5645 if *v == nil { 5646 sv = &types.ReplicationJob{} 5647 } else { 5648 sv = *v 5649 } 5650 5651 for key, value := range shape { 5652 switch key { 5653 case "description": 5654 if value != nil { 5655 jtv, ok := value.(string) 5656 if !ok { 5657 return fmt.Errorf("expected Description to be of type string, got %T instead", value) 5658 } 5659 sv.Description = ptr.String(jtv) 5660 } 5661 5662 case "encrypted": 5663 if value != nil { 5664 jtv, ok := value.(bool) 5665 if !ok { 5666 return fmt.Errorf("expected Encrypted to be of type *bool, got %T instead", value) 5667 } 5668 sv.Encrypted = ptr.Bool(jtv) 5669 } 5670 5671 case "frequency": 5672 if value != nil { 5673 jtv, ok := value.(json.Number) 5674 if !ok { 5675 return fmt.Errorf("expected Frequency to be json.Number, got %T instead", value) 5676 } 5677 i64, err := jtv.Int64() 5678 if err != nil { 5679 return err 5680 } 5681 sv.Frequency = ptr.Int32(int32(i64)) 5682 } 5683 5684 case "kmsKeyId": 5685 if value != nil { 5686 jtv, ok := value.(string) 5687 if !ok { 5688 return fmt.Errorf("expected KmsKeyId to be of type string, got %T instead", value) 5689 } 5690 sv.KmsKeyId = ptr.String(jtv) 5691 } 5692 5693 case "latestAmiId": 5694 if value != nil { 5695 jtv, ok := value.(string) 5696 if !ok { 5697 return fmt.Errorf("expected AmiId to be of type string, got %T instead", value) 5698 } 5699 sv.LatestAmiId = ptr.String(jtv) 5700 } 5701 5702 case "licenseType": 5703 if value != nil { 5704 jtv, ok := value.(string) 5705 if !ok { 5706 return fmt.Errorf("expected LicenseType to be of type string, got %T instead", value) 5707 } 5708 sv.LicenseType = types.LicenseType(jtv) 5709 } 5710 5711 case "nextReplicationRunStartTime": 5712 if value != nil { 5713 switch jtv := value.(type) { 5714 case json.Number: 5715 f64, err := jtv.Float64() 5716 if err != nil { 5717 return err 5718 } 5719 sv.NextReplicationRunStartTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 5720 5721 default: 5722 return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value) 5723 5724 } 5725 } 5726 5727 case "numberOfRecentAmisToKeep": 5728 if value != nil { 5729 jtv, ok := value.(json.Number) 5730 if !ok { 5731 return fmt.Errorf("expected NumberOfRecentAmisToKeep to be json.Number, got %T instead", value) 5732 } 5733 i64, err := jtv.Int64() 5734 if err != nil { 5735 return err 5736 } 5737 sv.NumberOfRecentAmisToKeep = ptr.Int32(int32(i64)) 5738 } 5739 5740 case "replicationJobId": 5741 if value != nil { 5742 jtv, ok := value.(string) 5743 if !ok { 5744 return fmt.Errorf("expected ReplicationJobId to be of type string, got %T instead", value) 5745 } 5746 sv.ReplicationJobId = ptr.String(jtv) 5747 } 5748 5749 case "replicationRunList": 5750 if err := awsAwsjson11_deserializeDocumentReplicationRunList(&sv.ReplicationRunList, value); err != nil { 5751 return err 5752 } 5753 5754 case "roleName": 5755 if value != nil { 5756 jtv, ok := value.(string) 5757 if !ok { 5758 return fmt.Errorf("expected RoleName to be of type string, got %T instead", value) 5759 } 5760 sv.RoleName = ptr.String(jtv) 5761 } 5762 5763 case "runOnce": 5764 if value != nil { 5765 jtv, ok := value.(bool) 5766 if !ok { 5767 return fmt.Errorf("expected RunOnce to be of type *bool, got %T instead", value) 5768 } 5769 sv.RunOnce = ptr.Bool(jtv) 5770 } 5771 5772 case "seedReplicationTime": 5773 if value != nil { 5774 switch jtv := value.(type) { 5775 case json.Number: 5776 f64, err := jtv.Float64() 5777 if err != nil { 5778 return err 5779 } 5780 sv.SeedReplicationTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 5781 5782 default: 5783 return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value) 5784 5785 } 5786 } 5787 5788 case "serverId": 5789 if value != nil { 5790 jtv, ok := value.(string) 5791 if !ok { 5792 return fmt.Errorf("expected ServerId to be of type string, got %T instead", value) 5793 } 5794 sv.ServerId = ptr.String(jtv) 5795 } 5796 5797 case "serverType": 5798 if value != nil { 5799 jtv, ok := value.(string) 5800 if !ok { 5801 return fmt.Errorf("expected ServerType to be of type string, got %T instead", value) 5802 } 5803 sv.ServerType = types.ServerType(jtv) 5804 } 5805 5806 case "state": 5807 if value != nil { 5808 jtv, ok := value.(string) 5809 if !ok { 5810 return fmt.Errorf("expected ReplicationJobState to be of type string, got %T instead", value) 5811 } 5812 sv.State = types.ReplicationJobState(jtv) 5813 } 5814 5815 case "statusMessage": 5816 if value != nil { 5817 jtv, ok := value.(string) 5818 if !ok { 5819 return fmt.Errorf("expected ReplicationJobStatusMessage to be of type string, got %T instead", value) 5820 } 5821 sv.StatusMessage = ptr.String(jtv) 5822 } 5823 5824 case "vmServer": 5825 if err := awsAwsjson11_deserializeDocumentVmServer(&sv.VmServer, value); err != nil { 5826 return err 5827 } 5828 5829 default: 5830 _, _ = key, value 5831 5832 } 5833 } 5834 *v = sv 5835 return nil 5836} 5837 5838func awsAwsjson11_deserializeDocumentReplicationJobAlreadyExistsException(v **types.ReplicationJobAlreadyExistsException, value interface{}) error { 5839 if v == nil { 5840 return fmt.Errorf("unexpected nil of type %T", v) 5841 } 5842 if value == nil { 5843 return nil 5844 } 5845 5846 shape, ok := value.(map[string]interface{}) 5847 if !ok { 5848 return fmt.Errorf("unexpected JSON type %v", value) 5849 } 5850 5851 var sv *types.ReplicationJobAlreadyExistsException 5852 if *v == nil { 5853 sv = &types.ReplicationJobAlreadyExistsException{} 5854 } else { 5855 sv = *v 5856 } 5857 5858 for key, value := range shape { 5859 switch key { 5860 case "message": 5861 if value != nil { 5862 jtv, ok := value.(string) 5863 if !ok { 5864 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 5865 } 5866 sv.Message = ptr.String(jtv) 5867 } 5868 5869 default: 5870 _, _ = key, value 5871 5872 } 5873 } 5874 *v = sv 5875 return nil 5876} 5877 5878func awsAwsjson11_deserializeDocumentReplicationJobList(v *[]types.ReplicationJob, value interface{}) error { 5879 if v == nil { 5880 return fmt.Errorf("unexpected nil of type %T", v) 5881 } 5882 if value == nil { 5883 return nil 5884 } 5885 5886 shape, ok := value.([]interface{}) 5887 if !ok { 5888 return fmt.Errorf("unexpected JSON type %v", value) 5889 } 5890 5891 var cv []types.ReplicationJob 5892 if *v == nil { 5893 cv = []types.ReplicationJob{} 5894 } else { 5895 cv = *v 5896 } 5897 5898 for _, value := range shape { 5899 var col types.ReplicationJob 5900 destAddr := &col 5901 if err := awsAwsjson11_deserializeDocumentReplicationJob(&destAddr, value); err != nil { 5902 return err 5903 } 5904 col = *destAddr 5905 cv = append(cv, col) 5906 5907 } 5908 *v = cv 5909 return nil 5910} 5911 5912func awsAwsjson11_deserializeDocumentReplicationJobNotFoundException(v **types.ReplicationJobNotFoundException, value interface{}) error { 5913 if v == nil { 5914 return fmt.Errorf("unexpected nil of type %T", v) 5915 } 5916 if value == nil { 5917 return nil 5918 } 5919 5920 shape, ok := value.(map[string]interface{}) 5921 if !ok { 5922 return fmt.Errorf("unexpected JSON type %v", value) 5923 } 5924 5925 var sv *types.ReplicationJobNotFoundException 5926 if *v == nil { 5927 sv = &types.ReplicationJobNotFoundException{} 5928 } else { 5929 sv = *v 5930 } 5931 5932 for key, value := range shape { 5933 switch key { 5934 case "message": 5935 if value != nil { 5936 jtv, ok := value.(string) 5937 if !ok { 5938 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 5939 } 5940 sv.Message = ptr.String(jtv) 5941 } 5942 5943 default: 5944 _, _ = key, value 5945 5946 } 5947 } 5948 *v = sv 5949 return nil 5950} 5951 5952func awsAwsjson11_deserializeDocumentReplicationRun(v **types.ReplicationRun, value interface{}) error { 5953 if v == nil { 5954 return fmt.Errorf("unexpected nil of type %T", v) 5955 } 5956 if value == nil { 5957 return nil 5958 } 5959 5960 shape, ok := value.(map[string]interface{}) 5961 if !ok { 5962 return fmt.Errorf("unexpected JSON type %v", value) 5963 } 5964 5965 var sv *types.ReplicationRun 5966 if *v == nil { 5967 sv = &types.ReplicationRun{} 5968 } else { 5969 sv = *v 5970 } 5971 5972 for key, value := range shape { 5973 switch key { 5974 case "amiId": 5975 if value != nil { 5976 jtv, ok := value.(string) 5977 if !ok { 5978 return fmt.Errorf("expected AmiId to be of type string, got %T instead", value) 5979 } 5980 sv.AmiId = ptr.String(jtv) 5981 } 5982 5983 case "completedTime": 5984 if value != nil { 5985 switch jtv := value.(type) { 5986 case json.Number: 5987 f64, err := jtv.Float64() 5988 if err != nil { 5989 return err 5990 } 5991 sv.CompletedTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 5992 5993 default: 5994 return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value) 5995 5996 } 5997 } 5998 5999 case "description": 6000 if value != nil { 6001 jtv, ok := value.(string) 6002 if !ok { 6003 return fmt.Errorf("expected Description to be of type string, got %T instead", value) 6004 } 6005 sv.Description = ptr.String(jtv) 6006 } 6007 6008 case "encrypted": 6009 if value != nil { 6010 jtv, ok := value.(bool) 6011 if !ok { 6012 return fmt.Errorf("expected Encrypted to be of type *bool, got %T instead", value) 6013 } 6014 sv.Encrypted = ptr.Bool(jtv) 6015 } 6016 6017 case "kmsKeyId": 6018 if value != nil { 6019 jtv, ok := value.(string) 6020 if !ok { 6021 return fmt.Errorf("expected KmsKeyId to be of type string, got %T instead", value) 6022 } 6023 sv.KmsKeyId = ptr.String(jtv) 6024 } 6025 6026 case "replicationRunId": 6027 if value != nil { 6028 jtv, ok := value.(string) 6029 if !ok { 6030 return fmt.Errorf("expected ReplicationRunId to be of type string, got %T instead", value) 6031 } 6032 sv.ReplicationRunId = ptr.String(jtv) 6033 } 6034 6035 case "scheduledStartTime": 6036 if value != nil { 6037 switch jtv := value.(type) { 6038 case json.Number: 6039 f64, err := jtv.Float64() 6040 if err != nil { 6041 return err 6042 } 6043 sv.ScheduledStartTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 6044 6045 default: 6046 return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value) 6047 6048 } 6049 } 6050 6051 case "stageDetails": 6052 if err := awsAwsjson11_deserializeDocumentReplicationRunStageDetails(&sv.StageDetails, value); err != nil { 6053 return err 6054 } 6055 6056 case "state": 6057 if value != nil { 6058 jtv, ok := value.(string) 6059 if !ok { 6060 return fmt.Errorf("expected ReplicationRunState to be of type string, got %T instead", value) 6061 } 6062 sv.State = types.ReplicationRunState(jtv) 6063 } 6064 6065 case "statusMessage": 6066 if value != nil { 6067 jtv, ok := value.(string) 6068 if !ok { 6069 return fmt.Errorf("expected ReplicationRunStatusMessage to be of type string, got %T instead", value) 6070 } 6071 sv.StatusMessage = ptr.String(jtv) 6072 } 6073 6074 case "type": 6075 if value != nil { 6076 jtv, ok := value.(string) 6077 if !ok { 6078 return fmt.Errorf("expected ReplicationRunType to be of type string, got %T instead", value) 6079 } 6080 sv.Type = types.ReplicationRunType(jtv) 6081 } 6082 6083 default: 6084 _, _ = key, value 6085 6086 } 6087 } 6088 *v = sv 6089 return nil 6090} 6091 6092func awsAwsjson11_deserializeDocumentReplicationRunLimitExceededException(v **types.ReplicationRunLimitExceededException, value interface{}) error { 6093 if v == nil { 6094 return fmt.Errorf("unexpected nil of type %T", v) 6095 } 6096 if value == nil { 6097 return nil 6098 } 6099 6100 shape, ok := value.(map[string]interface{}) 6101 if !ok { 6102 return fmt.Errorf("unexpected JSON type %v", value) 6103 } 6104 6105 var sv *types.ReplicationRunLimitExceededException 6106 if *v == nil { 6107 sv = &types.ReplicationRunLimitExceededException{} 6108 } else { 6109 sv = *v 6110 } 6111 6112 for key, value := range shape { 6113 switch key { 6114 case "message": 6115 if value != nil { 6116 jtv, ok := value.(string) 6117 if !ok { 6118 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 6119 } 6120 sv.Message = ptr.String(jtv) 6121 } 6122 6123 default: 6124 _, _ = key, value 6125 6126 } 6127 } 6128 *v = sv 6129 return nil 6130} 6131 6132func awsAwsjson11_deserializeDocumentReplicationRunList(v *[]types.ReplicationRun, value interface{}) error { 6133 if v == nil { 6134 return fmt.Errorf("unexpected nil of type %T", v) 6135 } 6136 if value == nil { 6137 return nil 6138 } 6139 6140 shape, ok := value.([]interface{}) 6141 if !ok { 6142 return fmt.Errorf("unexpected JSON type %v", value) 6143 } 6144 6145 var cv []types.ReplicationRun 6146 if *v == nil { 6147 cv = []types.ReplicationRun{} 6148 } else { 6149 cv = *v 6150 } 6151 6152 for _, value := range shape { 6153 var col types.ReplicationRun 6154 destAddr := &col 6155 if err := awsAwsjson11_deserializeDocumentReplicationRun(&destAddr, value); err != nil { 6156 return err 6157 } 6158 col = *destAddr 6159 cv = append(cv, col) 6160 6161 } 6162 *v = cv 6163 return nil 6164} 6165 6166func awsAwsjson11_deserializeDocumentReplicationRunStageDetails(v **types.ReplicationRunStageDetails, value interface{}) error { 6167 if v == nil { 6168 return fmt.Errorf("unexpected nil of type %T", v) 6169 } 6170 if value == nil { 6171 return nil 6172 } 6173 6174 shape, ok := value.(map[string]interface{}) 6175 if !ok { 6176 return fmt.Errorf("unexpected JSON type %v", value) 6177 } 6178 6179 var sv *types.ReplicationRunStageDetails 6180 if *v == nil { 6181 sv = &types.ReplicationRunStageDetails{} 6182 } else { 6183 sv = *v 6184 } 6185 6186 for key, value := range shape { 6187 switch key { 6188 case "stage": 6189 if value != nil { 6190 jtv, ok := value.(string) 6191 if !ok { 6192 return fmt.Errorf("expected ReplicationRunStage to be of type string, got %T instead", value) 6193 } 6194 sv.Stage = ptr.String(jtv) 6195 } 6196 6197 case "stageProgress": 6198 if value != nil { 6199 jtv, ok := value.(string) 6200 if !ok { 6201 return fmt.Errorf("expected ReplicationRunStageProgress to be of type string, got %T instead", value) 6202 } 6203 sv.StageProgress = ptr.String(jtv) 6204 } 6205 6206 default: 6207 _, _ = key, value 6208 6209 } 6210 } 6211 *v = sv 6212 return nil 6213} 6214 6215func awsAwsjson11_deserializeDocumentS3Location(v **types.S3Location, value interface{}) error { 6216 if v == nil { 6217 return fmt.Errorf("unexpected nil of type %T", v) 6218 } 6219 if value == nil { 6220 return nil 6221 } 6222 6223 shape, ok := value.(map[string]interface{}) 6224 if !ok { 6225 return fmt.Errorf("unexpected JSON type %v", value) 6226 } 6227 6228 var sv *types.S3Location 6229 if *v == nil { 6230 sv = &types.S3Location{} 6231 } else { 6232 sv = *v 6233 } 6234 6235 for key, value := range shape { 6236 switch key { 6237 case "bucket": 6238 if value != nil { 6239 jtv, ok := value.(string) 6240 if !ok { 6241 return fmt.Errorf("expected S3BucketName to be of type string, got %T instead", value) 6242 } 6243 sv.Bucket = ptr.String(jtv) 6244 } 6245 6246 case "key": 6247 if value != nil { 6248 jtv, ok := value.(string) 6249 if !ok { 6250 return fmt.Errorf("expected S3KeyName to be of type string, got %T instead", value) 6251 } 6252 sv.Key = ptr.String(jtv) 6253 } 6254 6255 default: 6256 _, _ = key, value 6257 6258 } 6259 } 6260 *v = sv 6261 return nil 6262} 6263 6264func awsAwsjson11_deserializeDocumentServer(v **types.Server, value interface{}) error { 6265 if v == nil { 6266 return fmt.Errorf("unexpected nil of type %T", v) 6267 } 6268 if value == nil { 6269 return nil 6270 } 6271 6272 shape, ok := value.(map[string]interface{}) 6273 if !ok { 6274 return fmt.Errorf("unexpected JSON type %v", value) 6275 } 6276 6277 var sv *types.Server 6278 if *v == nil { 6279 sv = &types.Server{} 6280 } else { 6281 sv = *v 6282 } 6283 6284 for key, value := range shape { 6285 switch key { 6286 case "replicationJobId": 6287 if value != nil { 6288 jtv, ok := value.(string) 6289 if !ok { 6290 return fmt.Errorf("expected ReplicationJobId to be of type string, got %T instead", value) 6291 } 6292 sv.ReplicationJobId = ptr.String(jtv) 6293 } 6294 6295 case "replicationJobTerminated": 6296 if value != nil { 6297 jtv, ok := value.(bool) 6298 if !ok { 6299 return fmt.Errorf("expected ReplicationJobTerminated to be of type *bool, got %T instead", value) 6300 } 6301 sv.ReplicationJobTerminated = ptr.Bool(jtv) 6302 } 6303 6304 case "serverId": 6305 if value != nil { 6306 jtv, ok := value.(string) 6307 if !ok { 6308 return fmt.Errorf("expected ServerId to be of type string, got %T instead", value) 6309 } 6310 sv.ServerId = ptr.String(jtv) 6311 } 6312 6313 case "serverType": 6314 if value != nil { 6315 jtv, ok := value.(string) 6316 if !ok { 6317 return fmt.Errorf("expected ServerType to be of type string, got %T instead", value) 6318 } 6319 sv.ServerType = types.ServerType(jtv) 6320 } 6321 6322 case "vmServer": 6323 if err := awsAwsjson11_deserializeDocumentVmServer(&sv.VmServer, value); err != nil { 6324 return err 6325 } 6326 6327 default: 6328 _, _ = key, value 6329 6330 } 6331 } 6332 *v = sv 6333 return nil 6334} 6335 6336func awsAwsjson11_deserializeDocumentServerCannotBeReplicatedException(v **types.ServerCannotBeReplicatedException, value interface{}) error { 6337 if v == nil { 6338 return fmt.Errorf("unexpected nil of type %T", v) 6339 } 6340 if value == nil { 6341 return nil 6342 } 6343 6344 shape, ok := value.(map[string]interface{}) 6345 if !ok { 6346 return fmt.Errorf("unexpected JSON type %v", value) 6347 } 6348 6349 var sv *types.ServerCannotBeReplicatedException 6350 if *v == nil { 6351 sv = &types.ServerCannotBeReplicatedException{} 6352 } else { 6353 sv = *v 6354 } 6355 6356 for key, value := range shape { 6357 switch key { 6358 case "message": 6359 if value != nil { 6360 jtv, ok := value.(string) 6361 if !ok { 6362 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 6363 } 6364 sv.Message = ptr.String(jtv) 6365 } 6366 6367 default: 6368 _, _ = key, value 6369 6370 } 6371 } 6372 *v = sv 6373 return nil 6374} 6375 6376func awsAwsjson11_deserializeDocumentServerGroup(v **types.ServerGroup, value interface{}) error { 6377 if v == nil { 6378 return fmt.Errorf("unexpected nil of type %T", v) 6379 } 6380 if value == nil { 6381 return nil 6382 } 6383 6384 shape, ok := value.(map[string]interface{}) 6385 if !ok { 6386 return fmt.Errorf("unexpected JSON type %v", value) 6387 } 6388 6389 var sv *types.ServerGroup 6390 if *v == nil { 6391 sv = &types.ServerGroup{} 6392 } else { 6393 sv = *v 6394 } 6395 6396 for key, value := range shape { 6397 switch key { 6398 case "name": 6399 if value != nil { 6400 jtv, ok := value.(string) 6401 if !ok { 6402 return fmt.Errorf("expected ServerGroupName to be of type string, got %T instead", value) 6403 } 6404 sv.Name = ptr.String(jtv) 6405 } 6406 6407 case "serverGroupId": 6408 if value != nil { 6409 jtv, ok := value.(string) 6410 if !ok { 6411 return fmt.Errorf("expected ServerGroupId to be of type string, got %T instead", value) 6412 } 6413 sv.ServerGroupId = ptr.String(jtv) 6414 } 6415 6416 case "serverList": 6417 if err := awsAwsjson11_deserializeDocumentServerList(&sv.ServerList, value); err != nil { 6418 return err 6419 } 6420 6421 default: 6422 _, _ = key, value 6423 6424 } 6425 } 6426 *v = sv 6427 return nil 6428} 6429 6430func awsAwsjson11_deserializeDocumentServerGroupLaunchConfiguration(v **types.ServerGroupLaunchConfiguration, value interface{}) error { 6431 if v == nil { 6432 return fmt.Errorf("unexpected nil of type %T", v) 6433 } 6434 if value == nil { 6435 return nil 6436 } 6437 6438 shape, ok := value.(map[string]interface{}) 6439 if !ok { 6440 return fmt.Errorf("unexpected JSON type %v", value) 6441 } 6442 6443 var sv *types.ServerGroupLaunchConfiguration 6444 if *v == nil { 6445 sv = &types.ServerGroupLaunchConfiguration{} 6446 } else { 6447 sv = *v 6448 } 6449 6450 for key, value := range shape { 6451 switch key { 6452 case "launchOrder": 6453 if value != nil { 6454 jtv, ok := value.(json.Number) 6455 if !ok { 6456 return fmt.Errorf("expected LaunchOrder to be json.Number, got %T instead", value) 6457 } 6458 i64, err := jtv.Int64() 6459 if err != nil { 6460 return err 6461 } 6462 sv.LaunchOrder = ptr.Int32(int32(i64)) 6463 } 6464 6465 case "serverGroupId": 6466 if value != nil { 6467 jtv, ok := value.(string) 6468 if !ok { 6469 return fmt.Errorf("expected ServerGroupId to be of type string, got %T instead", value) 6470 } 6471 sv.ServerGroupId = ptr.String(jtv) 6472 } 6473 6474 case "serverLaunchConfigurations": 6475 if err := awsAwsjson11_deserializeDocumentServerLaunchConfigurations(&sv.ServerLaunchConfigurations, value); err != nil { 6476 return err 6477 } 6478 6479 default: 6480 _, _ = key, value 6481 6482 } 6483 } 6484 *v = sv 6485 return nil 6486} 6487 6488func awsAwsjson11_deserializeDocumentServerGroupLaunchConfigurations(v *[]types.ServerGroupLaunchConfiguration, value interface{}) error { 6489 if v == nil { 6490 return fmt.Errorf("unexpected nil of type %T", v) 6491 } 6492 if value == nil { 6493 return nil 6494 } 6495 6496 shape, ok := value.([]interface{}) 6497 if !ok { 6498 return fmt.Errorf("unexpected JSON type %v", value) 6499 } 6500 6501 var cv []types.ServerGroupLaunchConfiguration 6502 if *v == nil { 6503 cv = []types.ServerGroupLaunchConfiguration{} 6504 } else { 6505 cv = *v 6506 } 6507 6508 for _, value := range shape { 6509 var col types.ServerGroupLaunchConfiguration 6510 destAddr := &col 6511 if err := awsAwsjson11_deserializeDocumentServerGroupLaunchConfiguration(&destAddr, value); err != nil { 6512 return err 6513 } 6514 col = *destAddr 6515 cv = append(cv, col) 6516 6517 } 6518 *v = cv 6519 return nil 6520} 6521 6522func awsAwsjson11_deserializeDocumentServerGroupReplicationConfiguration(v **types.ServerGroupReplicationConfiguration, value interface{}) error { 6523 if v == nil { 6524 return fmt.Errorf("unexpected nil of type %T", v) 6525 } 6526 if value == nil { 6527 return nil 6528 } 6529 6530 shape, ok := value.(map[string]interface{}) 6531 if !ok { 6532 return fmt.Errorf("unexpected JSON type %v", value) 6533 } 6534 6535 var sv *types.ServerGroupReplicationConfiguration 6536 if *v == nil { 6537 sv = &types.ServerGroupReplicationConfiguration{} 6538 } else { 6539 sv = *v 6540 } 6541 6542 for key, value := range shape { 6543 switch key { 6544 case "serverGroupId": 6545 if value != nil { 6546 jtv, ok := value.(string) 6547 if !ok { 6548 return fmt.Errorf("expected ServerGroupId to be of type string, got %T instead", value) 6549 } 6550 sv.ServerGroupId = ptr.String(jtv) 6551 } 6552 6553 case "serverReplicationConfigurations": 6554 if err := awsAwsjson11_deserializeDocumentServerReplicationConfigurations(&sv.ServerReplicationConfigurations, value); err != nil { 6555 return err 6556 } 6557 6558 default: 6559 _, _ = key, value 6560 6561 } 6562 } 6563 *v = sv 6564 return nil 6565} 6566 6567func awsAwsjson11_deserializeDocumentServerGroupReplicationConfigurations(v *[]types.ServerGroupReplicationConfiguration, value interface{}) error { 6568 if v == nil { 6569 return fmt.Errorf("unexpected nil of type %T", v) 6570 } 6571 if value == nil { 6572 return nil 6573 } 6574 6575 shape, ok := value.([]interface{}) 6576 if !ok { 6577 return fmt.Errorf("unexpected JSON type %v", value) 6578 } 6579 6580 var cv []types.ServerGroupReplicationConfiguration 6581 if *v == nil { 6582 cv = []types.ServerGroupReplicationConfiguration{} 6583 } else { 6584 cv = *v 6585 } 6586 6587 for _, value := range shape { 6588 var col types.ServerGroupReplicationConfiguration 6589 destAddr := &col 6590 if err := awsAwsjson11_deserializeDocumentServerGroupReplicationConfiguration(&destAddr, value); err != nil { 6591 return err 6592 } 6593 col = *destAddr 6594 cv = append(cv, col) 6595 6596 } 6597 *v = cv 6598 return nil 6599} 6600 6601func awsAwsjson11_deserializeDocumentServerGroups(v *[]types.ServerGroup, value interface{}) error { 6602 if v == nil { 6603 return fmt.Errorf("unexpected nil of type %T", v) 6604 } 6605 if value == nil { 6606 return nil 6607 } 6608 6609 shape, ok := value.([]interface{}) 6610 if !ok { 6611 return fmt.Errorf("unexpected JSON type %v", value) 6612 } 6613 6614 var cv []types.ServerGroup 6615 if *v == nil { 6616 cv = []types.ServerGroup{} 6617 } else { 6618 cv = *v 6619 } 6620 6621 for _, value := range shape { 6622 var col types.ServerGroup 6623 destAddr := &col 6624 if err := awsAwsjson11_deserializeDocumentServerGroup(&destAddr, value); err != nil { 6625 return err 6626 } 6627 col = *destAddr 6628 cv = append(cv, col) 6629 6630 } 6631 *v = cv 6632 return nil 6633} 6634 6635func awsAwsjson11_deserializeDocumentServerGroupValidationConfiguration(v **types.ServerGroupValidationConfiguration, value interface{}) error { 6636 if v == nil { 6637 return fmt.Errorf("unexpected nil of type %T", v) 6638 } 6639 if value == nil { 6640 return nil 6641 } 6642 6643 shape, ok := value.(map[string]interface{}) 6644 if !ok { 6645 return fmt.Errorf("unexpected JSON type %v", value) 6646 } 6647 6648 var sv *types.ServerGroupValidationConfiguration 6649 if *v == nil { 6650 sv = &types.ServerGroupValidationConfiguration{} 6651 } else { 6652 sv = *v 6653 } 6654 6655 for key, value := range shape { 6656 switch key { 6657 case "serverGroupId": 6658 if value != nil { 6659 jtv, ok := value.(string) 6660 if !ok { 6661 return fmt.Errorf("expected ServerGroupId to be of type string, got %T instead", value) 6662 } 6663 sv.ServerGroupId = ptr.String(jtv) 6664 } 6665 6666 case "serverValidationConfigurations": 6667 if err := awsAwsjson11_deserializeDocumentServerValidationConfigurations(&sv.ServerValidationConfigurations, value); err != nil { 6668 return err 6669 } 6670 6671 default: 6672 _, _ = key, value 6673 6674 } 6675 } 6676 *v = sv 6677 return nil 6678} 6679 6680func awsAwsjson11_deserializeDocumentServerGroupValidationConfigurations(v *[]types.ServerGroupValidationConfiguration, value interface{}) error { 6681 if v == nil { 6682 return fmt.Errorf("unexpected nil of type %T", v) 6683 } 6684 if value == nil { 6685 return nil 6686 } 6687 6688 shape, ok := value.([]interface{}) 6689 if !ok { 6690 return fmt.Errorf("unexpected JSON type %v", value) 6691 } 6692 6693 var cv []types.ServerGroupValidationConfiguration 6694 if *v == nil { 6695 cv = []types.ServerGroupValidationConfiguration{} 6696 } else { 6697 cv = *v 6698 } 6699 6700 for _, value := range shape { 6701 var col types.ServerGroupValidationConfiguration 6702 destAddr := &col 6703 if err := awsAwsjson11_deserializeDocumentServerGroupValidationConfiguration(&destAddr, value); err != nil { 6704 return err 6705 } 6706 col = *destAddr 6707 cv = append(cv, col) 6708 6709 } 6710 *v = cv 6711 return nil 6712} 6713 6714func awsAwsjson11_deserializeDocumentServerLaunchConfiguration(v **types.ServerLaunchConfiguration, value interface{}) error { 6715 if v == nil { 6716 return fmt.Errorf("unexpected nil of type %T", v) 6717 } 6718 if value == nil { 6719 return nil 6720 } 6721 6722 shape, ok := value.(map[string]interface{}) 6723 if !ok { 6724 return fmt.Errorf("unexpected JSON type %v", value) 6725 } 6726 6727 var sv *types.ServerLaunchConfiguration 6728 if *v == nil { 6729 sv = &types.ServerLaunchConfiguration{} 6730 } else { 6731 sv = *v 6732 } 6733 6734 for key, value := range shape { 6735 switch key { 6736 case "associatePublicIpAddress": 6737 if value != nil { 6738 jtv, ok := value.(bool) 6739 if !ok { 6740 return fmt.Errorf("expected AssociatePublicIpAddress to be of type *bool, got %T instead", value) 6741 } 6742 sv.AssociatePublicIpAddress = ptr.Bool(jtv) 6743 } 6744 6745 case "configureScript": 6746 if err := awsAwsjson11_deserializeDocumentS3Location(&sv.ConfigureScript, value); err != nil { 6747 return err 6748 } 6749 6750 case "configureScriptType": 6751 if value != nil { 6752 jtv, ok := value.(string) 6753 if !ok { 6754 return fmt.Errorf("expected ScriptType to be of type string, got %T instead", value) 6755 } 6756 sv.ConfigureScriptType = types.ScriptType(jtv) 6757 } 6758 6759 case "ec2KeyName": 6760 if value != nil { 6761 jtv, ok := value.(string) 6762 if !ok { 6763 return fmt.Errorf("expected EC2KeyName to be of type string, got %T instead", value) 6764 } 6765 sv.Ec2KeyName = ptr.String(jtv) 6766 } 6767 6768 case "iamInstanceProfileName": 6769 if value != nil { 6770 jtv, ok := value.(string) 6771 if !ok { 6772 return fmt.Errorf("expected RoleName to be of type string, got %T instead", value) 6773 } 6774 sv.IamInstanceProfileName = ptr.String(jtv) 6775 } 6776 6777 case "instanceType": 6778 if value != nil { 6779 jtv, ok := value.(string) 6780 if !ok { 6781 return fmt.Errorf("expected InstanceType to be of type string, got %T instead", value) 6782 } 6783 sv.InstanceType = ptr.String(jtv) 6784 } 6785 6786 case "logicalId": 6787 if value != nil { 6788 jtv, ok := value.(string) 6789 if !ok { 6790 return fmt.Errorf("expected LogicalId to be of type string, got %T instead", value) 6791 } 6792 sv.LogicalId = ptr.String(jtv) 6793 } 6794 6795 case "securityGroup": 6796 if value != nil { 6797 jtv, ok := value.(string) 6798 if !ok { 6799 return fmt.Errorf("expected SecurityGroup to be of type string, got %T instead", value) 6800 } 6801 sv.SecurityGroup = ptr.String(jtv) 6802 } 6803 6804 case "server": 6805 if err := awsAwsjson11_deserializeDocumentServer(&sv.Server, value); err != nil { 6806 return err 6807 } 6808 6809 case "subnet": 6810 if value != nil { 6811 jtv, ok := value.(string) 6812 if !ok { 6813 return fmt.Errorf("expected Subnet to be of type string, got %T instead", value) 6814 } 6815 sv.Subnet = ptr.String(jtv) 6816 } 6817 6818 case "userData": 6819 if err := awsAwsjson11_deserializeDocumentUserData(&sv.UserData, value); err != nil { 6820 return err 6821 } 6822 6823 case "vpc": 6824 if value != nil { 6825 jtv, ok := value.(string) 6826 if !ok { 6827 return fmt.Errorf("expected VPC to be of type string, got %T instead", value) 6828 } 6829 sv.Vpc = ptr.String(jtv) 6830 } 6831 6832 default: 6833 _, _ = key, value 6834 6835 } 6836 } 6837 *v = sv 6838 return nil 6839} 6840 6841func awsAwsjson11_deserializeDocumentServerLaunchConfigurations(v *[]types.ServerLaunchConfiguration, value interface{}) error { 6842 if v == nil { 6843 return fmt.Errorf("unexpected nil of type %T", v) 6844 } 6845 if value == nil { 6846 return nil 6847 } 6848 6849 shape, ok := value.([]interface{}) 6850 if !ok { 6851 return fmt.Errorf("unexpected JSON type %v", value) 6852 } 6853 6854 var cv []types.ServerLaunchConfiguration 6855 if *v == nil { 6856 cv = []types.ServerLaunchConfiguration{} 6857 } else { 6858 cv = *v 6859 } 6860 6861 for _, value := range shape { 6862 var col types.ServerLaunchConfiguration 6863 destAddr := &col 6864 if err := awsAwsjson11_deserializeDocumentServerLaunchConfiguration(&destAddr, value); err != nil { 6865 return err 6866 } 6867 col = *destAddr 6868 cv = append(cv, col) 6869 6870 } 6871 *v = cv 6872 return nil 6873} 6874 6875func awsAwsjson11_deserializeDocumentServerList(v *[]types.Server, value interface{}) error { 6876 if v == nil { 6877 return fmt.Errorf("unexpected nil of type %T", v) 6878 } 6879 if value == nil { 6880 return nil 6881 } 6882 6883 shape, ok := value.([]interface{}) 6884 if !ok { 6885 return fmt.Errorf("unexpected JSON type %v", value) 6886 } 6887 6888 var cv []types.Server 6889 if *v == nil { 6890 cv = []types.Server{} 6891 } else { 6892 cv = *v 6893 } 6894 6895 for _, value := range shape { 6896 var col types.Server 6897 destAddr := &col 6898 if err := awsAwsjson11_deserializeDocumentServer(&destAddr, value); err != nil { 6899 return err 6900 } 6901 col = *destAddr 6902 cv = append(cv, col) 6903 6904 } 6905 *v = cv 6906 return nil 6907} 6908 6909func awsAwsjson11_deserializeDocumentServerReplicationConfiguration(v **types.ServerReplicationConfiguration, value interface{}) error { 6910 if v == nil { 6911 return fmt.Errorf("unexpected nil of type %T", v) 6912 } 6913 if value == nil { 6914 return nil 6915 } 6916 6917 shape, ok := value.(map[string]interface{}) 6918 if !ok { 6919 return fmt.Errorf("unexpected JSON type %v", value) 6920 } 6921 6922 var sv *types.ServerReplicationConfiguration 6923 if *v == nil { 6924 sv = &types.ServerReplicationConfiguration{} 6925 } else { 6926 sv = *v 6927 } 6928 6929 for key, value := range shape { 6930 switch key { 6931 case "server": 6932 if err := awsAwsjson11_deserializeDocumentServer(&sv.Server, value); err != nil { 6933 return err 6934 } 6935 6936 case "serverReplicationParameters": 6937 if err := awsAwsjson11_deserializeDocumentServerReplicationParameters(&sv.ServerReplicationParameters, value); err != nil { 6938 return err 6939 } 6940 6941 default: 6942 _, _ = key, value 6943 6944 } 6945 } 6946 *v = sv 6947 return nil 6948} 6949 6950func awsAwsjson11_deserializeDocumentServerReplicationConfigurations(v *[]types.ServerReplicationConfiguration, value interface{}) error { 6951 if v == nil { 6952 return fmt.Errorf("unexpected nil of type %T", v) 6953 } 6954 if value == nil { 6955 return nil 6956 } 6957 6958 shape, ok := value.([]interface{}) 6959 if !ok { 6960 return fmt.Errorf("unexpected JSON type %v", value) 6961 } 6962 6963 var cv []types.ServerReplicationConfiguration 6964 if *v == nil { 6965 cv = []types.ServerReplicationConfiguration{} 6966 } else { 6967 cv = *v 6968 } 6969 6970 for _, value := range shape { 6971 var col types.ServerReplicationConfiguration 6972 destAddr := &col 6973 if err := awsAwsjson11_deserializeDocumentServerReplicationConfiguration(&destAddr, value); err != nil { 6974 return err 6975 } 6976 col = *destAddr 6977 cv = append(cv, col) 6978 6979 } 6980 *v = cv 6981 return nil 6982} 6983 6984func awsAwsjson11_deserializeDocumentServerReplicationParameters(v **types.ServerReplicationParameters, value interface{}) error { 6985 if v == nil { 6986 return fmt.Errorf("unexpected nil of type %T", v) 6987 } 6988 if value == nil { 6989 return nil 6990 } 6991 6992 shape, ok := value.(map[string]interface{}) 6993 if !ok { 6994 return fmt.Errorf("unexpected JSON type %v", value) 6995 } 6996 6997 var sv *types.ServerReplicationParameters 6998 if *v == nil { 6999 sv = &types.ServerReplicationParameters{} 7000 } else { 7001 sv = *v 7002 } 7003 7004 for key, value := range shape { 7005 switch key { 7006 case "encrypted": 7007 if value != nil { 7008 jtv, ok := value.(bool) 7009 if !ok { 7010 return fmt.Errorf("expected Encrypted to be of type *bool, got %T instead", value) 7011 } 7012 sv.Encrypted = ptr.Bool(jtv) 7013 } 7014 7015 case "frequency": 7016 if value != nil { 7017 jtv, ok := value.(json.Number) 7018 if !ok { 7019 return fmt.Errorf("expected Frequency to be json.Number, got %T instead", value) 7020 } 7021 i64, err := jtv.Int64() 7022 if err != nil { 7023 return err 7024 } 7025 sv.Frequency = ptr.Int32(int32(i64)) 7026 } 7027 7028 case "kmsKeyId": 7029 if value != nil { 7030 jtv, ok := value.(string) 7031 if !ok { 7032 return fmt.Errorf("expected KmsKeyId to be of type string, got %T instead", value) 7033 } 7034 sv.KmsKeyId = ptr.String(jtv) 7035 } 7036 7037 case "licenseType": 7038 if value != nil { 7039 jtv, ok := value.(string) 7040 if !ok { 7041 return fmt.Errorf("expected LicenseType to be of type string, got %T instead", value) 7042 } 7043 sv.LicenseType = types.LicenseType(jtv) 7044 } 7045 7046 case "numberOfRecentAmisToKeep": 7047 if value != nil { 7048 jtv, ok := value.(json.Number) 7049 if !ok { 7050 return fmt.Errorf("expected NumberOfRecentAmisToKeep to be json.Number, got %T instead", value) 7051 } 7052 i64, err := jtv.Int64() 7053 if err != nil { 7054 return err 7055 } 7056 sv.NumberOfRecentAmisToKeep = ptr.Int32(int32(i64)) 7057 } 7058 7059 case "runOnce": 7060 if value != nil { 7061 jtv, ok := value.(bool) 7062 if !ok { 7063 return fmt.Errorf("expected RunOnce to be of type *bool, got %T instead", value) 7064 } 7065 sv.RunOnce = ptr.Bool(jtv) 7066 } 7067 7068 case "seedTime": 7069 if value != nil { 7070 switch jtv := value.(type) { 7071 case json.Number: 7072 f64, err := jtv.Float64() 7073 if err != nil { 7074 return err 7075 } 7076 sv.SeedTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 7077 7078 default: 7079 return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value) 7080 7081 } 7082 } 7083 7084 default: 7085 _, _ = key, value 7086 7087 } 7088 } 7089 *v = sv 7090 return nil 7091} 7092 7093func awsAwsjson11_deserializeDocumentServerValidationConfiguration(v **types.ServerValidationConfiguration, value interface{}) error { 7094 if v == nil { 7095 return fmt.Errorf("unexpected nil of type %T", v) 7096 } 7097 if value == nil { 7098 return nil 7099 } 7100 7101 shape, ok := value.(map[string]interface{}) 7102 if !ok { 7103 return fmt.Errorf("unexpected JSON type %v", value) 7104 } 7105 7106 var sv *types.ServerValidationConfiguration 7107 if *v == nil { 7108 sv = &types.ServerValidationConfiguration{} 7109 } else { 7110 sv = *v 7111 } 7112 7113 for key, value := range shape { 7114 switch key { 7115 case "name": 7116 if value != nil { 7117 jtv, ok := value.(string) 7118 if !ok { 7119 return fmt.Errorf("expected NonEmptyStringWithMaxLen255 to be of type string, got %T instead", value) 7120 } 7121 sv.Name = ptr.String(jtv) 7122 } 7123 7124 case "server": 7125 if err := awsAwsjson11_deserializeDocumentServer(&sv.Server, value); err != nil { 7126 return err 7127 } 7128 7129 case "serverValidationStrategy": 7130 if value != nil { 7131 jtv, ok := value.(string) 7132 if !ok { 7133 return fmt.Errorf("expected ServerValidationStrategy to be of type string, got %T instead", value) 7134 } 7135 sv.ServerValidationStrategy = types.ServerValidationStrategy(jtv) 7136 } 7137 7138 case "userDataValidationParameters": 7139 if err := awsAwsjson11_deserializeDocumentUserDataValidationParameters(&sv.UserDataValidationParameters, value); err != nil { 7140 return err 7141 } 7142 7143 case "validationId": 7144 if value != nil { 7145 jtv, ok := value.(string) 7146 if !ok { 7147 return fmt.Errorf("expected ValidationId to be of type string, got %T instead", value) 7148 } 7149 sv.ValidationId = ptr.String(jtv) 7150 } 7151 7152 default: 7153 _, _ = key, value 7154 7155 } 7156 } 7157 *v = sv 7158 return nil 7159} 7160 7161func awsAwsjson11_deserializeDocumentServerValidationConfigurations(v *[]types.ServerValidationConfiguration, value interface{}) error { 7162 if v == nil { 7163 return fmt.Errorf("unexpected nil of type %T", v) 7164 } 7165 if value == nil { 7166 return nil 7167 } 7168 7169 shape, ok := value.([]interface{}) 7170 if !ok { 7171 return fmt.Errorf("unexpected JSON type %v", value) 7172 } 7173 7174 var cv []types.ServerValidationConfiguration 7175 if *v == nil { 7176 cv = []types.ServerValidationConfiguration{} 7177 } else { 7178 cv = *v 7179 } 7180 7181 for _, value := range shape { 7182 var col types.ServerValidationConfiguration 7183 destAddr := &col 7184 if err := awsAwsjson11_deserializeDocumentServerValidationConfiguration(&destAddr, value); err != nil { 7185 return err 7186 } 7187 col = *destAddr 7188 cv = append(cv, col) 7189 7190 } 7191 *v = cv 7192 return nil 7193} 7194 7195func awsAwsjson11_deserializeDocumentServerValidationOutput(v **types.ServerValidationOutput, value interface{}) error { 7196 if v == nil { 7197 return fmt.Errorf("unexpected nil of type %T", v) 7198 } 7199 if value == nil { 7200 return nil 7201 } 7202 7203 shape, ok := value.(map[string]interface{}) 7204 if !ok { 7205 return fmt.Errorf("unexpected JSON type %v", value) 7206 } 7207 7208 var sv *types.ServerValidationOutput 7209 if *v == nil { 7210 sv = &types.ServerValidationOutput{} 7211 } else { 7212 sv = *v 7213 } 7214 7215 for key, value := range shape { 7216 switch key { 7217 case "server": 7218 if err := awsAwsjson11_deserializeDocumentServer(&sv.Server, value); err != nil { 7219 return err 7220 } 7221 7222 default: 7223 _, _ = key, value 7224 7225 } 7226 } 7227 *v = sv 7228 return nil 7229} 7230 7231func awsAwsjson11_deserializeDocumentSource(v **types.Source, value interface{}) error { 7232 if v == nil { 7233 return fmt.Errorf("unexpected nil of type %T", v) 7234 } 7235 if value == nil { 7236 return nil 7237 } 7238 7239 shape, ok := value.(map[string]interface{}) 7240 if !ok { 7241 return fmt.Errorf("unexpected JSON type %v", value) 7242 } 7243 7244 var sv *types.Source 7245 if *v == nil { 7246 sv = &types.Source{} 7247 } else { 7248 sv = *v 7249 } 7250 7251 for key, value := range shape { 7252 switch key { 7253 case "s3Location": 7254 if err := awsAwsjson11_deserializeDocumentS3Location(&sv.S3Location, value); err != nil { 7255 return err 7256 } 7257 7258 default: 7259 _, _ = key, value 7260 7261 } 7262 } 7263 *v = sv 7264 return nil 7265} 7266 7267func awsAwsjson11_deserializeDocumentSSMOutput(v **types.SSMOutput, value interface{}) error { 7268 if v == nil { 7269 return fmt.Errorf("unexpected nil of type %T", v) 7270 } 7271 if value == nil { 7272 return nil 7273 } 7274 7275 shape, ok := value.(map[string]interface{}) 7276 if !ok { 7277 return fmt.Errorf("unexpected JSON type %v", value) 7278 } 7279 7280 var sv *types.SSMOutput 7281 if *v == nil { 7282 sv = &types.SSMOutput{} 7283 } else { 7284 sv = *v 7285 } 7286 7287 for key, value := range shape { 7288 switch key { 7289 case "s3Location": 7290 if err := awsAwsjson11_deserializeDocumentS3Location(&sv.S3Location, value); err != nil { 7291 return err 7292 } 7293 7294 default: 7295 _, _ = key, value 7296 7297 } 7298 } 7299 *v = sv 7300 return nil 7301} 7302 7303func awsAwsjson11_deserializeDocumentSSMValidationParameters(v **types.SSMValidationParameters, value interface{}) error { 7304 if v == nil { 7305 return fmt.Errorf("unexpected nil of type %T", v) 7306 } 7307 if value == nil { 7308 return nil 7309 } 7310 7311 shape, ok := value.(map[string]interface{}) 7312 if !ok { 7313 return fmt.Errorf("unexpected JSON type %v", value) 7314 } 7315 7316 var sv *types.SSMValidationParameters 7317 if *v == nil { 7318 sv = &types.SSMValidationParameters{} 7319 } else { 7320 sv = *v 7321 } 7322 7323 for key, value := range shape { 7324 switch key { 7325 case "command": 7326 if value != nil { 7327 jtv, ok := value.(string) 7328 if !ok { 7329 return fmt.Errorf("expected Command to be of type string, got %T instead", value) 7330 } 7331 sv.Command = ptr.String(jtv) 7332 } 7333 7334 case "executionTimeoutSeconds": 7335 if value != nil { 7336 jtv, ok := value.(json.Number) 7337 if !ok { 7338 return fmt.Errorf("expected ExecutionTimeoutSeconds to be json.Number, got %T instead", value) 7339 } 7340 i64, err := jtv.Int64() 7341 if err != nil { 7342 return err 7343 } 7344 sv.ExecutionTimeoutSeconds = int32(i64) 7345 } 7346 7347 case "instanceId": 7348 if value != nil { 7349 jtv, ok := value.(string) 7350 if !ok { 7351 return fmt.Errorf("expected InstanceId to be of type string, got %T instead", value) 7352 } 7353 sv.InstanceId = ptr.String(jtv) 7354 } 7355 7356 case "outputS3BucketName": 7357 if value != nil { 7358 jtv, ok := value.(string) 7359 if !ok { 7360 return fmt.Errorf("expected BucketName to be of type string, got %T instead", value) 7361 } 7362 sv.OutputS3BucketName = ptr.String(jtv) 7363 } 7364 7365 case "scriptType": 7366 if value != nil { 7367 jtv, ok := value.(string) 7368 if !ok { 7369 return fmt.Errorf("expected ScriptType to be of type string, got %T instead", value) 7370 } 7371 sv.ScriptType = types.ScriptType(jtv) 7372 } 7373 7374 case "source": 7375 if err := awsAwsjson11_deserializeDocumentSource(&sv.Source, value); err != nil { 7376 return err 7377 } 7378 7379 default: 7380 _, _ = key, value 7381 7382 } 7383 } 7384 *v = sv 7385 return nil 7386} 7387 7388func awsAwsjson11_deserializeDocumentTag(v **types.Tag, value interface{}) error { 7389 if v == nil { 7390 return fmt.Errorf("unexpected nil of type %T", v) 7391 } 7392 if value == nil { 7393 return nil 7394 } 7395 7396 shape, ok := value.(map[string]interface{}) 7397 if !ok { 7398 return fmt.Errorf("unexpected JSON type %v", value) 7399 } 7400 7401 var sv *types.Tag 7402 if *v == nil { 7403 sv = &types.Tag{} 7404 } else { 7405 sv = *v 7406 } 7407 7408 for key, value := range shape { 7409 switch key { 7410 case "key": 7411 if value != nil { 7412 jtv, ok := value.(string) 7413 if !ok { 7414 return fmt.Errorf("expected TagKey to be of type string, got %T instead", value) 7415 } 7416 sv.Key = ptr.String(jtv) 7417 } 7418 7419 case "value": 7420 if value != nil { 7421 jtv, ok := value.(string) 7422 if !ok { 7423 return fmt.Errorf("expected TagValue to be of type string, got %T instead", value) 7424 } 7425 sv.Value = ptr.String(jtv) 7426 } 7427 7428 default: 7429 _, _ = key, value 7430 7431 } 7432 } 7433 *v = sv 7434 return nil 7435} 7436 7437func awsAwsjson11_deserializeDocumentTags(v *[]types.Tag, value interface{}) error { 7438 if v == nil { 7439 return fmt.Errorf("unexpected nil of type %T", v) 7440 } 7441 if value == nil { 7442 return nil 7443 } 7444 7445 shape, ok := value.([]interface{}) 7446 if !ok { 7447 return fmt.Errorf("unexpected JSON type %v", value) 7448 } 7449 7450 var cv []types.Tag 7451 if *v == nil { 7452 cv = []types.Tag{} 7453 } else { 7454 cv = *v 7455 } 7456 7457 for _, value := range shape { 7458 var col types.Tag 7459 destAddr := &col 7460 if err := awsAwsjson11_deserializeDocumentTag(&destAddr, value); err != nil { 7461 return err 7462 } 7463 col = *destAddr 7464 cv = append(cv, col) 7465 7466 } 7467 *v = cv 7468 return nil 7469} 7470 7471func awsAwsjson11_deserializeDocumentTemporarilyUnavailableException(v **types.TemporarilyUnavailableException, value interface{}) error { 7472 if v == nil { 7473 return fmt.Errorf("unexpected nil of type %T", v) 7474 } 7475 if value == nil { 7476 return nil 7477 } 7478 7479 shape, ok := value.(map[string]interface{}) 7480 if !ok { 7481 return fmt.Errorf("unexpected JSON type %v", value) 7482 } 7483 7484 var sv *types.TemporarilyUnavailableException 7485 if *v == nil { 7486 sv = &types.TemporarilyUnavailableException{} 7487 } else { 7488 sv = *v 7489 } 7490 7491 for key, value := range shape { 7492 switch key { 7493 default: 7494 _, _ = key, value 7495 7496 } 7497 } 7498 *v = sv 7499 return nil 7500} 7501 7502func awsAwsjson11_deserializeDocumentUnauthorizedOperationException(v **types.UnauthorizedOperationException, value interface{}) error { 7503 if v == nil { 7504 return fmt.Errorf("unexpected nil of type %T", v) 7505 } 7506 if value == nil { 7507 return nil 7508 } 7509 7510 shape, ok := value.(map[string]interface{}) 7511 if !ok { 7512 return fmt.Errorf("unexpected JSON type %v", value) 7513 } 7514 7515 var sv *types.UnauthorizedOperationException 7516 if *v == nil { 7517 sv = &types.UnauthorizedOperationException{} 7518 } else { 7519 sv = *v 7520 } 7521 7522 for key, value := range shape { 7523 switch key { 7524 case "message": 7525 if value != nil { 7526 jtv, ok := value.(string) 7527 if !ok { 7528 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 7529 } 7530 sv.Message = ptr.String(jtv) 7531 } 7532 7533 default: 7534 _, _ = key, value 7535 7536 } 7537 } 7538 *v = sv 7539 return nil 7540} 7541 7542func awsAwsjson11_deserializeDocumentUserData(v **types.UserData, value interface{}) error { 7543 if v == nil { 7544 return fmt.Errorf("unexpected nil of type %T", v) 7545 } 7546 if value == nil { 7547 return nil 7548 } 7549 7550 shape, ok := value.(map[string]interface{}) 7551 if !ok { 7552 return fmt.Errorf("unexpected JSON type %v", value) 7553 } 7554 7555 var sv *types.UserData 7556 if *v == nil { 7557 sv = &types.UserData{} 7558 } else { 7559 sv = *v 7560 } 7561 7562 for key, value := range shape { 7563 switch key { 7564 case "s3Location": 7565 if err := awsAwsjson11_deserializeDocumentS3Location(&sv.S3Location, value); err != nil { 7566 return err 7567 } 7568 7569 default: 7570 _, _ = key, value 7571 7572 } 7573 } 7574 *v = sv 7575 return nil 7576} 7577 7578func awsAwsjson11_deserializeDocumentUserDataValidationParameters(v **types.UserDataValidationParameters, value interface{}) error { 7579 if v == nil { 7580 return fmt.Errorf("unexpected nil of type %T", v) 7581 } 7582 if value == nil { 7583 return nil 7584 } 7585 7586 shape, ok := value.(map[string]interface{}) 7587 if !ok { 7588 return fmt.Errorf("unexpected JSON type %v", value) 7589 } 7590 7591 var sv *types.UserDataValidationParameters 7592 if *v == nil { 7593 sv = &types.UserDataValidationParameters{} 7594 } else { 7595 sv = *v 7596 } 7597 7598 for key, value := range shape { 7599 switch key { 7600 case "scriptType": 7601 if value != nil { 7602 jtv, ok := value.(string) 7603 if !ok { 7604 return fmt.Errorf("expected ScriptType to be of type string, got %T instead", value) 7605 } 7606 sv.ScriptType = types.ScriptType(jtv) 7607 } 7608 7609 case "source": 7610 if err := awsAwsjson11_deserializeDocumentSource(&sv.Source, value); err != nil { 7611 return err 7612 } 7613 7614 default: 7615 _, _ = key, value 7616 7617 } 7618 } 7619 *v = sv 7620 return nil 7621} 7622 7623func awsAwsjson11_deserializeDocumentValidationOutput(v **types.ValidationOutput, value interface{}) error { 7624 if v == nil { 7625 return fmt.Errorf("unexpected nil of type %T", v) 7626 } 7627 if value == nil { 7628 return nil 7629 } 7630 7631 shape, ok := value.(map[string]interface{}) 7632 if !ok { 7633 return fmt.Errorf("unexpected JSON type %v", value) 7634 } 7635 7636 var sv *types.ValidationOutput 7637 if *v == nil { 7638 sv = &types.ValidationOutput{} 7639 } else { 7640 sv = *v 7641 } 7642 7643 for key, value := range shape { 7644 switch key { 7645 case "appValidationOutput": 7646 if err := awsAwsjson11_deserializeDocumentAppValidationOutput(&sv.AppValidationOutput, value); err != nil { 7647 return err 7648 } 7649 7650 case "latestValidationTime": 7651 if value != nil { 7652 switch jtv := value.(type) { 7653 case json.Number: 7654 f64, err := jtv.Float64() 7655 if err != nil { 7656 return err 7657 } 7658 sv.LatestValidationTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 7659 7660 default: 7661 return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value) 7662 7663 } 7664 } 7665 7666 case "name": 7667 if value != nil { 7668 jtv, ok := value.(string) 7669 if !ok { 7670 return fmt.Errorf("expected NonEmptyStringWithMaxLen255 to be of type string, got %T instead", value) 7671 } 7672 sv.Name = ptr.String(jtv) 7673 } 7674 7675 case "serverValidationOutput": 7676 if err := awsAwsjson11_deserializeDocumentServerValidationOutput(&sv.ServerValidationOutput, value); err != nil { 7677 return err 7678 } 7679 7680 case "status": 7681 if value != nil { 7682 jtv, ok := value.(string) 7683 if !ok { 7684 return fmt.Errorf("expected ValidationStatus to be of type string, got %T instead", value) 7685 } 7686 sv.Status = types.ValidationStatus(jtv) 7687 } 7688 7689 case "statusMessage": 7690 if value != nil { 7691 jtv, ok := value.(string) 7692 if !ok { 7693 return fmt.Errorf("expected ValidationStatusMessage to be of type string, got %T instead", value) 7694 } 7695 sv.StatusMessage = ptr.String(jtv) 7696 } 7697 7698 case "validationId": 7699 if value != nil { 7700 jtv, ok := value.(string) 7701 if !ok { 7702 return fmt.Errorf("expected ValidationId to be of type string, got %T instead", value) 7703 } 7704 sv.ValidationId = ptr.String(jtv) 7705 } 7706 7707 default: 7708 _, _ = key, value 7709 7710 } 7711 } 7712 *v = sv 7713 return nil 7714} 7715 7716func awsAwsjson11_deserializeDocumentValidationOutputList(v *[]types.ValidationOutput, value interface{}) error { 7717 if v == nil { 7718 return fmt.Errorf("unexpected nil of type %T", v) 7719 } 7720 if value == nil { 7721 return nil 7722 } 7723 7724 shape, ok := value.([]interface{}) 7725 if !ok { 7726 return fmt.Errorf("unexpected JSON type %v", value) 7727 } 7728 7729 var cv []types.ValidationOutput 7730 if *v == nil { 7731 cv = []types.ValidationOutput{} 7732 } else { 7733 cv = *v 7734 } 7735 7736 for _, value := range shape { 7737 var col types.ValidationOutput 7738 destAddr := &col 7739 if err := awsAwsjson11_deserializeDocumentValidationOutput(&destAddr, value); err != nil { 7740 return err 7741 } 7742 col = *destAddr 7743 cv = append(cv, col) 7744 7745 } 7746 *v = cv 7747 return nil 7748} 7749 7750func awsAwsjson11_deserializeDocumentVmServer(v **types.VmServer, value interface{}) error { 7751 if v == nil { 7752 return fmt.Errorf("unexpected nil of type %T", v) 7753 } 7754 if value == nil { 7755 return nil 7756 } 7757 7758 shape, ok := value.(map[string]interface{}) 7759 if !ok { 7760 return fmt.Errorf("unexpected JSON type %v", value) 7761 } 7762 7763 var sv *types.VmServer 7764 if *v == nil { 7765 sv = &types.VmServer{} 7766 } else { 7767 sv = *v 7768 } 7769 7770 for key, value := range shape { 7771 switch key { 7772 case "vmManagerName": 7773 if value != nil { 7774 jtv, ok := value.(string) 7775 if !ok { 7776 return fmt.Errorf("expected VmManagerName to be of type string, got %T instead", value) 7777 } 7778 sv.VmManagerName = ptr.String(jtv) 7779 } 7780 7781 case "vmManagerType": 7782 if value != nil { 7783 jtv, ok := value.(string) 7784 if !ok { 7785 return fmt.Errorf("expected VmManagerType to be of type string, got %T instead", value) 7786 } 7787 sv.VmManagerType = types.VmManagerType(jtv) 7788 } 7789 7790 case "vmName": 7791 if value != nil { 7792 jtv, ok := value.(string) 7793 if !ok { 7794 return fmt.Errorf("expected VmName to be of type string, got %T instead", value) 7795 } 7796 sv.VmName = ptr.String(jtv) 7797 } 7798 7799 case "vmPath": 7800 if value != nil { 7801 jtv, ok := value.(string) 7802 if !ok { 7803 return fmt.Errorf("expected VmPath to be of type string, got %T instead", value) 7804 } 7805 sv.VmPath = ptr.String(jtv) 7806 } 7807 7808 case "vmServerAddress": 7809 if err := awsAwsjson11_deserializeDocumentVmServerAddress(&sv.VmServerAddress, value); err != nil { 7810 return err 7811 } 7812 7813 default: 7814 _, _ = key, value 7815 7816 } 7817 } 7818 *v = sv 7819 return nil 7820} 7821 7822func awsAwsjson11_deserializeDocumentVmServerAddress(v **types.VmServerAddress, value interface{}) error { 7823 if v == nil { 7824 return fmt.Errorf("unexpected nil of type %T", v) 7825 } 7826 if value == nil { 7827 return nil 7828 } 7829 7830 shape, ok := value.(map[string]interface{}) 7831 if !ok { 7832 return fmt.Errorf("unexpected JSON type %v", value) 7833 } 7834 7835 var sv *types.VmServerAddress 7836 if *v == nil { 7837 sv = &types.VmServerAddress{} 7838 } else { 7839 sv = *v 7840 } 7841 7842 for key, value := range shape { 7843 switch key { 7844 case "vmId": 7845 if value != nil { 7846 jtv, ok := value.(string) 7847 if !ok { 7848 return fmt.Errorf("expected VmId to be of type string, got %T instead", value) 7849 } 7850 sv.VmId = ptr.String(jtv) 7851 } 7852 7853 case "vmManagerId": 7854 if value != nil { 7855 jtv, ok := value.(string) 7856 if !ok { 7857 return fmt.Errorf("expected VmManagerId to be of type string, got %T instead", value) 7858 } 7859 sv.VmManagerId = ptr.String(jtv) 7860 } 7861 7862 default: 7863 _, _ = key, value 7864 7865 } 7866 } 7867 *v = sv 7868 return nil 7869} 7870 7871func awsAwsjson11_deserializeOpDocumentCreateAppOutput(v **CreateAppOutput, value interface{}) error { 7872 if v == nil { 7873 return fmt.Errorf("unexpected nil of type %T", v) 7874 } 7875 if value == nil { 7876 return nil 7877 } 7878 7879 shape, ok := value.(map[string]interface{}) 7880 if !ok { 7881 return fmt.Errorf("unexpected JSON type %v", value) 7882 } 7883 7884 var sv *CreateAppOutput 7885 if *v == nil { 7886 sv = &CreateAppOutput{} 7887 } else { 7888 sv = *v 7889 } 7890 7891 for key, value := range shape { 7892 switch key { 7893 case "appSummary": 7894 if err := awsAwsjson11_deserializeDocumentAppSummary(&sv.AppSummary, value); err != nil { 7895 return err 7896 } 7897 7898 case "serverGroups": 7899 if err := awsAwsjson11_deserializeDocumentServerGroups(&sv.ServerGroups, value); err != nil { 7900 return err 7901 } 7902 7903 case "tags": 7904 if err := awsAwsjson11_deserializeDocumentTags(&sv.Tags, value); err != nil { 7905 return err 7906 } 7907 7908 default: 7909 _, _ = key, value 7910 7911 } 7912 } 7913 *v = sv 7914 return nil 7915} 7916 7917func awsAwsjson11_deserializeOpDocumentCreateReplicationJobOutput(v **CreateReplicationJobOutput, value interface{}) error { 7918 if v == nil { 7919 return fmt.Errorf("unexpected nil of type %T", v) 7920 } 7921 if value == nil { 7922 return nil 7923 } 7924 7925 shape, ok := value.(map[string]interface{}) 7926 if !ok { 7927 return fmt.Errorf("unexpected JSON type %v", value) 7928 } 7929 7930 var sv *CreateReplicationJobOutput 7931 if *v == nil { 7932 sv = &CreateReplicationJobOutput{} 7933 } else { 7934 sv = *v 7935 } 7936 7937 for key, value := range shape { 7938 switch key { 7939 case "replicationJobId": 7940 if value != nil { 7941 jtv, ok := value.(string) 7942 if !ok { 7943 return fmt.Errorf("expected ReplicationJobId to be of type string, got %T instead", value) 7944 } 7945 sv.ReplicationJobId = ptr.String(jtv) 7946 } 7947 7948 default: 7949 _, _ = key, value 7950 7951 } 7952 } 7953 *v = sv 7954 return nil 7955} 7956 7957func awsAwsjson11_deserializeOpDocumentDeleteAppLaunchConfigurationOutput(v **DeleteAppLaunchConfigurationOutput, value interface{}) error { 7958 if v == nil { 7959 return fmt.Errorf("unexpected nil of type %T", v) 7960 } 7961 if value == nil { 7962 return nil 7963 } 7964 7965 shape, ok := value.(map[string]interface{}) 7966 if !ok { 7967 return fmt.Errorf("unexpected JSON type %v", value) 7968 } 7969 7970 var sv *DeleteAppLaunchConfigurationOutput 7971 if *v == nil { 7972 sv = &DeleteAppLaunchConfigurationOutput{} 7973 } else { 7974 sv = *v 7975 } 7976 7977 for key, value := range shape { 7978 switch key { 7979 default: 7980 _, _ = key, value 7981 7982 } 7983 } 7984 *v = sv 7985 return nil 7986} 7987 7988func awsAwsjson11_deserializeOpDocumentDeleteAppOutput(v **DeleteAppOutput, value interface{}) error { 7989 if v == nil { 7990 return fmt.Errorf("unexpected nil of type %T", v) 7991 } 7992 if value == nil { 7993 return nil 7994 } 7995 7996 shape, ok := value.(map[string]interface{}) 7997 if !ok { 7998 return fmt.Errorf("unexpected JSON type %v", value) 7999 } 8000 8001 var sv *DeleteAppOutput 8002 if *v == nil { 8003 sv = &DeleteAppOutput{} 8004 } else { 8005 sv = *v 8006 } 8007 8008 for key, value := range shape { 8009 switch key { 8010 default: 8011 _, _ = key, value 8012 8013 } 8014 } 8015 *v = sv 8016 return nil 8017} 8018 8019func awsAwsjson11_deserializeOpDocumentDeleteAppReplicationConfigurationOutput(v **DeleteAppReplicationConfigurationOutput, value interface{}) error { 8020 if v == nil { 8021 return fmt.Errorf("unexpected nil of type %T", v) 8022 } 8023 if value == nil { 8024 return nil 8025 } 8026 8027 shape, ok := value.(map[string]interface{}) 8028 if !ok { 8029 return fmt.Errorf("unexpected JSON type %v", value) 8030 } 8031 8032 var sv *DeleteAppReplicationConfigurationOutput 8033 if *v == nil { 8034 sv = &DeleteAppReplicationConfigurationOutput{} 8035 } else { 8036 sv = *v 8037 } 8038 8039 for key, value := range shape { 8040 switch key { 8041 default: 8042 _, _ = key, value 8043 8044 } 8045 } 8046 *v = sv 8047 return nil 8048} 8049 8050func awsAwsjson11_deserializeOpDocumentDeleteAppValidationConfigurationOutput(v **DeleteAppValidationConfigurationOutput, value interface{}) error { 8051 if v == nil { 8052 return fmt.Errorf("unexpected nil of type %T", v) 8053 } 8054 if value == nil { 8055 return nil 8056 } 8057 8058 shape, ok := value.(map[string]interface{}) 8059 if !ok { 8060 return fmt.Errorf("unexpected JSON type %v", value) 8061 } 8062 8063 var sv *DeleteAppValidationConfigurationOutput 8064 if *v == nil { 8065 sv = &DeleteAppValidationConfigurationOutput{} 8066 } else { 8067 sv = *v 8068 } 8069 8070 for key, value := range shape { 8071 switch key { 8072 default: 8073 _, _ = key, value 8074 8075 } 8076 } 8077 *v = sv 8078 return nil 8079} 8080 8081func awsAwsjson11_deserializeOpDocumentDeleteReplicationJobOutput(v **DeleteReplicationJobOutput, value interface{}) error { 8082 if v == nil { 8083 return fmt.Errorf("unexpected nil of type %T", v) 8084 } 8085 if value == nil { 8086 return nil 8087 } 8088 8089 shape, ok := value.(map[string]interface{}) 8090 if !ok { 8091 return fmt.Errorf("unexpected JSON type %v", value) 8092 } 8093 8094 var sv *DeleteReplicationJobOutput 8095 if *v == nil { 8096 sv = &DeleteReplicationJobOutput{} 8097 } else { 8098 sv = *v 8099 } 8100 8101 for key, value := range shape { 8102 switch key { 8103 default: 8104 _, _ = key, value 8105 8106 } 8107 } 8108 *v = sv 8109 return nil 8110} 8111 8112func awsAwsjson11_deserializeOpDocumentDeleteServerCatalogOutput(v **DeleteServerCatalogOutput, value interface{}) error { 8113 if v == nil { 8114 return fmt.Errorf("unexpected nil of type %T", v) 8115 } 8116 if value == nil { 8117 return nil 8118 } 8119 8120 shape, ok := value.(map[string]interface{}) 8121 if !ok { 8122 return fmt.Errorf("unexpected JSON type %v", value) 8123 } 8124 8125 var sv *DeleteServerCatalogOutput 8126 if *v == nil { 8127 sv = &DeleteServerCatalogOutput{} 8128 } else { 8129 sv = *v 8130 } 8131 8132 for key, value := range shape { 8133 switch key { 8134 default: 8135 _, _ = key, value 8136 8137 } 8138 } 8139 *v = sv 8140 return nil 8141} 8142 8143func awsAwsjson11_deserializeOpDocumentDisassociateConnectorOutput(v **DisassociateConnectorOutput, value interface{}) error { 8144 if v == nil { 8145 return fmt.Errorf("unexpected nil of type %T", v) 8146 } 8147 if value == nil { 8148 return nil 8149 } 8150 8151 shape, ok := value.(map[string]interface{}) 8152 if !ok { 8153 return fmt.Errorf("unexpected JSON type %v", value) 8154 } 8155 8156 var sv *DisassociateConnectorOutput 8157 if *v == nil { 8158 sv = &DisassociateConnectorOutput{} 8159 } else { 8160 sv = *v 8161 } 8162 8163 for key, value := range shape { 8164 switch key { 8165 default: 8166 _, _ = key, value 8167 8168 } 8169 } 8170 *v = sv 8171 return nil 8172} 8173 8174func awsAwsjson11_deserializeOpDocumentGenerateChangeSetOutput(v **GenerateChangeSetOutput, value interface{}) error { 8175 if v == nil { 8176 return fmt.Errorf("unexpected nil of type %T", v) 8177 } 8178 if value == nil { 8179 return nil 8180 } 8181 8182 shape, ok := value.(map[string]interface{}) 8183 if !ok { 8184 return fmt.Errorf("unexpected JSON type %v", value) 8185 } 8186 8187 var sv *GenerateChangeSetOutput 8188 if *v == nil { 8189 sv = &GenerateChangeSetOutput{} 8190 } else { 8191 sv = *v 8192 } 8193 8194 for key, value := range shape { 8195 switch key { 8196 case "s3Location": 8197 if err := awsAwsjson11_deserializeDocumentS3Location(&sv.S3Location, value); err != nil { 8198 return err 8199 } 8200 8201 default: 8202 _, _ = key, value 8203 8204 } 8205 } 8206 *v = sv 8207 return nil 8208} 8209 8210func awsAwsjson11_deserializeOpDocumentGenerateTemplateOutput(v **GenerateTemplateOutput, value interface{}) error { 8211 if v == nil { 8212 return fmt.Errorf("unexpected nil of type %T", v) 8213 } 8214 if value == nil { 8215 return nil 8216 } 8217 8218 shape, ok := value.(map[string]interface{}) 8219 if !ok { 8220 return fmt.Errorf("unexpected JSON type %v", value) 8221 } 8222 8223 var sv *GenerateTemplateOutput 8224 if *v == nil { 8225 sv = &GenerateTemplateOutput{} 8226 } else { 8227 sv = *v 8228 } 8229 8230 for key, value := range shape { 8231 switch key { 8232 case "s3Location": 8233 if err := awsAwsjson11_deserializeDocumentS3Location(&sv.S3Location, value); err != nil { 8234 return err 8235 } 8236 8237 default: 8238 _, _ = key, value 8239 8240 } 8241 } 8242 *v = sv 8243 return nil 8244} 8245 8246func awsAwsjson11_deserializeOpDocumentGetAppLaunchConfigurationOutput(v **GetAppLaunchConfigurationOutput, value interface{}) error { 8247 if v == nil { 8248 return fmt.Errorf("unexpected nil of type %T", v) 8249 } 8250 if value == nil { 8251 return nil 8252 } 8253 8254 shape, ok := value.(map[string]interface{}) 8255 if !ok { 8256 return fmt.Errorf("unexpected JSON type %v", value) 8257 } 8258 8259 var sv *GetAppLaunchConfigurationOutput 8260 if *v == nil { 8261 sv = &GetAppLaunchConfigurationOutput{} 8262 } else { 8263 sv = *v 8264 } 8265 8266 for key, value := range shape { 8267 switch key { 8268 case "appId": 8269 if value != nil { 8270 jtv, ok := value.(string) 8271 if !ok { 8272 return fmt.Errorf("expected AppId to be of type string, got %T instead", value) 8273 } 8274 sv.AppId = ptr.String(jtv) 8275 } 8276 8277 case "autoLaunch": 8278 if value != nil { 8279 jtv, ok := value.(bool) 8280 if !ok { 8281 return fmt.Errorf("expected AutoLaunch to be of type *bool, got %T instead", value) 8282 } 8283 sv.AutoLaunch = ptr.Bool(jtv) 8284 } 8285 8286 case "roleName": 8287 if value != nil { 8288 jtv, ok := value.(string) 8289 if !ok { 8290 return fmt.Errorf("expected RoleName to be of type string, got %T instead", value) 8291 } 8292 sv.RoleName = ptr.String(jtv) 8293 } 8294 8295 case "serverGroupLaunchConfigurations": 8296 if err := awsAwsjson11_deserializeDocumentServerGroupLaunchConfigurations(&sv.ServerGroupLaunchConfigurations, value); err != nil { 8297 return err 8298 } 8299 8300 default: 8301 _, _ = key, value 8302 8303 } 8304 } 8305 *v = sv 8306 return nil 8307} 8308 8309func awsAwsjson11_deserializeOpDocumentGetAppOutput(v **GetAppOutput, value interface{}) error { 8310 if v == nil { 8311 return fmt.Errorf("unexpected nil of type %T", v) 8312 } 8313 if value == nil { 8314 return nil 8315 } 8316 8317 shape, ok := value.(map[string]interface{}) 8318 if !ok { 8319 return fmt.Errorf("unexpected JSON type %v", value) 8320 } 8321 8322 var sv *GetAppOutput 8323 if *v == nil { 8324 sv = &GetAppOutput{} 8325 } else { 8326 sv = *v 8327 } 8328 8329 for key, value := range shape { 8330 switch key { 8331 case "appSummary": 8332 if err := awsAwsjson11_deserializeDocumentAppSummary(&sv.AppSummary, value); err != nil { 8333 return err 8334 } 8335 8336 case "serverGroups": 8337 if err := awsAwsjson11_deserializeDocumentServerGroups(&sv.ServerGroups, value); err != nil { 8338 return err 8339 } 8340 8341 case "tags": 8342 if err := awsAwsjson11_deserializeDocumentTags(&sv.Tags, value); err != nil { 8343 return err 8344 } 8345 8346 default: 8347 _, _ = key, value 8348 8349 } 8350 } 8351 *v = sv 8352 return nil 8353} 8354 8355func awsAwsjson11_deserializeOpDocumentGetAppReplicationConfigurationOutput(v **GetAppReplicationConfigurationOutput, value interface{}) error { 8356 if v == nil { 8357 return fmt.Errorf("unexpected nil of type %T", v) 8358 } 8359 if value == nil { 8360 return nil 8361 } 8362 8363 shape, ok := value.(map[string]interface{}) 8364 if !ok { 8365 return fmt.Errorf("unexpected JSON type %v", value) 8366 } 8367 8368 var sv *GetAppReplicationConfigurationOutput 8369 if *v == nil { 8370 sv = &GetAppReplicationConfigurationOutput{} 8371 } else { 8372 sv = *v 8373 } 8374 8375 for key, value := range shape { 8376 switch key { 8377 case "serverGroupReplicationConfigurations": 8378 if err := awsAwsjson11_deserializeDocumentServerGroupReplicationConfigurations(&sv.ServerGroupReplicationConfigurations, value); err != nil { 8379 return err 8380 } 8381 8382 default: 8383 _, _ = key, value 8384 8385 } 8386 } 8387 *v = sv 8388 return nil 8389} 8390 8391func awsAwsjson11_deserializeOpDocumentGetAppValidationConfigurationOutput(v **GetAppValidationConfigurationOutput, value interface{}) error { 8392 if v == nil { 8393 return fmt.Errorf("unexpected nil of type %T", v) 8394 } 8395 if value == nil { 8396 return nil 8397 } 8398 8399 shape, ok := value.(map[string]interface{}) 8400 if !ok { 8401 return fmt.Errorf("unexpected JSON type %v", value) 8402 } 8403 8404 var sv *GetAppValidationConfigurationOutput 8405 if *v == nil { 8406 sv = &GetAppValidationConfigurationOutput{} 8407 } else { 8408 sv = *v 8409 } 8410 8411 for key, value := range shape { 8412 switch key { 8413 case "appValidationConfigurations": 8414 if err := awsAwsjson11_deserializeDocumentAppValidationConfigurations(&sv.AppValidationConfigurations, value); err != nil { 8415 return err 8416 } 8417 8418 case "serverGroupValidationConfigurations": 8419 if err := awsAwsjson11_deserializeDocumentServerGroupValidationConfigurations(&sv.ServerGroupValidationConfigurations, value); err != nil { 8420 return err 8421 } 8422 8423 default: 8424 _, _ = key, value 8425 8426 } 8427 } 8428 *v = sv 8429 return nil 8430} 8431 8432func awsAwsjson11_deserializeOpDocumentGetAppValidationOutputOutput(v **GetAppValidationOutputOutput, value interface{}) error { 8433 if v == nil { 8434 return fmt.Errorf("unexpected nil of type %T", v) 8435 } 8436 if value == nil { 8437 return nil 8438 } 8439 8440 shape, ok := value.(map[string]interface{}) 8441 if !ok { 8442 return fmt.Errorf("unexpected JSON type %v", value) 8443 } 8444 8445 var sv *GetAppValidationOutputOutput 8446 if *v == nil { 8447 sv = &GetAppValidationOutputOutput{} 8448 } else { 8449 sv = *v 8450 } 8451 8452 for key, value := range shape { 8453 switch key { 8454 case "validationOutputList": 8455 if err := awsAwsjson11_deserializeDocumentValidationOutputList(&sv.ValidationOutputList, value); err != nil { 8456 return err 8457 } 8458 8459 default: 8460 _, _ = key, value 8461 8462 } 8463 } 8464 *v = sv 8465 return nil 8466} 8467 8468func awsAwsjson11_deserializeOpDocumentGetConnectorsOutput(v **GetConnectorsOutput, value interface{}) error { 8469 if v == nil { 8470 return fmt.Errorf("unexpected nil of type %T", v) 8471 } 8472 if value == nil { 8473 return nil 8474 } 8475 8476 shape, ok := value.(map[string]interface{}) 8477 if !ok { 8478 return fmt.Errorf("unexpected JSON type %v", value) 8479 } 8480 8481 var sv *GetConnectorsOutput 8482 if *v == nil { 8483 sv = &GetConnectorsOutput{} 8484 } else { 8485 sv = *v 8486 } 8487 8488 for key, value := range shape { 8489 switch key { 8490 case "connectorList": 8491 if err := awsAwsjson11_deserializeDocumentConnectorList(&sv.ConnectorList, value); err != nil { 8492 return err 8493 } 8494 8495 case "nextToken": 8496 if value != nil { 8497 jtv, ok := value.(string) 8498 if !ok { 8499 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 8500 } 8501 sv.NextToken = ptr.String(jtv) 8502 } 8503 8504 default: 8505 _, _ = key, value 8506 8507 } 8508 } 8509 *v = sv 8510 return nil 8511} 8512 8513func awsAwsjson11_deserializeOpDocumentGetReplicationJobsOutput(v **GetReplicationJobsOutput, value interface{}) error { 8514 if v == nil { 8515 return fmt.Errorf("unexpected nil of type %T", v) 8516 } 8517 if value == nil { 8518 return nil 8519 } 8520 8521 shape, ok := value.(map[string]interface{}) 8522 if !ok { 8523 return fmt.Errorf("unexpected JSON type %v", value) 8524 } 8525 8526 var sv *GetReplicationJobsOutput 8527 if *v == nil { 8528 sv = &GetReplicationJobsOutput{} 8529 } else { 8530 sv = *v 8531 } 8532 8533 for key, value := range shape { 8534 switch key { 8535 case "nextToken": 8536 if value != nil { 8537 jtv, ok := value.(string) 8538 if !ok { 8539 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 8540 } 8541 sv.NextToken = ptr.String(jtv) 8542 } 8543 8544 case "replicationJobList": 8545 if err := awsAwsjson11_deserializeDocumentReplicationJobList(&sv.ReplicationJobList, value); err != nil { 8546 return err 8547 } 8548 8549 default: 8550 _, _ = key, value 8551 8552 } 8553 } 8554 *v = sv 8555 return nil 8556} 8557 8558func awsAwsjson11_deserializeOpDocumentGetReplicationRunsOutput(v **GetReplicationRunsOutput, value interface{}) error { 8559 if v == nil { 8560 return fmt.Errorf("unexpected nil of type %T", v) 8561 } 8562 if value == nil { 8563 return nil 8564 } 8565 8566 shape, ok := value.(map[string]interface{}) 8567 if !ok { 8568 return fmt.Errorf("unexpected JSON type %v", value) 8569 } 8570 8571 var sv *GetReplicationRunsOutput 8572 if *v == nil { 8573 sv = &GetReplicationRunsOutput{} 8574 } else { 8575 sv = *v 8576 } 8577 8578 for key, value := range shape { 8579 switch key { 8580 case "nextToken": 8581 if value != nil { 8582 jtv, ok := value.(string) 8583 if !ok { 8584 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 8585 } 8586 sv.NextToken = ptr.String(jtv) 8587 } 8588 8589 case "replicationJob": 8590 if err := awsAwsjson11_deserializeDocumentReplicationJob(&sv.ReplicationJob, value); err != nil { 8591 return err 8592 } 8593 8594 case "replicationRunList": 8595 if err := awsAwsjson11_deserializeDocumentReplicationRunList(&sv.ReplicationRunList, value); err != nil { 8596 return err 8597 } 8598 8599 default: 8600 _, _ = key, value 8601 8602 } 8603 } 8604 *v = sv 8605 return nil 8606} 8607 8608func awsAwsjson11_deserializeOpDocumentGetServersOutput(v **GetServersOutput, value interface{}) error { 8609 if v == nil { 8610 return fmt.Errorf("unexpected nil of type %T", v) 8611 } 8612 if value == nil { 8613 return nil 8614 } 8615 8616 shape, ok := value.(map[string]interface{}) 8617 if !ok { 8618 return fmt.Errorf("unexpected JSON type %v", value) 8619 } 8620 8621 var sv *GetServersOutput 8622 if *v == nil { 8623 sv = &GetServersOutput{} 8624 } else { 8625 sv = *v 8626 } 8627 8628 for key, value := range shape { 8629 switch key { 8630 case "lastModifiedOn": 8631 if value != nil { 8632 switch jtv := value.(type) { 8633 case json.Number: 8634 f64, err := jtv.Float64() 8635 if err != nil { 8636 return err 8637 } 8638 sv.LastModifiedOn = ptr.Time(smithytime.ParseEpochSeconds(f64)) 8639 8640 default: 8641 return fmt.Errorf("expected Timestamp to be a JSON Number, got %T instead", value) 8642 8643 } 8644 } 8645 8646 case "nextToken": 8647 if value != nil { 8648 jtv, ok := value.(string) 8649 if !ok { 8650 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 8651 } 8652 sv.NextToken = ptr.String(jtv) 8653 } 8654 8655 case "serverCatalogStatus": 8656 if value != nil { 8657 jtv, ok := value.(string) 8658 if !ok { 8659 return fmt.Errorf("expected ServerCatalogStatus to be of type string, got %T instead", value) 8660 } 8661 sv.ServerCatalogStatus = types.ServerCatalogStatus(jtv) 8662 } 8663 8664 case "serverList": 8665 if err := awsAwsjson11_deserializeDocumentServerList(&sv.ServerList, value); err != nil { 8666 return err 8667 } 8668 8669 default: 8670 _, _ = key, value 8671 8672 } 8673 } 8674 *v = sv 8675 return nil 8676} 8677 8678func awsAwsjson11_deserializeOpDocumentImportAppCatalogOutput(v **ImportAppCatalogOutput, value interface{}) error { 8679 if v == nil { 8680 return fmt.Errorf("unexpected nil of type %T", v) 8681 } 8682 if value == nil { 8683 return nil 8684 } 8685 8686 shape, ok := value.(map[string]interface{}) 8687 if !ok { 8688 return fmt.Errorf("unexpected JSON type %v", value) 8689 } 8690 8691 var sv *ImportAppCatalogOutput 8692 if *v == nil { 8693 sv = &ImportAppCatalogOutput{} 8694 } else { 8695 sv = *v 8696 } 8697 8698 for key, value := range shape { 8699 switch key { 8700 default: 8701 _, _ = key, value 8702 8703 } 8704 } 8705 *v = sv 8706 return nil 8707} 8708 8709func awsAwsjson11_deserializeOpDocumentImportServerCatalogOutput(v **ImportServerCatalogOutput, value interface{}) error { 8710 if v == nil { 8711 return fmt.Errorf("unexpected nil of type %T", v) 8712 } 8713 if value == nil { 8714 return nil 8715 } 8716 8717 shape, ok := value.(map[string]interface{}) 8718 if !ok { 8719 return fmt.Errorf("unexpected JSON type %v", value) 8720 } 8721 8722 var sv *ImportServerCatalogOutput 8723 if *v == nil { 8724 sv = &ImportServerCatalogOutput{} 8725 } else { 8726 sv = *v 8727 } 8728 8729 for key, value := range shape { 8730 switch key { 8731 default: 8732 _, _ = key, value 8733 8734 } 8735 } 8736 *v = sv 8737 return nil 8738} 8739 8740func awsAwsjson11_deserializeOpDocumentLaunchAppOutput(v **LaunchAppOutput, value interface{}) error { 8741 if v == nil { 8742 return fmt.Errorf("unexpected nil of type %T", v) 8743 } 8744 if value == nil { 8745 return nil 8746 } 8747 8748 shape, ok := value.(map[string]interface{}) 8749 if !ok { 8750 return fmt.Errorf("unexpected JSON type %v", value) 8751 } 8752 8753 var sv *LaunchAppOutput 8754 if *v == nil { 8755 sv = &LaunchAppOutput{} 8756 } else { 8757 sv = *v 8758 } 8759 8760 for key, value := range shape { 8761 switch key { 8762 default: 8763 _, _ = key, value 8764 8765 } 8766 } 8767 *v = sv 8768 return nil 8769} 8770 8771func awsAwsjson11_deserializeOpDocumentListAppsOutput(v **ListAppsOutput, value interface{}) error { 8772 if v == nil { 8773 return fmt.Errorf("unexpected nil of type %T", v) 8774 } 8775 if value == nil { 8776 return nil 8777 } 8778 8779 shape, ok := value.(map[string]interface{}) 8780 if !ok { 8781 return fmt.Errorf("unexpected JSON type %v", value) 8782 } 8783 8784 var sv *ListAppsOutput 8785 if *v == nil { 8786 sv = &ListAppsOutput{} 8787 } else { 8788 sv = *v 8789 } 8790 8791 for key, value := range shape { 8792 switch key { 8793 case "apps": 8794 if err := awsAwsjson11_deserializeDocumentApps(&sv.Apps, value); err != nil { 8795 return err 8796 } 8797 8798 case "nextToken": 8799 if value != nil { 8800 jtv, ok := value.(string) 8801 if !ok { 8802 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 8803 } 8804 sv.NextToken = ptr.String(jtv) 8805 } 8806 8807 default: 8808 _, _ = key, value 8809 8810 } 8811 } 8812 *v = sv 8813 return nil 8814} 8815 8816func awsAwsjson11_deserializeOpDocumentNotifyAppValidationOutputOutput(v **NotifyAppValidationOutputOutput, value interface{}) error { 8817 if v == nil { 8818 return fmt.Errorf("unexpected nil of type %T", v) 8819 } 8820 if value == nil { 8821 return nil 8822 } 8823 8824 shape, ok := value.(map[string]interface{}) 8825 if !ok { 8826 return fmt.Errorf("unexpected JSON type %v", value) 8827 } 8828 8829 var sv *NotifyAppValidationOutputOutput 8830 if *v == nil { 8831 sv = &NotifyAppValidationOutputOutput{} 8832 } else { 8833 sv = *v 8834 } 8835 8836 for key, value := range shape { 8837 switch key { 8838 default: 8839 _, _ = key, value 8840 8841 } 8842 } 8843 *v = sv 8844 return nil 8845} 8846 8847func awsAwsjson11_deserializeOpDocumentPutAppLaunchConfigurationOutput(v **PutAppLaunchConfigurationOutput, value interface{}) error { 8848 if v == nil { 8849 return fmt.Errorf("unexpected nil of type %T", v) 8850 } 8851 if value == nil { 8852 return nil 8853 } 8854 8855 shape, ok := value.(map[string]interface{}) 8856 if !ok { 8857 return fmt.Errorf("unexpected JSON type %v", value) 8858 } 8859 8860 var sv *PutAppLaunchConfigurationOutput 8861 if *v == nil { 8862 sv = &PutAppLaunchConfigurationOutput{} 8863 } else { 8864 sv = *v 8865 } 8866 8867 for key, value := range shape { 8868 switch key { 8869 default: 8870 _, _ = key, value 8871 8872 } 8873 } 8874 *v = sv 8875 return nil 8876} 8877 8878func awsAwsjson11_deserializeOpDocumentPutAppReplicationConfigurationOutput(v **PutAppReplicationConfigurationOutput, value interface{}) error { 8879 if v == nil { 8880 return fmt.Errorf("unexpected nil of type %T", v) 8881 } 8882 if value == nil { 8883 return nil 8884 } 8885 8886 shape, ok := value.(map[string]interface{}) 8887 if !ok { 8888 return fmt.Errorf("unexpected JSON type %v", value) 8889 } 8890 8891 var sv *PutAppReplicationConfigurationOutput 8892 if *v == nil { 8893 sv = &PutAppReplicationConfigurationOutput{} 8894 } else { 8895 sv = *v 8896 } 8897 8898 for key, value := range shape { 8899 switch key { 8900 default: 8901 _, _ = key, value 8902 8903 } 8904 } 8905 *v = sv 8906 return nil 8907} 8908 8909func awsAwsjson11_deserializeOpDocumentPutAppValidationConfigurationOutput(v **PutAppValidationConfigurationOutput, value interface{}) error { 8910 if v == nil { 8911 return fmt.Errorf("unexpected nil of type %T", v) 8912 } 8913 if value == nil { 8914 return nil 8915 } 8916 8917 shape, ok := value.(map[string]interface{}) 8918 if !ok { 8919 return fmt.Errorf("unexpected JSON type %v", value) 8920 } 8921 8922 var sv *PutAppValidationConfigurationOutput 8923 if *v == nil { 8924 sv = &PutAppValidationConfigurationOutput{} 8925 } else { 8926 sv = *v 8927 } 8928 8929 for key, value := range shape { 8930 switch key { 8931 default: 8932 _, _ = key, value 8933 8934 } 8935 } 8936 *v = sv 8937 return nil 8938} 8939 8940func awsAwsjson11_deserializeOpDocumentStartAppReplicationOutput(v **StartAppReplicationOutput, value interface{}) error { 8941 if v == nil { 8942 return fmt.Errorf("unexpected nil of type %T", v) 8943 } 8944 if value == nil { 8945 return nil 8946 } 8947 8948 shape, ok := value.(map[string]interface{}) 8949 if !ok { 8950 return fmt.Errorf("unexpected JSON type %v", value) 8951 } 8952 8953 var sv *StartAppReplicationOutput 8954 if *v == nil { 8955 sv = &StartAppReplicationOutput{} 8956 } else { 8957 sv = *v 8958 } 8959 8960 for key, value := range shape { 8961 switch key { 8962 default: 8963 _, _ = key, value 8964 8965 } 8966 } 8967 *v = sv 8968 return nil 8969} 8970 8971func awsAwsjson11_deserializeOpDocumentStartOnDemandAppReplicationOutput(v **StartOnDemandAppReplicationOutput, value interface{}) error { 8972 if v == nil { 8973 return fmt.Errorf("unexpected nil of type %T", v) 8974 } 8975 if value == nil { 8976 return nil 8977 } 8978 8979 shape, ok := value.(map[string]interface{}) 8980 if !ok { 8981 return fmt.Errorf("unexpected JSON type %v", value) 8982 } 8983 8984 var sv *StartOnDemandAppReplicationOutput 8985 if *v == nil { 8986 sv = &StartOnDemandAppReplicationOutput{} 8987 } else { 8988 sv = *v 8989 } 8990 8991 for key, value := range shape { 8992 switch key { 8993 default: 8994 _, _ = key, value 8995 8996 } 8997 } 8998 *v = sv 8999 return nil 9000} 9001 9002func awsAwsjson11_deserializeOpDocumentStartOnDemandReplicationRunOutput(v **StartOnDemandReplicationRunOutput, value interface{}) error { 9003 if v == nil { 9004 return fmt.Errorf("unexpected nil of type %T", v) 9005 } 9006 if value == nil { 9007 return nil 9008 } 9009 9010 shape, ok := value.(map[string]interface{}) 9011 if !ok { 9012 return fmt.Errorf("unexpected JSON type %v", value) 9013 } 9014 9015 var sv *StartOnDemandReplicationRunOutput 9016 if *v == nil { 9017 sv = &StartOnDemandReplicationRunOutput{} 9018 } else { 9019 sv = *v 9020 } 9021 9022 for key, value := range shape { 9023 switch key { 9024 case "replicationRunId": 9025 if value != nil { 9026 jtv, ok := value.(string) 9027 if !ok { 9028 return fmt.Errorf("expected ReplicationRunId to be of type string, got %T instead", value) 9029 } 9030 sv.ReplicationRunId = ptr.String(jtv) 9031 } 9032 9033 default: 9034 _, _ = key, value 9035 9036 } 9037 } 9038 *v = sv 9039 return nil 9040} 9041 9042func awsAwsjson11_deserializeOpDocumentStopAppReplicationOutput(v **StopAppReplicationOutput, value interface{}) error { 9043 if v == nil { 9044 return fmt.Errorf("unexpected nil of type %T", v) 9045 } 9046 if value == nil { 9047 return nil 9048 } 9049 9050 shape, ok := value.(map[string]interface{}) 9051 if !ok { 9052 return fmt.Errorf("unexpected JSON type %v", value) 9053 } 9054 9055 var sv *StopAppReplicationOutput 9056 if *v == nil { 9057 sv = &StopAppReplicationOutput{} 9058 } else { 9059 sv = *v 9060 } 9061 9062 for key, value := range shape { 9063 switch key { 9064 default: 9065 _, _ = key, value 9066 9067 } 9068 } 9069 *v = sv 9070 return nil 9071} 9072 9073func awsAwsjson11_deserializeOpDocumentTerminateAppOutput(v **TerminateAppOutput, value interface{}) error { 9074 if v == nil { 9075 return fmt.Errorf("unexpected nil of type %T", v) 9076 } 9077 if value == nil { 9078 return nil 9079 } 9080 9081 shape, ok := value.(map[string]interface{}) 9082 if !ok { 9083 return fmt.Errorf("unexpected JSON type %v", value) 9084 } 9085 9086 var sv *TerminateAppOutput 9087 if *v == nil { 9088 sv = &TerminateAppOutput{} 9089 } else { 9090 sv = *v 9091 } 9092 9093 for key, value := range shape { 9094 switch key { 9095 default: 9096 _, _ = key, value 9097 9098 } 9099 } 9100 *v = sv 9101 return nil 9102} 9103 9104func awsAwsjson11_deserializeOpDocumentUpdateAppOutput(v **UpdateAppOutput, value interface{}) error { 9105 if v == nil { 9106 return fmt.Errorf("unexpected nil of type %T", v) 9107 } 9108 if value == nil { 9109 return nil 9110 } 9111 9112 shape, ok := value.(map[string]interface{}) 9113 if !ok { 9114 return fmt.Errorf("unexpected JSON type %v", value) 9115 } 9116 9117 var sv *UpdateAppOutput 9118 if *v == nil { 9119 sv = &UpdateAppOutput{} 9120 } else { 9121 sv = *v 9122 } 9123 9124 for key, value := range shape { 9125 switch key { 9126 case "appSummary": 9127 if err := awsAwsjson11_deserializeDocumentAppSummary(&sv.AppSummary, value); err != nil { 9128 return err 9129 } 9130 9131 case "serverGroups": 9132 if err := awsAwsjson11_deserializeDocumentServerGroups(&sv.ServerGroups, value); err != nil { 9133 return err 9134 } 9135 9136 case "tags": 9137 if err := awsAwsjson11_deserializeDocumentTags(&sv.Tags, value); err != nil { 9138 return err 9139 } 9140 9141 default: 9142 _, _ = key, value 9143 9144 } 9145 } 9146 *v = sv 9147 return nil 9148} 9149 9150func awsAwsjson11_deserializeOpDocumentUpdateReplicationJobOutput(v **UpdateReplicationJobOutput, value interface{}) error { 9151 if v == nil { 9152 return fmt.Errorf("unexpected nil of type %T", v) 9153 } 9154 if value == nil { 9155 return nil 9156 } 9157 9158 shape, ok := value.(map[string]interface{}) 9159 if !ok { 9160 return fmt.Errorf("unexpected JSON type %v", value) 9161 } 9162 9163 var sv *UpdateReplicationJobOutput 9164 if *v == nil { 9165 sv = &UpdateReplicationJobOutput{} 9166 } else { 9167 sv = *v 9168 } 9169 9170 for key, value := range shape { 9171 switch key { 9172 default: 9173 _, _ = key, value 9174 9175 } 9176 } 9177 *v = sv 9178 return nil 9179} 9180