1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package applicationdiscoveryservice 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/applicationdiscoveryservice/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_deserializeOpAssociateConfigurationItemsToApplication struct { 23} 24 25func (*awsAwsjson11_deserializeOpAssociateConfigurationItemsToApplication) ID() string { 26 return "OperationDeserializer" 27} 28 29func (m *awsAwsjson11_deserializeOpAssociateConfigurationItemsToApplication) 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_deserializeOpErrorAssociateConfigurationItemsToApplication(response, &metadata) 44 } 45 output := &AssociateConfigurationItemsToApplicationOutput{} 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_deserializeOpDocumentAssociateConfigurationItemsToApplicationOutput(&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_deserializeOpErrorAssociateConfigurationItemsToApplication(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("AuthorizationErrorException", errorCode): 121 return awsAwsjson11_deserializeErrorAuthorizationErrorException(response, errorBody) 122 123 case strings.EqualFold("HomeRegionNotSetException", errorCode): 124 return awsAwsjson11_deserializeErrorHomeRegionNotSetException(response, errorBody) 125 126 case strings.EqualFold("InvalidParameterException", errorCode): 127 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 128 129 case strings.EqualFold("InvalidParameterValueException", errorCode): 130 return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody) 131 132 case strings.EqualFold("ServerInternalErrorException", errorCode): 133 return awsAwsjson11_deserializeErrorServerInternalErrorException(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_deserializeOpBatchDeleteImportData struct { 146} 147 148func (*awsAwsjson11_deserializeOpBatchDeleteImportData) ID() string { 149 return "OperationDeserializer" 150} 151 152func (m *awsAwsjson11_deserializeOpBatchDeleteImportData) 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_deserializeOpErrorBatchDeleteImportData(response, &metadata) 167 } 168 output := &BatchDeleteImportDataOutput{} 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_deserializeOpDocumentBatchDeleteImportDataOutput(&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_deserializeOpErrorBatchDeleteImportData(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("AuthorizationErrorException", errorCode): 244 return awsAwsjson11_deserializeErrorAuthorizationErrorException(response, errorBody) 245 246 case strings.EqualFold("HomeRegionNotSetException", errorCode): 247 return awsAwsjson11_deserializeErrorHomeRegionNotSetException(response, errorBody) 248 249 case strings.EqualFold("InvalidParameterException", errorCode): 250 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 251 252 case strings.EqualFold("InvalidParameterValueException", errorCode): 253 return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody) 254 255 case strings.EqualFold("ServerInternalErrorException", errorCode): 256 return awsAwsjson11_deserializeErrorServerInternalErrorException(response, errorBody) 257 258 default: 259 genericError := &smithy.GenericAPIError{ 260 Code: errorCode, 261 Message: errorMessage, 262 } 263 return genericError 264 265 } 266} 267 268type awsAwsjson11_deserializeOpCreateApplication struct { 269} 270 271func (*awsAwsjson11_deserializeOpCreateApplication) ID() string { 272 return "OperationDeserializer" 273} 274 275func (m *awsAwsjson11_deserializeOpCreateApplication) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 276 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 277) { 278 out, metadata, err = next.HandleDeserialize(ctx, in) 279 if err != nil { 280 return out, metadata, err 281 } 282 283 response, ok := out.RawResponse.(*smithyhttp.Response) 284 if !ok { 285 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 286 } 287 288 if response.StatusCode < 200 || response.StatusCode >= 300 { 289 return out, metadata, awsAwsjson11_deserializeOpErrorCreateApplication(response, &metadata) 290 } 291 output := &CreateApplicationOutput{} 292 out.Result = output 293 294 var buff [1024]byte 295 ringBuffer := smithyio.NewRingBuffer(buff[:]) 296 297 body := io.TeeReader(response.Body, ringBuffer) 298 decoder := json.NewDecoder(body) 299 decoder.UseNumber() 300 var shape interface{} 301 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 302 var snapshot bytes.Buffer 303 io.Copy(&snapshot, ringBuffer) 304 err = &smithy.DeserializationError{ 305 Err: fmt.Errorf("failed to decode response body, %w", err), 306 Snapshot: snapshot.Bytes(), 307 } 308 return out, metadata, err 309 } 310 311 err = awsAwsjson11_deserializeOpDocumentCreateApplicationOutput(&output, shape) 312 if err != nil { 313 var snapshot bytes.Buffer 314 io.Copy(&snapshot, ringBuffer) 315 err = &smithy.DeserializationError{ 316 Err: fmt.Errorf("failed to decode response body, %w", err), 317 Snapshot: snapshot.Bytes(), 318 } 319 return out, metadata, err 320 } 321 322 return out, metadata, err 323} 324 325func awsAwsjson11_deserializeOpErrorCreateApplication(response *smithyhttp.Response, metadata *middleware.Metadata) error { 326 var errorBuffer bytes.Buffer 327 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 328 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 329 } 330 errorBody := bytes.NewReader(errorBuffer.Bytes()) 331 332 errorCode := "UnknownError" 333 errorMessage := errorCode 334 335 code := response.Header.Get("X-Amzn-ErrorType") 336 if len(code) != 0 { 337 errorCode = restjson.SanitizeErrorCode(code) 338 } 339 340 var buff [1024]byte 341 ringBuffer := smithyio.NewRingBuffer(buff[:]) 342 343 body := io.TeeReader(errorBody, ringBuffer) 344 decoder := json.NewDecoder(body) 345 decoder.UseNumber() 346 code, message, err := restjson.GetErrorInfo(decoder) 347 if err != nil { 348 var snapshot bytes.Buffer 349 io.Copy(&snapshot, ringBuffer) 350 err = &smithy.DeserializationError{ 351 Err: fmt.Errorf("failed to decode response body, %w", err), 352 Snapshot: snapshot.Bytes(), 353 } 354 return err 355 } 356 357 errorBody.Seek(0, io.SeekStart) 358 if len(code) != 0 { 359 errorCode = restjson.SanitizeErrorCode(code) 360 } 361 if len(message) != 0 { 362 errorMessage = message 363 } 364 365 switch { 366 case strings.EqualFold("AuthorizationErrorException", errorCode): 367 return awsAwsjson11_deserializeErrorAuthorizationErrorException(response, errorBody) 368 369 case strings.EqualFold("HomeRegionNotSetException", errorCode): 370 return awsAwsjson11_deserializeErrorHomeRegionNotSetException(response, errorBody) 371 372 case strings.EqualFold("InvalidParameterException", errorCode): 373 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 374 375 case strings.EqualFold("InvalidParameterValueException", errorCode): 376 return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody) 377 378 case strings.EqualFold("ServerInternalErrorException", errorCode): 379 return awsAwsjson11_deserializeErrorServerInternalErrorException(response, errorBody) 380 381 default: 382 genericError := &smithy.GenericAPIError{ 383 Code: errorCode, 384 Message: errorMessage, 385 } 386 return genericError 387 388 } 389} 390 391type awsAwsjson11_deserializeOpCreateTags struct { 392} 393 394func (*awsAwsjson11_deserializeOpCreateTags) ID() string { 395 return "OperationDeserializer" 396} 397 398func (m *awsAwsjson11_deserializeOpCreateTags) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 399 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 400) { 401 out, metadata, err = next.HandleDeserialize(ctx, in) 402 if err != nil { 403 return out, metadata, err 404 } 405 406 response, ok := out.RawResponse.(*smithyhttp.Response) 407 if !ok { 408 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 409 } 410 411 if response.StatusCode < 200 || response.StatusCode >= 300 { 412 return out, metadata, awsAwsjson11_deserializeOpErrorCreateTags(response, &metadata) 413 } 414 output := &CreateTagsOutput{} 415 out.Result = output 416 417 var buff [1024]byte 418 ringBuffer := smithyio.NewRingBuffer(buff[:]) 419 420 body := io.TeeReader(response.Body, ringBuffer) 421 decoder := json.NewDecoder(body) 422 decoder.UseNumber() 423 var shape interface{} 424 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 425 var snapshot bytes.Buffer 426 io.Copy(&snapshot, ringBuffer) 427 err = &smithy.DeserializationError{ 428 Err: fmt.Errorf("failed to decode response body, %w", err), 429 Snapshot: snapshot.Bytes(), 430 } 431 return out, metadata, err 432 } 433 434 err = awsAwsjson11_deserializeOpDocumentCreateTagsOutput(&output, shape) 435 if err != nil { 436 var snapshot bytes.Buffer 437 io.Copy(&snapshot, ringBuffer) 438 err = &smithy.DeserializationError{ 439 Err: fmt.Errorf("failed to decode response body, %w", err), 440 Snapshot: snapshot.Bytes(), 441 } 442 return out, metadata, err 443 } 444 445 return out, metadata, err 446} 447 448func awsAwsjson11_deserializeOpErrorCreateTags(response *smithyhttp.Response, metadata *middleware.Metadata) error { 449 var errorBuffer bytes.Buffer 450 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 451 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 452 } 453 errorBody := bytes.NewReader(errorBuffer.Bytes()) 454 455 errorCode := "UnknownError" 456 errorMessage := errorCode 457 458 code := response.Header.Get("X-Amzn-ErrorType") 459 if len(code) != 0 { 460 errorCode = restjson.SanitizeErrorCode(code) 461 } 462 463 var buff [1024]byte 464 ringBuffer := smithyio.NewRingBuffer(buff[:]) 465 466 body := io.TeeReader(errorBody, ringBuffer) 467 decoder := json.NewDecoder(body) 468 decoder.UseNumber() 469 code, message, err := restjson.GetErrorInfo(decoder) 470 if err != nil { 471 var snapshot bytes.Buffer 472 io.Copy(&snapshot, ringBuffer) 473 err = &smithy.DeserializationError{ 474 Err: fmt.Errorf("failed to decode response body, %w", err), 475 Snapshot: snapshot.Bytes(), 476 } 477 return err 478 } 479 480 errorBody.Seek(0, io.SeekStart) 481 if len(code) != 0 { 482 errorCode = restjson.SanitizeErrorCode(code) 483 } 484 if len(message) != 0 { 485 errorMessage = message 486 } 487 488 switch { 489 case strings.EqualFold("AuthorizationErrorException", errorCode): 490 return awsAwsjson11_deserializeErrorAuthorizationErrorException(response, errorBody) 491 492 case strings.EqualFold("HomeRegionNotSetException", errorCode): 493 return awsAwsjson11_deserializeErrorHomeRegionNotSetException(response, errorBody) 494 495 case strings.EqualFold("InvalidParameterException", errorCode): 496 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 497 498 case strings.EqualFold("InvalidParameterValueException", errorCode): 499 return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody) 500 501 case strings.EqualFold("ResourceNotFoundException", errorCode): 502 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 503 504 case strings.EqualFold("ServerInternalErrorException", errorCode): 505 return awsAwsjson11_deserializeErrorServerInternalErrorException(response, errorBody) 506 507 default: 508 genericError := &smithy.GenericAPIError{ 509 Code: errorCode, 510 Message: errorMessage, 511 } 512 return genericError 513 514 } 515} 516 517type awsAwsjson11_deserializeOpDeleteApplications struct { 518} 519 520func (*awsAwsjson11_deserializeOpDeleteApplications) ID() string { 521 return "OperationDeserializer" 522} 523 524func (m *awsAwsjson11_deserializeOpDeleteApplications) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 525 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 526) { 527 out, metadata, err = next.HandleDeserialize(ctx, in) 528 if err != nil { 529 return out, metadata, err 530 } 531 532 response, ok := out.RawResponse.(*smithyhttp.Response) 533 if !ok { 534 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 535 } 536 537 if response.StatusCode < 200 || response.StatusCode >= 300 { 538 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteApplications(response, &metadata) 539 } 540 output := &DeleteApplicationsOutput{} 541 out.Result = output 542 543 var buff [1024]byte 544 ringBuffer := smithyio.NewRingBuffer(buff[:]) 545 546 body := io.TeeReader(response.Body, ringBuffer) 547 decoder := json.NewDecoder(body) 548 decoder.UseNumber() 549 var shape interface{} 550 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 551 var snapshot bytes.Buffer 552 io.Copy(&snapshot, ringBuffer) 553 err = &smithy.DeserializationError{ 554 Err: fmt.Errorf("failed to decode response body, %w", err), 555 Snapshot: snapshot.Bytes(), 556 } 557 return out, metadata, err 558 } 559 560 err = awsAwsjson11_deserializeOpDocumentDeleteApplicationsOutput(&output, shape) 561 if err != nil { 562 var snapshot bytes.Buffer 563 io.Copy(&snapshot, ringBuffer) 564 err = &smithy.DeserializationError{ 565 Err: fmt.Errorf("failed to decode response body, %w", err), 566 Snapshot: snapshot.Bytes(), 567 } 568 return out, metadata, err 569 } 570 571 return out, metadata, err 572} 573 574func awsAwsjson11_deserializeOpErrorDeleteApplications(response *smithyhttp.Response, metadata *middleware.Metadata) error { 575 var errorBuffer bytes.Buffer 576 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 577 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 578 } 579 errorBody := bytes.NewReader(errorBuffer.Bytes()) 580 581 errorCode := "UnknownError" 582 errorMessage := errorCode 583 584 code := response.Header.Get("X-Amzn-ErrorType") 585 if len(code) != 0 { 586 errorCode = restjson.SanitizeErrorCode(code) 587 } 588 589 var buff [1024]byte 590 ringBuffer := smithyio.NewRingBuffer(buff[:]) 591 592 body := io.TeeReader(errorBody, ringBuffer) 593 decoder := json.NewDecoder(body) 594 decoder.UseNumber() 595 code, message, err := restjson.GetErrorInfo(decoder) 596 if err != nil { 597 var snapshot bytes.Buffer 598 io.Copy(&snapshot, ringBuffer) 599 err = &smithy.DeserializationError{ 600 Err: fmt.Errorf("failed to decode response body, %w", err), 601 Snapshot: snapshot.Bytes(), 602 } 603 return err 604 } 605 606 errorBody.Seek(0, io.SeekStart) 607 if len(code) != 0 { 608 errorCode = restjson.SanitizeErrorCode(code) 609 } 610 if len(message) != 0 { 611 errorMessage = message 612 } 613 614 switch { 615 case strings.EqualFold("AuthorizationErrorException", errorCode): 616 return awsAwsjson11_deserializeErrorAuthorizationErrorException(response, errorBody) 617 618 case strings.EqualFold("HomeRegionNotSetException", errorCode): 619 return awsAwsjson11_deserializeErrorHomeRegionNotSetException(response, errorBody) 620 621 case strings.EqualFold("InvalidParameterException", errorCode): 622 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 623 624 case strings.EqualFold("InvalidParameterValueException", errorCode): 625 return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody) 626 627 case strings.EqualFold("ServerInternalErrorException", errorCode): 628 return awsAwsjson11_deserializeErrorServerInternalErrorException(response, errorBody) 629 630 default: 631 genericError := &smithy.GenericAPIError{ 632 Code: errorCode, 633 Message: errorMessage, 634 } 635 return genericError 636 637 } 638} 639 640type awsAwsjson11_deserializeOpDeleteTags struct { 641} 642 643func (*awsAwsjson11_deserializeOpDeleteTags) ID() string { 644 return "OperationDeserializer" 645} 646 647func (m *awsAwsjson11_deserializeOpDeleteTags) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 648 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 649) { 650 out, metadata, err = next.HandleDeserialize(ctx, in) 651 if err != nil { 652 return out, metadata, err 653 } 654 655 response, ok := out.RawResponse.(*smithyhttp.Response) 656 if !ok { 657 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 658 } 659 660 if response.StatusCode < 200 || response.StatusCode >= 300 { 661 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteTags(response, &metadata) 662 } 663 output := &DeleteTagsOutput{} 664 out.Result = output 665 666 var buff [1024]byte 667 ringBuffer := smithyio.NewRingBuffer(buff[:]) 668 669 body := io.TeeReader(response.Body, ringBuffer) 670 decoder := json.NewDecoder(body) 671 decoder.UseNumber() 672 var shape interface{} 673 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 674 var snapshot bytes.Buffer 675 io.Copy(&snapshot, ringBuffer) 676 err = &smithy.DeserializationError{ 677 Err: fmt.Errorf("failed to decode response body, %w", err), 678 Snapshot: snapshot.Bytes(), 679 } 680 return out, metadata, err 681 } 682 683 err = awsAwsjson11_deserializeOpDocumentDeleteTagsOutput(&output, shape) 684 if err != nil { 685 var snapshot bytes.Buffer 686 io.Copy(&snapshot, ringBuffer) 687 err = &smithy.DeserializationError{ 688 Err: fmt.Errorf("failed to decode response body, %w", err), 689 Snapshot: snapshot.Bytes(), 690 } 691 return out, metadata, err 692 } 693 694 return out, metadata, err 695} 696 697func awsAwsjson11_deserializeOpErrorDeleteTags(response *smithyhttp.Response, metadata *middleware.Metadata) error { 698 var errorBuffer bytes.Buffer 699 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 700 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 701 } 702 errorBody := bytes.NewReader(errorBuffer.Bytes()) 703 704 errorCode := "UnknownError" 705 errorMessage := errorCode 706 707 code := response.Header.Get("X-Amzn-ErrorType") 708 if len(code) != 0 { 709 errorCode = restjson.SanitizeErrorCode(code) 710 } 711 712 var buff [1024]byte 713 ringBuffer := smithyio.NewRingBuffer(buff[:]) 714 715 body := io.TeeReader(errorBody, ringBuffer) 716 decoder := json.NewDecoder(body) 717 decoder.UseNumber() 718 code, message, err := restjson.GetErrorInfo(decoder) 719 if err != nil { 720 var snapshot bytes.Buffer 721 io.Copy(&snapshot, ringBuffer) 722 err = &smithy.DeserializationError{ 723 Err: fmt.Errorf("failed to decode response body, %w", err), 724 Snapshot: snapshot.Bytes(), 725 } 726 return err 727 } 728 729 errorBody.Seek(0, io.SeekStart) 730 if len(code) != 0 { 731 errorCode = restjson.SanitizeErrorCode(code) 732 } 733 if len(message) != 0 { 734 errorMessage = message 735 } 736 737 switch { 738 case strings.EqualFold("AuthorizationErrorException", errorCode): 739 return awsAwsjson11_deserializeErrorAuthorizationErrorException(response, errorBody) 740 741 case strings.EqualFold("HomeRegionNotSetException", errorCode): 742 return awsAwsjson11_deserializeErrorHomeRegionNotSetException(response, errorBody) 743 744 case strings.EqualFold("InvalidParameterException", errorCode): 745 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 746 747 case strings.EqualFold("InvalidParameterValueException", errorCode): 748 return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody) 749 750 case strings.EqualFold("ResourceNotFoundException", errorCode): 751 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 752 753 case strings.EqualFold("ServerInternalErrorException", errorCode): 754 return awsAwsjson11_deserializeErrorServerInternalErrorException(response, errorBody) 755 756 default: 757 genericError := &smithy.GenericAPIError{ 758 Code: errorCode, 759 Message: errorMessage, 760 } 761 return genericError 762 763 } 764} 765 766type awsAwsjson11_deserializeOpDescribeAgents struct { 767} 768 769func (*awsAwsjson11_deserializeOpDescribeAgents) ID() string { 770 return "OperationDeserializer" 771} 772 773func (m *awsAwsjson11_deserializeOpDescribeAgents) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 774 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 775) { 776 out, metadata, err = next.HandleDeserialize(ctx, in) 777 if err != nil { 778 return out, metadata, err 779 } 780 781 response, ok := out.RawResponse.(*smithyhttp.Response) 782 if !ok { 783 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 784 } 785 786 if response.StatusCode < 200 || response.StatusCode >= 300 { 787 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeAgents(response, &metadata) 788 } 789 output := &DescribeAgentsOutput{} 790 out.Result = output 791 792 var buff [1024]byte 793 ringBuffer := smithyio.NewRingBuffer(buff[:]) 794 795 body := io.TeeReader(response.Body, ringBuffer) 796 decoder := json.NewDecoder(body) 797 decoder.UseNumber() 798 var shape interface{} 799 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 800 var snapshot bytes.Buffer 801 io.Copy(&snapshot, ringBuffer) 802 err = &smithy.DeserializationError{ 803 Err: fmt.Errorf("failed to decode response body, %w", err), 804 Snapshot: snapshot.Bytes(), 805 } 806 return out, metadata, err 807 } 808 809 err = awsAwsjson11_deserializeOpDocumentDescribeAgentsOutput(&output, shape) 810 if err != nil { 811 var snapshot bytes.Buffer 812 io.Copy(&snapshot, ringBuffer) 813 err = &smithy.DeserializationError{ 814 Err: fmt.Errorf("failed to decode response body, %w", err), 815 Snapshot: snapshot.Bytes(), 816 } 817 return out, metadata, err 818 } 819 820 return out, metadata, err 821} 822 823func awsAwsjson11_deserializeOpErrorDescribeAgents(response *smithyhttp.Response, metadata *middleware.Metadata) error { 824 var errorBuffer bytes.Buffer 825 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 826 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 827 } 828 errorBody := bytes.NewReader(errorBuffer.Bytes()) 829 830 errorCode := "UnknownError" 831 errorMessage := errorCode 832 833 code := response.Header.Get("X-Amzn-ErrorType") 834 if len(code) != 0 { 835 errorCode = restjson.SanitizeErrorCode(code) 836 } 837 838 var buff [1024]byte 839 ringBuffer := smithyio.NewRingBuffer(buff[:]) 840 841 body := io.TeeReader(errorBody, ringBuffer) 842 decoder := json.NewDecoder(body) 843 decoder.UseNumber() 844 code, message, err := restjson.GetErrorInfo(decoder) 845 if err != nil { 846 var snapshot bytes.Buffer 847 io.Copy(&snapshot, ringBuffer) 848 err = &smithy.DeserializationError{ 849 Err: fmt.Errorf("failed to decode response body, %w", err), 850 Snapshot: snapshot.Bytes(), 851 } 852 return err 853 } 854 855 errorBody.Seek(0, io.SeekStart) 856 if len(code) != 0 { 857 errorCode = restjson.SanitizeErrorCode(code) 858 } 859 if len(message) != 0 { 860 errorMessage = message 861 } 862 863 switch { 864 case strings.EqualFold("AuthorizationErrorException", errorCode): 865 return awsAwsjson11_deserializeErrorAuthorizationErrorException(response, errorBody) 866 867 case strings.EqualFold("HomeRegionNotSetException", errorCode): 868 return awsAwsjson11_deserializeErrorHomeRegionNotSetException(response, errorBody) 869 870 case strings.EqualFold("InvalidParameterException", errorCode): 871 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 872 873 case strings.EqualFold("InvalidParameterValueException", errorCode): 874 return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody) 875 876 case strings.EqualFold("ServerInternalErrorException", errorCode): 877 return awsAwsjson11_deserializeErrorServerInternalErrorException(response, errorBody) 878 879 default: 880 genericError := &smithy.GenericAPIError{ 881 Code: errorCode, 882 Message: errorMessage, 883 } 884 return genericError 885 886 } 887} 888 889type awsAwsjson11_deserializeOpDescribeConfigurations struct { 890} 891 892func (*awsAwsjson11_deserializeOpDescribeConfigurations) ID() string { 893 return "OperationDeserializer" 894} 895 896func (m *awsAwsjson11_deserializeOpDescribeConfigurations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 897 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 898) { 899 out, metadata, err = next.HandleDeserialize(ctx, in) 900 if err != nil { 901 return out, metadata, err 902 } 903 904 response, ok := out.RawResponse.(*smithyhttp.Response) 905 if !ok { 906 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 907 } 908 909 if response.StatusCode < 200 || response.StatusCode >= 300 { 910 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeConfigurations(response, &metadata) 911 } 912 output := &DescribeConfigurationsOutput{} 913 out.Result = output 914 915 var buff [1024]byte 916 ringBuffer := smithyio.NewRingBuffer(buff[:]) 917 918 body := io.TeeReader(response.Body, ringBuffer) 919 decoder := json.NewDecoder(body) 920 decoder.UseNumber() 921 var shape interface{} 922 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 923 var snapshot bytes.Buffer 924 io.Copy(&snapshot, ringBuffer) 925 err = &smithy.DeserializationError{ 926 Err: fmt.Errorf("failed to decode response body, %w", err), 927 Snapshot: snapshot.Bytes(), 928 } 929 return out, metadata, err 930 } 931 932 err = awsAwsjson11_deserializeOpDocumentDescribeConfigurationsOutput(&output, shape) 933 if err != nil { 934 var snapshot bytes.Buffer 935 io.Copy(&snapshot, ringBuffer) 936 err = &smithy.DeserializationError{ 937 Err: fmt.Errorf("failed to decode response body, %w", err), 938 Snapshot: snapshot.Bytes(), 939 } 940 return out, metadata, err 941 } 942 943 return out, metadata, err 944} 945 946func awsAwsjson11_deserializeOpErrorDescribeConfigurations(response *smithyhttp.Response, metadata *middleware.Metadata) error { 947 var errorBuffer bytes.Buffer 948 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 949 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 950 } 951 errorBody := bytes.NewReader(errorBuffer.Bytes()) 952 953 errorCode := "UnknownError" 954 errorMessage := errorCode 955 956 code := response.Header.Get("X-Amzn-ErrorType") 957 if len(code) != 0 { 958 errorCode = restjson.SanitizeErrorCode(code) 959 } 960 961 var buff [1024]byte 962 ringBuffer := smithyio.NewRingBuffer(buff[:]) 963 964 body := io.TeeReader(errorBody, ringBuffer) 965 decoder := json.NewDecoder(body) 966 decoder.UseNumber() 967 code, message, err := restjson.GetErrorInfo(decoder) 968 if err != nil { 969 var snapshot bytes.Buffer 970 io.Copy(&snapshot, ringBuffer) 971 err = &smithy.DeserializationError{ 972 Err: fmt.Errorf("failed to decode response body, %w", err), 973 Snapshot: snapshot.Bytes(), 974 } 975 return err 976 } 977 978 errorBody.Seek(0, io.SeekStart) 979 if len(code) != 0 { 980 errorCode = restjson.SanitizeErrorCode(code) 981 } 982 if len(message) != 0 { 983 errorMessage = message 984 } 985 986 switch { 987 case strings.EqualFold("AuthorizationErrorException", errorCode): 988 return awsAwsjson11_deserializeErrorAuthorizationErrorException(response, errorBody) 989 990 case strings.EqualFold("HomeRegionNotSetException", errorCode): 991 return awsAwsjson11_deserializeErrorHomeRegionNotSetException(response, errorBody) 992 993 case strings.EqualFold("InvalidParameterException", errorCode): 994 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 995 996 case strings.EqualFold("InvalidParameterValueException", errorCode): 997 return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody) 998 999 case strings.EqualFold("ServerInternalErrorException", errorCode): 1000 return awsAwsjson11_deserializeErrorServerInternalErrorException(response, errorBody) 1001 1002 default: 1003 genericError := &smithy.GenericAPIError{ 1004 Code: errorCode, 1005 Message: errorMessage, 1006 } 1007 return genericError 1008 1009 } 1010} 1011 1012type awsAwsjson11_deserializeOpDescribeContinuousExports struct { 1013} 1014 1015func (*awsAwsjson11_deserializeOpDescribeContinuousExports) ID() string { 1016 return "OperationDeserializer" 1017} 1018 1019func (m *awsAwsjson11_deserializeOpDescribeContinuousExports) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1020 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1021) { 1022 out, metadata, err = next.HandleDeserialize(ctx, in) 1023 if err != nil { 1024 return out, metadata, err 1025 } 1026 1027 response, ok := out.RawResponse.(*smithyhttp.Response) 1028 if !ok { 1029 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1030 } 1031 1032 if response.StatusCode < 200 || response.StatusCode >= 300 { 1033 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeContinuousExports(response, &metadata) 1034 } 1035 output := &DescribeContinuousExportsOutput{} 1036 out.Result = output 1037 1038 var buff [1024]byte 1039 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1040 1041 body := io.TeeReader(response.Body, ringBuffer) 1042 decoder := json.NewDecoder(body) 1043 decoder.UseNumber() 1044 var shape interface{} 1045 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1046 var snapshot bytes.Buffer 1047 io.Copy(&snapshot, ringBuffer) 1048 err = &smithy.DeserializationError{ 1049 Err: fmt.Errorf("failed to decode response body, %w", err), 1050 Snapshot: snapshot.Bytes(), 1051 } 1052 return out, metadata, err 1053 } 1054 1055 err = awsAwsjson11_deserializeOpDocumentDescribeContinuousExportsOutput(&output, shape) 1056 if err != nil { 1057 var snapshot bytes.Buffer 1058 io.Copy(&snapshot, ringBuffer) 1059 err = &smithy.DeserializationError{ 1060 Err: fmt.Errorf("failed to decode response body, %w", err), 1061 Snapshot: snapshot.Bytes(), 1062 } 1063 return out, metadata, err 1064 } 1065 1066 return out, metadata, err 1067} 1068 1069func awsAwsjson11_deserializeOpErrorDescribeContinuousExports(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1070 var errorBuffer bytes.Buffer 1071 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1072 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1073 } 1074 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1075 1076 errorCode := "UnknownError" 1077 errorMessage := errorCode 1078 1079 code := response.Header.Get("X-Amzn-ErrorType") 1080 if len(code) != 0 { 1081 errorCode = restjson.SanitizeErrorCode(code) 1082 } 1083 1084 var buff [1024]byte 1085 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1086 1087 body := io.TeeReader(errorBody, ringBuffer) 1088 decoder := json.NewDecoder(body) 1089 decoder.UseNumber() 1090 code, message, err := restjson.GetErrorInfo(decoder) 1091 if err != nil { 1092 var snapshot bytes.Buffer 1093 io.Copy(&snapshot, ringBuffer) 1094 err = &smithy.DeserializationError{ 1095 Err: fmt.Errorf("failed to decode response body, %w", err), 1096 Snapshot: snapshot.Bytes(), 1097 } 1098 return err 1099 } 1100 1101 errorBody.Seek(0, io.SeekStart) 1102 if len(code) != 0 { 1103 errorCode = restjson.SanitizeErrorCode(code) 1104 } 1105 if len(message) != 0 { 1106 errorMessage = message 1107 } 1108 1109 switch { 1110 case strings.EqualFold("AuthorizationErrorException", errorCode): 1111 return awsAwsjson11_deserializeErrorAuthorizationErrorException(response, errorBody) 1112 1113 case strings.EqualFold("HomeRegionNotSetException", errorCode): 1114 return awsAwsjson11_deserializeErrorHomeRegionNotSetException(response, errorBody) 1115 1116 case strings.EqualFold("InvalidParameterException", errorCode): 1117 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 1118 1119 case strings.EqualFold("InvalidParameterValueException", errorCode): 1120 return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody) 1121 1122 case strings.EqualFold("OperationNotPermittedException", errorCode): 1123 return awsAwsjson11_deserializeErrorOperationNotPermittedException(response, errorBody) 1124 1125 case strings.EqualFold("ResourceNotFoundException", errorCode): 1126 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 1127 1128 case strings.EqualFold("ServerInternalErrorException", errorCode): 1129 return awsAwsjson11_deserializeErrorServerInternalErrorException(response, errorBody) 1130 1131 default: 1132 genericError := &smithy.GenericAPIError{ 1133 Code: errorCode, 1134 Message: errorMessage, 1135 } 1136 return genericError 1137 1138 } 1139} 1140 1141type awsAwsjson11_deserializeOpDescribeExportConfigurations struct { 1142} 1143 1144func (*awsAwsjson11_deserializeOpDescribeExportConfigurations) ID() string { 1145 return "OperationDeserializer" 1146} 1147 1148func (m *awsAwsjson11_deserializeOpDescribeExportConfigurations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1149 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1150) { 1151 out, metadata, err = next.HandleDeserialize(ctx, in) 1152 if err != nil { 1153 return out, metadata, err 1154 } 1155 1156 response, ok := out.RawResponse.(*smithyhttp.Response) 1157 if !ok { 1158 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1159 } 1160 1161 if response.StatusCode < 200 || response.StatusCode >= 300 { 1162 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeExportConfigurations(response, &metadata) 1163 } 1164 output := &DescribeExportConfigurationsOutput{} 1165 out.Result = output 1166 1167 var buff [1024]byte 1168 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1169 1170 body := io.TeeReader(response.Body, ringBuffer) 1171 decoder := json.NewDecoder(body) 1172 decoder.UseNumber() 1173 var shape interface{} 1174 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1175 var snapshot bytes.Buffer 1176 io.Copy(&snapshot, ringBuffer) 1177 err = &smithy.DeserializationError{ 1178 Err: fmt.Errorf("failed to decode response body, %w", err), 1179 Snapshot: snapshot.Bytes(), 1180 } 1181 return out, metadata, err 1182 } 1183 1184 err = awsAwsjson11_deserializeOpDocumentDescribeExportConfigurationsOutput(&output, shape) 1185 if err != nil { 1186 var snapshot bytes.Buffer 1187 io.Copy(&snapshot, ringBuffer) 1188 err = &smithy.DeserializationError{ 1189 Err: fmt.Errorf("failed to decode response body, %w", err), 1190 Snapshot: snapshot.Bytes(), 1191 } 1192 return out, metadata, err 1193 } 1194 1195 return out, metadata, err 1196} 1197 1198func awsAwsjson11_deserializeOpErrorDescribeExportConfigurations(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1199 var errorBuffer bytes.Buffer 1200 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1201 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1202 } 1203 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1204 1205 errorCode := "UnknownError" 1206 errorMessage := errorCode 1207 1208 code := response.Header.Get("X-Amzn-ErrorType") 1209 if len(code) != 0 { 1210 errorCode = restjson.SanitizeErrorCode(code) 1211 } 1212 1213 var buff [1024]byte 1214 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1215 1216 body := io.TeeReader(errorBody, ringBuffer) 1217 decoder := json.NewDecoder(body) 1218 decoder.UseNumber() 1219 code, message, err := restjson.GetErrorInfo(decoder) 1220 if err != nil { 1221 var snapshot bytes.Buffer 1222 io.Copy(&snapshot, ringBuffer) 1223 err = &smithy.DeserializationError{ 1224 Err: fmt.Errorf("failed to decode response body, %w", err), 1225 Snapshot: snapshot.Bytes(), 1226 } 1227 return err 1228 } 1229 1230 errorBody.Seek(0, io.SeekStart) 1231 if len(code) != 0 { 1232 errorCode = restjson.SanitizeErrorCode(code) 1233 } 1234 if len(message) != 0 { 1235 errorMessage = message 1236 } 1237 1238 switch { 1239 case strings.EqualFold("AuthorizationErrorException", errorCode): 1240 return awsAwsjson11_deserializeErrorAuthorizationErrorException(response, errorBody) 1241 1242 case strings.EqualFold("HomeRegionNotSetException", errorCode): 1243 return awsAwsjson11_deserializeErrorHomeRegionNotSetException(response, errorBody) 1244 1245 case strings.EqualFold("InvalidParameterException", errorCode): 1246 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 1247 1248 case strings.EqualFold("InvalidParameterValueException", errorCode): 1249 return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody) 1250 1251 case strings.EqualFold("ResourceNotFoundException", errorCode): 1252 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 1253 1254 case strings.EqualFold("ServerInternalErrorException", errorCode): 1255 return awsAwsjson11_deserializeErrorServerInternalErrorException(response, errorBody) 1256 1257 default: 1258 genericError := &smithy.GenericAPIError{ 1259 Code: errorCode, 1260 Message: errorMessage, 1261 } 1262 return genericError 1263 1264 } 1265} 1266 1267type awsAwsjson11_deserializeOpDescribeExportTasks struct { 1268} 1269 1270func (*awsAwsjson11_deserializeOpDescribeExportTasks) ID() string { 1271 return "OperationDeserializer" 1272} 1273 1274func (m *awsAwsjson11_deserializeOpDescribeExportTasks) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1275 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1276) { 1277 out, metadata, err = next.HandleDeserialize(ctx, in) 1278 if err != nil { 1279 return out, metadata, err 1280 } 1281 1282 response, ok := out.RawResponse.(*smithyhttp.Response) 1283 if !ok { 1284 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1285 } 1286 1287 if response.StatusCode < 200 || response.StatusCode >= 300 { 1288 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeExportTasks(response, &metadata) 1289 } 1290 output := &DescribeExportTasksOutput{} 1291 out.Result = output 1292 1293 var buff [1024]byte 1294 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1295 1296 body := io.TeeReader(response.Body, ringBuffer) 1297 decoder := json.NewDecoder(body) 1298 decoder.UseNumber() 1299 var shape interface{} 1300 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1301 var snapshot bytes.Buffer 1302 io.Copy(&snapshot, ringBuffer) 1303 err = &smithy.DeserializationError{ 1304 Err: fmt.Errorf("failed to decode response body, %w", err), 1305 Snapshot: snapshot.Bytes(), 1306 } 1307 return out, metadata, err 1308 } 1309 1310 err = awsAwsjson11_deserializeOpDocumentDescribeExportTasksOutput(&output, shape) 1311 if err != nil { 1312 var snapshot bytes.Buffer 1313 io.Copy(&snapshot, ringBuffer) 1314 err = &smithy.DeserializationError{ 1315 Err: fmt.Errorf("failed to decode response body, %w", err), 1316 Snapshot: snapshot.Bytes(), 1317 } 1318 return out, metadata, err 1319 } 1320 1321 return out, metadata, err 1322} 1323 1324func awsAwsjson11_deserializeOpErrorDescribeExportTasks(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1325 var errorBuffer bytes.Buffer 1326 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1327 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1328 } 1329 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1330 1331 errorCode := "UnknownError" 1332 errorMessage := errorCode 1333 1334 code := response.Header.Get("X-Amzn-ErrorType") 1335 if len(code) != 0 { 1336 errorCode = restjson.SanitizeErrorCode(code) 1337 } 1338 1339 var buff [1024]byte 1340 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1341 1342 body := io.TeeReader(errorBody, ringBuffer) 1343 decoder := json.NewDecoder(body) 1344 decoder.UseNumber() 1345 code, message, err := restjson.GetErrorInfo(decoder) 1346 if err != nil { 1347 var snapshot bytes.Buffer 1348 io.Copy(&snapshot, ringBuffer) 1349 err = &smithy.DeserializationError{ 1350 Err: fmt.Errorf("failed to decode response body, %w", err), 1351 Snapshot: snapshot.Bytes(), 1352 } 1353 return err 1354 } 1355 1356 errorBody.Seek(0, io.SeekStart) 1357 if len(code) != 0 { 1358 errorCode = restjson.SanitizeErrorCode(code) 1359 } 1360 if len(message) != 0 { 1361 errorMessage = message 1362 } 1363 1364 switch { 1365 case strings.EqualFold("AuthorizationErrorException", errorCode): 1366 return awsAwsjson11_deserializeErrorAuthorizationErrorException(response, errorBody) 1367 1368 case strings.EqualFold("HomeRegionNotSetException", errorCode): 1369 return awsAwsjson11_deserializeErrorHomeRegionNotSetException(response, errorBody) 1370 1371 case strings.EqualFold("InvalidParameterException", errorCode): 1372 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 1373 1374 case strings.EqualFold("InvalidParameterValueException", errorCode): 1375 return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody) 1376 1377 case strings.EqualFold("ServerInternalErrorException", errorCode): 1378 return awsAwsjson11_deserializeErrorServerInternalErrorException(response, errorBody) 1379 1380 default: 1381 genericError := &smithy.GenericAPIError{ 1382 Code: errorCode, 1383 Message: errorMessage, 1384 } 1385 return genericError 1386 1387 } 1388} 1389 1390type awsAwsjson11_deserializeOpDescribeImportTasks struct { 1391} 1392 1393func (*awsAwsjson11_deserializeOpDescribeImportTasks) ID() string { 1394 return "OperationDeserializer" 1395} 1396 1397func (m *awsAwsjson11_deserializeOpDescribeImportTasks) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1398 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1399) { 1400 out, metadata, err = next.HandleDeserialize(ctx, in) 1401 if err != nil { 1402 return out, metadata, err 1403 } 1404 1405 response, ok := out.RawResponse.(*smithyhttp.Response) 1406 if !ok { 1407 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1408 } 1409 1410 if response.StatusCode < 200 || response.StatusCode >= 300 { 1411 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeImportTasks(response, &metadata) 1412 } 1413 output := &DescribeImportTasksOutput{} 1414 out.Result = output 1415 1416 var buff [1024]byte 1417 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1418 1419 body := io.TeeReader(response.Body, ringBuffer) 1420 decoder := json.NewDecoder(body) 1421 decoder.UseNumber() 1422 var shape interface{} 1423 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1424 var snapshot bytes.Buffer 1425 io.Copy(&snapshot, ringBuffer) 1426 err = &smithy.DeserializationError{ 1427 Err: fmt.Errorf("failed to decode response body, %w", err), 1428 Snapshot: snapshot.Bytes(), 1429 } 1430 return out, metadata, err 1431 } 1432 1433 err = awsAwsjson11_deserializeOpDocumentDescribeImportTasksOutput(&output, shape) 1434 if err != nil { 1435 var snapshot bytes.Buffer 1436 io.Copy(&snapshot, ringBuffer) 1437 err = &smithy.DeserializationError{ 1438 Err: fmt.Errorf("failed to decode response body, %w", err), 1439 Snapshot: snapshot.Bytes(), 1440 } 1441 return out, metadata, err 1442 } 1443 1444 return out, metadata, err 1445} 1446 1447func awsAwsjson11_deserializeOpErrorDescribeImportTasks(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1448 var errorBuffer bytes.Buffer 1449 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1450 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1451 } 1452 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1453 1454 errorCode := "UnknownError" 1455 errorMessage := errorCode 1456 1457 code := response.Header.Get("X-Amzn-ErrorType") 1458 if len(code) != 0 { 1459 errorCode = restjson.SanitizeErrorCode(code) 1460 } 1461 1462 var buff [1024]byte 1463 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1464 1465 body := io.TeeReader(errorBody, ringBuffer) 1466 decoder := json.NewDecoder(body) 1467 decoder.UseNumber() 1468 code, message, err := restjson.GetErrorInfo(decoder) 1469 if err != nil { 1470 var snapshot bytes.Buffer 1471 io.Copy(&snapshot, ringBuffer) 1472 err = &smithy.DeserializationError{ 1473 Err: fmt.Errorf("failed to decode response body, %w", err), 1474 Snapshot: snapshot.Bytes(), 1475 } 1476 return err 1477 } 1478 1479 errorBody.Seek(0, io.SeekStart) 1480 if len(code) != 0 { 1481 errorCode = restjson.SanitizeErrorCode(code) 1482 } 1483 if len(message) != 0 { 1484 errorMessage = message 1485 } 1486 1487 switch { 1488 case strings.EqualFold("AuthorizationErrorException", errorCode): 1489 return awsAwsjson11_deserializeErrorAuthorizationErrorException(response, errorBody) 1490 1491 case strings.EqualFold("HomeRegionNotSetException", errorCode): 1492 return awsAwsjson11_deserializeErrorHomeRegionNotSetException(response, errorBody) 1493 1494 case strings.EqualFold("InvalidParameterException", errorCode): 1495 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 1496 1497 case strings.EqualFold("InvalidParameterValueException", errorCode): 1498 return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody) 1499 1500 case strings.EqualFold("ServerInternalErrorException", errorCode): 1501 return awsAwsjson11_deserializeErrorServerInternalErrorException(response, errorBody) 1502 1503 default: 1504 genericError := &smithy.GenericAPIError{ 1505 Code: errorCode, 1506 Message: errorMessage, 1507 } 1508 return genericError 1509 1510 } 1511} 1512 1513type awsAwsjson11_deserializeOpDescribeTags struct { 1514} 1515 1516func (*awsAwsjson11_deserializeOpDescribeTags) ID() string { 1517 return "OperationDeserializer" 1518} 1519 1520func (m *awsAwsjson11_deserializeOpDescribeTags) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1521 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1522) { 1523 out, metadata, err = next.HandleDeserialize(ctx, in) 1524 if err != nil { 1525 return out, metadata, err 1526 } 1527 1528 response, ok := out.RawResponse.(*smithyhttp.Response) 1529 if !ok { 1530 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1531 } 1532 1533 if response.StatusCode < 200 || response.StatusCode >= 300 { 1534 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeTags(response, &metadata) 1535 } 1536 output := &DescribeTagsOutput{} 1537 out.Result = output 1538 1539 var buff [1024]byte 1540 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1541 1542 body := io.TeeReader(response.Body, ringBuffer) 1543 decoder := json.NewDecoder(body) 1544 decoder.UseNumber() 1545 var shape interface{} 1546 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1547 var snapshot bytes.Buffer 1548 io.Copy(&snapshot, ringBuffer) 1549 err = &smithy.DeserializationError{ 1550 Err: fmt.Errorf("failed to decode response body, %w", err), 1551 Snapshot: snapshot.Bytes(), 1552 } 1553 return out, metadata, err 1554 } 1555 1556 err = awsAwsjson11_deserializeOpDocumentDescribeTagsOutput(&output, shape) 1557 if err != nil { 1558 var snapshot bytes.Buffer 1559 io.Copy(&snapshot, ringBuffer) 1560 err = &smithy.DeserializationError{ 1561 Err: fmt.Errorf("failed to decode response body, %w", err), 1562 Snapshot: snapshot.Bytes(), 1563 } 1564 return out, metadata, err 1565 } 1566 1567 return out, metadata, err 1568} 1569 1570func awsAwsjson11_deserializeOpErrorDescribeTags(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1571 var errorBuffer bytes.Buffer 1572 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1573 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1574 } 1575 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1576 1577 errorCode := "UnknownError" 1578 errorMessage := errorCode 1579 1580 code := response.Header.Get("X-Amzn-ErrorType") 1581 if len(code) != 0 { 1582 errorCode = restjson.SanitizeErrorCode(code) 1583 } 1584 1585 var buff [1024]byte 1586 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1587 1588 body := io.TeeReader(errorBody, ringBuffer) 1589 decoder := json.NewDecoder(body) 1590 decoder.UseNumber() 1591 code, message, err := restjson.GetErrorInfo(decoder) 1592 if err != nil { 1593 var snapshot bytes.Buffer 1594 io.Copy(&snapshot, ringBuffer) 1595 err = &smithy.DeserializationError{ 1596 Err: fmt.Errorf("failed to decode response body, %w", err), 1597 Snapshot: snapshot.Bytes(), 1598 } 1599 return err 1600 } 1601 1602 errorBody.Seek(0, io.SeekStart) 1603 if len(code) != 0 { 1604 errorCode = restjson.SanitizeErrorCode(code) 1605 } 1606 if len(message) != 0 { 1607 errorMessage = message 1608 } 1609 1610 switch { 1611 case strings.EqualFold("AuthorizationErrorException", errorCode): 1612 return awsAwsjson11_deserializeErrorAuthorizationErrorException(response, errorBody) 1613 1614 case strings.EqualFold("HomeRegionNotSetException", errorCode): 1615 return awsAwsjson11_deserializeErrorHomeRegionNotSetException(response, errorBody) 1616 1617 case strings.EqualFold("InvalidParameterException", errorCode): 1618 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 1619 1620 case strings.EqualFold("InvalidParameterValueException", errorCode): 1621 return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody) 1622 1623 case strings.EqualFold("ResourceNotFoundException", errorCode): 1624 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 1625 1626 case strings.EqualFold("ServerInternalErrorException", errorCode): 1627 return awsAwsjson11_deserializeErrorServerInternalErrorException(response, errorBody) 1628 1629 default: 1630 genericError := &smithy.GenericAPIError{ 1631 Code: errorCode, 1632 Message: errorMessage, 1633 } 1634 return genericError 1635 1636 } 1637} 1638 1639type awsAwsjson11_deserializeOpDisassociateConfigurationItemsFromApplication struct { 1640} 1641 1642func (*awsAwsjson11_deserializeOpDisassociateConfigurationItemsFromApplication) ID() string { 1643 return "OperationDeserializer" 1644} 1645 1646func (m *awsAwsjson11_deserializeOpDisassociateConfigurationItemsFromApplication) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1647 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1648) { 1649 out, metadata, err = next.HandleDeserialize(ctx, in) 1650 if err != nil { 1651 return out, metadata, err 1652 } 1653 1654 response, ok := out.RawResponse.(*smithyhttp.Response) 1655 if !ok { 1656 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1657 } 1658 1659 if response.StatusCode < 200 || response.StatusCode >= 300 { 1660 return out, metadata, awsAwsjson11_deserializeOpErrorDisassociateConfigurationItemsFromApplication(response, &metadata) 1661 } 1662 output := &DisassociateConfigurationItemsFromApplicationOutput{} 1663 out.Result = output 1664 1665 var buff [1024]byte 1666 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1667 1668 body := io.TeeReader(response.Body, ringBuffer) 1669 decoder := json.NewDecoder(body) 1670 decoder.UseNumber() 1671 var shape interface{} 1672 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1673 var snapshot bytes.Buffer 1674 io.Copy(&snapshot, ringBuffer) 1675 err = &smithy.DeserializationError{ 1676 Err: fmt.Errorf("failed to decode response body, %w", err), 1677 Snapshot: snapshot.Bytes(), 1678 } 1679 return out, metadata, err 1680 } 1681 1682 err = awsAwsjson11_deserializeOpDocumentDisassociateConfigurationItemsFromApplicationOutput(&output, shape) 1683 if err != nil { 1684 var snapshot bytes.Buffer 1685 io.Copy(&snapshot, ringBuffer) 1686 err = &smithy.DeserializationError{ 1687 Err: fmt.Errorf("failed to decode response body, %w", err), 1688 Snapshot: snapshot.Bytes(), 1689 } 1690 return out, metadata, err 1691 } 1692 1693 return out, metadata, err 1694} 1695 1696func awsAwsjson11_deserializeOpErrorDisassociateConfigurationItemsFromApplication(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1697 var errorBuffer bytes.Buffer 1698 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1699 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1700 } 1701 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1702 1703 errorCode := "UnknownError" 1704 errorMessage := errorCode 1705 1706 code := response.Header.Get("X-Amzn-ErrorType") 1707 if len(code) != 0 { 1708 errorCode = restjson.SanitizeErrorCode(code) 1709 } 1710 1711 var buff [1024]byte 1712 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1713 1714 body := io.TeeReader(errorBody, ringBuffer) 1715 decoder := json.NewDecoder(body) 1716 decoder.UseNumber() 1717 code, message, err := restjson.GetErrorInfo(decoder) 1718 if err != nil { 1719 var snapshot bytes.Buffer 1720 io.Copy(&snapshot, ringBuffer) 1721 err = &smithy.DeserializationError{ 1722 Err: fmt.Errorf("failed to decode response body, %w", err), 1723 Snapshot: snapshot.Bytes(), 1724 } 1725 return err 1726 } 1727 1728 errorBody.Seek(0, io.SeekStart) 1729 if len(code) != 0 { 1730 errorCode = restjson.SanitizeErrorCode(code) 1731 } 1732 if len(message) != 0 { 1733 errorMessage = message 1734 } 1735 1736 switch { 1737 case strings.EqualFold("AuthorizationErrorException", errorCode): 1738 return awsAwsjson11_deserializeErrorAuthorizationErrorException(response, errorBody) 1739 1740 case strings.EqualFold("HomeRegionNotSetException", errorCode): 1741 return awsAwsjson11_deserializeErrorHomeRegionNotSetException(response, errorBody) 1742 1743 case strings.EqualFold("InvalidParameterException", errorCode): 1744 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 1745 1746 case strings.EqualFold("InvalidParameterValueException", errorCode): 1747 return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody) 1748 1749 case strings.EqualFold("ServerInternalErrorException", errorCode): 1750 return awsAwsjson11_deserializeErrorServerInternalErrorException(response, errorBody) 1751 1752 default: 1753 genericError := &smithy.GenericAPIError{ 1754 Code: errorCode, 1755 Message: errorMessage, 1756 } 1757 return genericError 1758 1759 } 1760} 1761 1762type awsAwsjson11_deserializeOpExportConfigurations struct { 1763} 1764 1765func (*awsAwsjson11_deserializeOpExportConfigurations) ID() string { 1766 return "OperationDeserializer" 1767} 1768 1769func (m *awsAwsjson11_deserializeOpExportConfigurations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1770 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1771) { 1772 out, metadata, err = next.HandleDeserialize(ctx, in) 1773 if err != nil { 1774 return out, metadata, err 1775 } 1776 1777 response, ok := out.RawResponse.(*smithyhttp.Response) 1778 if !ok { 1779 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1780 } 1781 1782 if response.StatusCode < 200 || response.StatusCode >= 300 { 1783 return out, metadata, awsAwsjson11_deserializeOpErrorExportConfigurations(response, &metadata) 1784 } 1785 output := &ExportConfigurationsOutput{} 1786 out.Result = output 1787 1788 var buff [1024]byte 1789 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1790 1791 body := io.TeeReader(response.Body, ringBuffer) 1792 decoder := json.NewDecoder(body) 1793 decoder.UseNumber() 1794 var shape interface{} 1795 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1796 var snapshot bytes.Buffer 1797 io.Copy(&snapshot, ringBuffer) 1798 err = &smithy.DeserializationError{ 1799 Err: fmt.Errorf("failed to decode response body, %w", err), 1800 Snapshot: snapshot.Bytes(), 1801 } 1802 return out, metadata, err 1803 } 1804 1805 err = awsAwsjson11_deserializeOpDocumentExportConfigurationsOutput(&output, shape) 1806 if err != nil { 1807 var snapshot bytes.Buffer 1808 io.Copy(&snapshot, ringBuffer) 1809 err = &smithy.DeserializationError{ 1810 Err: fmt.Errorf("failed to decode response body, %w", err), 1811 Snapshot: snapshot.Bytes(), 1812 } 1813 return out, metadata, err 1814 } 1815 1816 return out, metadata, err 1817} 1818 1819func awsAwsjson11_deserializeOpErrorExportConfigurations(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1820 var errorBuffer bytes.Buffer 1821 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1822 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1823 } 1824 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1825 1826 errorCode := "UnknownError" 1827 errorMessage := errorCode 1828 1829 code := response.Header.Get("X-Amzn-ErrorType") 1830 if len(code) != 0 { 1831 errorCode = restjson.SanitizeErrorCode(code) 1832 } 1833 1834 var buff [1024]byte 1835 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1836 1837 body := io.TeeReader(errorBody, ringBuffer) 1838 decoder := json.NewDecoder(body) 1839 decoder.UseNumber() 1840 code, message, err := restjson.GetErrorInfo(decoder) 1841 if err != nil { 1842 var snapshot bytes.Buffer 1843 io.Copy(&snapshot, ringBuffer) 1844 err = &smithy.DeserializationError{ 1845 Err: fmt.Errorf("failed to decode response body, %w", err), 1846 Snapshot: snapshot.Bytes(), 1847 } 1848 return err 1849 } 1850 1851 errorBody.Seek(0, io.SeekStart) 1852 if len(code) != 0 { 1853 errorCode = restjson.SanitizeErrorCode(code) 1854 } 1855 if len(message) != 0 { 1856 errorMessage = message 1857 } 1858 1859 switch { 1860 case strings.EqualFold("AuthorizationErrorException", errorCode): 1861 return awsAwsjson11_deserializeErrorAuthorizationErrorException(response, errorBody) 1862 1863 case strings.EqualFold("HomeRegionNotSetException", errorCode): 1864 return awsAwsjson11_deserializeErrorHomeRegionNotSetException(response, errorBody) 1865 1866 case strings.EqualFold("InvalidParameterException", errorCode): 1867 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 1868 1869 case strings.EqualFold("InvalidParameterValueException", errorCode): 1870 return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody) 1871 1872 case strings.EqualFold("OperationNotPermittedException", errorCode): 1873 return awsAwsjson11_deserializeErrorOperationNotPermittedException(response, errorBody) 1874 1875 case strings.EqualFold("ServerInternalErrorException", errorCode): 1876 return awsAwsjson11_deserializeErrorServerInternalErrorException(response, errorBody) 1877 1878 default: 1879 genericError := &smithy.GenericAPIError{ 1880 Code: errorCode, 1881 Message: errorMessage, 1882 } 1883 return genericError 1884 1885 } 1886} 1887 1888type awsAwsjson11_deserializeOpGetDiscoverySummary struct { 1889} 1890 1891func (*awsAwsjson11_deserializeOpGetDiscoverySummary) ID() string { 1892 return "OperationDeserializer" 1893} 1894 1895func (m *awsAwsjson11_deserializeOpGetDiscoverySummary) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1896 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1897) { 1898 out, metadata, err = next.HandleDeserialize(ctx, in) 1899 if err != nil { 1900 return out, metadata, err 1901 } 1902 1903 response, ok := out.RawResponse.(*smithyhttp.Response) 1904 if !ok { 1905 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1906 } 1907 1908 if response.StatusCode < 200 || response.StatusCode >= 300 { 1909 return out, metadata, awsAwsjson11_deserializeOpErrorGetDiscoverySummary(response, &metadata) 1910 } 1911 output := &GetDiscoverySummaryOutput{} 1912 out.Result = output 1913 1914 var buff [1024]byte 1915 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1916 1917 body := io.TeeReader(response.Body, ringBuffer) 1918 decoder := json.NewDecoder(body) 1919 decoder.UseNumber() 1920 var shape interface{} 1921 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1922 var snapshot bytes.Buffer 1923 io.Copy(&snapshot, ringBuffer) 1924 err = &smithy.DeserializationError{ 1925 Err: fmt.Errorf("failed to decode response body, %w", err), 1926 Snapshot: snapshot.Bytes(), 1927 } 1928 return out, metadata, err 1929 } 1930 1931 err = awsAwsjson11_deserializeOpDocumentGetDiscoverySummaryOutput(&output, shape) 1932 if err != nil { 1933 var snapshot bytes.Buffer 1934 io.Copy(&snapshot, ringBuffer) 1935 err = &smithy.DeserializationError{ 1936 Err: fmt.Errorf("failed to decode response body, %w", err), 1937 Snapshot: snapshot.Bytes(), 1938 } 1939 return out, metadata, err 1940 } 1941 1942 return out, metadata, err 1943} 1944 1945func awsAwsjson11_deserializeOpErrorGetDiscoverySummary(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1946 var errorBuffer bytes.Buffer 1947 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1948 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1949 } 1950 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1951 1952 errorCode := "UnknownError" 1953 errorMessage := errorCode 1954 1955 code := response.Header.Get("X-Amzn-ErrorType") 1956 if len(code) != 0 { 1957 errorCode = restjson.SanitizeErrorCode(code) 1958 } 1959 1960 var buff [1024]byte 1961 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1962 1963 body := io.TeeReader(errorBody, ringBuffer) 1964 decoder := json.NewDecoder(body) 1965 decoder.UseNumber() 1966 code, message, err := restjson.GetErrorInfo(decoder) 1967 if err != nil { 1968 var snapshot bytes.Buffer 1969 io.Copy(&snapshot, ringBuffer) 1970 err = &smithy.DeserializationError{ 1971 Err: fmt.Errorf("failed to decode response body, %w", err), 1972 Snapshot: snapshot.Bytes(), 1973 } 1974 return err 1975 } 1976 1977 errorBody.Seek(0, io.SeekStart) 1978 if len(code) != 0 { 1979 errorCode = restjson.SanitizeErrorCode(code) 1980 } 1981 if len(message) != 0 { 1982 errorMessage = message 1983 } 1984 1985 switch { 1986 case strings.EqualFold("AuthorizationErrorException", errorCode): 1987 return awsAwsjson11_deserializeErrorAuthorizationErrorException(response, errorBody) 1988 1989 case strings.EqualFold("HomeRegionNotSetException", errorCode): 1990 return awsAwsjson11_deserializeErrorHomeRegionNotSetException(response, errorBody) 1991 1992 case strings.EqualFold("InvalidParameterException", errorCode): 1993 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 1994 1995 case strings.EqualFold("InvalidParameterValueException", errorCode): 1996 return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody) 1997 1998 case strings.EqualFold("ServerInternalErrorException", errorCode): 1999 return awsAwsjson11_deserializeErrorServerInternalErrorException(response, errorBody) 2000 2001 default: 2002 genericError := &smithy.GenericAPIError{ 2003 Code: errorCode, 2004 Message: errorMessage, 2005 } 2006 return genericError 2007 2008 } 2009} 2010 2011type awsAwsjson11_deserializeOpListConfigurations struct { 2012} 2013 2014func (*awsAwsjson11_deserializeOpListConfigurations) ID() string { 2015 return "OperationDeserializer" 2016} 2017 2018func (m *awsAwsjson11_deserializeOpListConfigurations) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2019 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2020) { 2021 out, metadata, err = next.HandleDeserialize(ctx, in) 2022 if err != nil { 2023 return out, metadata, err 2024 } 2025 2026 response, ok := out.RawResponse.(*smithyhttp.Response) 2027 if !ok { 2028 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2029 } 2030 2031 if response.StatusCode < 200 || response.StatusCode >= 300 { 2032 return out, metadata, awsAwsjson11_deserializeOpErrorListConfigurations(response, &metadata) 2033 } 2034 output := &ListConfigurationsOutput{} 2035 out.Result = output 2036 2037 var buff [1024]byte 2038 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2039 2040 body := io.TeeReader(response.Body, ringBuffer) 2041 decoder := json.NewDecoder(body) 2042 decoder.UseNumber() 2043 var shape interface{} 2044 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2045 var snapshot bytes.Buffer 2046 io.Copy(&snapshot, ringBuffer) 2047 err = &smithy.DeserializationError{ 2048 Err: fmt.Errorf("failed to decode response body, %w", err), 2049 Snapshot: snapshot.Bytes(), 2050 } 2051 return out, metadata, err 2052 } 2053 2054 err = awsAwsjson11_deserializeOpDocumentListConfigurationsOutput(&output, shape) 2055 if err != nil { 2056 var snapshot bytes.Buffer 2057 io.Copy(&snapshot, ringBuffer) 2058 err = &smithy.DeserializationError{ 2059 Err: fmt.Errorf("failed to decode response body, %w", err), 2060 Snapshot: snapshot.Bytes(), 2061 } 2062 return out, metadata, err 2063 } 2064 2065 return out, metadata, err 2066} 2067 2068func awsAwsjson11_deserializeOpErrorListConfigurations(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2069 var errorBuffer bytes.Buffer 2070 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2071 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2072 } 2073 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2074 2075 errorCode := "UnknownError" 2076 errorMessage := errorCode 2077 2078 code := response.Header.Get("X-Amzn-ErrorType") 2079 if len(code) != 0 { 2080 errorCode = restjson.SanitizeErrorCode(code) 2081 } 2082 2083 var buff [1024]byte 2084 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2085 2086 body := io.TeeReader(errorBody, ringBuffer) 2087 decoder := json.NewDecoder(body) 2088 decoder.UseNumber() 2089 code, message, err := restjson.GetErrorInfo(decoder) 2090 if err != nil { 2091 var snapshot bytes.Buffer 2092 io.Copy(&snapshot, ringBuffer) 2093 err = &smithy.DeserializationError{ 2094 Err: fmt.Errorf("failed to decode response body, %w", err), 2095 Snapshot: snapshot.Bytes(), 2096 } 2097 return err 2098 } 2099 2100 errorBody.Seek(0, io.SeekStart) 2101 if len(code) != 0 { 2102 errorCode = restjson.SanitizeErrorCode(code) 2103 } 2104 if len(message) != 0 { 2105 errorMessage = message 2106 } 2107 2108 switch { 2109 case strings.EqualFold("AuthorizationErrorException", errorCode): 2110 return awsAwsjson11_deserializeErrorAuthorizationErrorException(response, errorBody) 2111 2112 case strings.EqualFold("HomeRegionNotSetException", errorCode): 2113 return awsAwsjson11_deserializeErrorHomeRegionNotSetException(response, errorBody) 2114 2115 case strings.EqualFold("InvalidParameterException", errorCode): 2116 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 2117 2118 case strings.EqualFold("InvalidParameterValueException", errorCode): 2119 return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody) 2120 2121 case strings.EqualFold("ResourceNotFoundException", errorCode): 2122 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 2123 2124 case strings.EqualFold("ServerInternalErrorException", errorCode): 2125 return awsAwsjson11_deserializeErrorServerInternalErrorException(response, errorBody) 2126 2127 default: 2128 genericError := &smithy.GenericAPIError{ 2129 Code: errorCode, 2130 Message: errorMessage, 2131 } 2132 return genericError 2133 2134 } 2135} 2136 2137type awsAwsjson11_deserializeOpListServerNeighbors struct { 2138} 2139 2140func (*awsAwsjson11_deserializeOpListServerNeighbors) ID() string { 2141 return "OperationDeserializer" 2142} 2143 2144func (m *awsAwsjson11_deserializeOpListServerNeighbors) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2145 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2146) { 2147 out, metadata, err = next.HandleDeserialize(ctx, in) 2148 if err != nil { 2149 return out, metadata, err 2150 } 2151 2152 response, ok := out.RawResponse.(*smithyhttp.Response) 2153 if !ok { 2154 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2155 } 2156 2157 if response.StatusCode < 200 || response.StatusCode >= 300 { 2158 return out, metadata, awsAwsjson11_deserializeOpErrorListServerNeighbors(response, &metadata) 2159 } 2160 output := &ListServerNeighborsOutput{} 2161 out.Result = output 2162 2163 var buff [1024]byte 2164 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2165 2166 body := io.TeeReader(response.Body, ringBuffer) 2167 decoder := json.NewDecoder(body) 2168 decoder.UseNumber() 2169 var shape interface{} 2170 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2171 var snapshot bytes.Buffer 2172 io.Copy(&snapshot, ringBuffer) 2173 err = &smithy.DeserializationError{ 2174 Err: fmt.Errorf("failed to decode response body, %w", err), 2175 Snapshot: snapshot.Bytes(), 2176 } 2177 return out, metadata, err 2178 } 2179 2180 err = awsAwsjson11_deserializeOpDocumentListServerNeighborsOutput(&output, shape) 2181 if err != nil { 2182 var snapshot bytes.Buffer 2183 io.Copy(&snapshot, ringBuffer) 2184 err = &smithy.DeserializationError{ 2185 Err: fmt.Errorf("failed to decode response body, %w", err), 2186 Snapshot: snapshot.Bytes(), 2187 } 2188 return out, metadata, err 2189 } 2190 2191 return out, metadata, err 2192} 2193 2194func awsAwsjson11_deserializeOpErrorListServerNeighbors(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2195 var errorBuffer bytes.Buffer 2196 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2197 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2198 } 2199 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2200 2201 errorCode := "UnknownError" 2202 errorMessage := errorCode 2203 2204 code := response.Header.Get("X-Amzn-ErrorType") 2205 if len(code) != 0 { 2206 errorCode = restjson.SanitizeErrorCode(code) 2207 } 2208 2209 var buff [1024]byte 2210 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2211 2212 body := io.TeeReader(errorBody, ringBuffer) 2213 decoder := json.NewDecoder(body) 2214 decoder.UseNumber() 2215 code, message, err := restjson.GetErrorInfo(decoder) 2216 if err != nil { 2217 var snapshot bytes.Buffer 2218 io.Copy(&snapshot, ringBuffer) 2219 err = &smithy.DeserializationError{ 2220 Err: fmt.Errorf("failed to decode response body, %w", err), 2221 Snapshot: snapshot.Bytes(), 2222 } 2223 return err 2224 } 2225 2226 errorBody.Seek(0, io.SeekStart) 2227 if len(code) != 0 { 2228 errorCode = restjson.SanitizeErrorCode(code) 2229 } 2230 if len(message) != 0 { 2231 errorMessage = message 2232 } 2233 2234 switch { 2235 case strings.EqualFold("AuthorizationErrorException", errorCode): 2236 return awsAwsjson11_deserializeErrorAuthorizationErrorException(response, errorBody) 2237 2238 case strings.EqualFold("HomeRegionNotSetException", errorCode): 2239 return awsAwsjson11_deserializeErrorHomeRegionNotSetException(response, errorBody) 2240 2241 case strings.EqualFold("InvalidParameterException", errorCode): 2242 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 2243 2244 case strings.EqualFold("InvalidParameterValueException", errorCode): 2245 return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody) 2246 2247 case strings.EqualFold("ServerInternalErrorException", errorCode): 2248 return awsAwsjson11_deserializeErrorServerInternalErrorException(response, errorBody) 2249 2250 default: 2251 genericError := &smithy.GenericAPIError{ 2252 Code: errorCode, 2253 Message: errorMessage, 2254 } 2255 return genericError 2256 2257 } 2258} 2259 2260type awsAwsjson11_deserializeOpStartContinuousExport struct { 2261} 2262 2263func (*awsAwsjson11_deserializeOpStartContinuousExport) ID() string { 2264 return "OperationDeserializer" 2265} 2266 2267func (m *awsAwsjson11_deserializeOpStartContinuousExport) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2268 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2269) { 2270 out, metadata, err = next.HandleDeserialize(ctx, in) 2271 if err != nil { 2272 return out, metadata, err 2273 } 2274 2275 response, ok := out.RawResponse.(*smithyhttp.Response) 2276 if !ok { 2277 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2278 } 2279 2280 if response.StatusCode < 200 || response.StatusCode >= 300 { 2281 return out, metadata, awsAwsjson11_deserializeOpErrorStartContinuousExport(response, &metadata) 2282 } 2283 output := &StartContinuousExportOutput{} 2284 out.Result = output 2285 2286 var buff [1024]byte 2287 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2288 2289 body := io.TeeReader(response.Body, ringBuffer) 2290 decoder := json.NewDecoder(body) 2291 decoder.UseNumber() 2292 var shape interface{} 2293 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2294 var snapshot bytes.Buffer 2295 io.Copy(&snapshot, ringBuffer) 2296 err = &smithy.DeserializationError{ 2297 Err: fmt.Errorf("failed to decode response body, %w", err), 2298 Snapshot: snapshot.Bytes(), 2299 } 2300 return out, metadata, err 2301 } 2302 2303 err = awsAwsjson11_deserializeOpDocumentStartContinuousExportOutput(&output, shape) 2304 if err != nil { 2305 var snapshot bytes.Buffer 2306 io.Copy(&snapshot, ringBuffer) 2307 err = &smithy.DeserializationError{ 2308 Err: fmt.Errorf("failed to decode response body, %w", err), 2309 Snapshot: snapshot.Bytes(), 2310 } 2311 return out, metadata, err 2312 } 2313 2314 return out, metadata, err 2315} 2316 2317func awsAwsjson11_deserializeOpErrorStartContinuousExport(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2318 var errorBuffer bytes.Buffer 2319 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2320 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2321 } 2322 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2323 2324 errorCode := "UnknownError" 2325 errorMessage := errorCode 2326 2327 code := response.Header.Get("X-Amzn-ErrorType") 2328 if len(code) != 0 { 2329 errorCode = restjson.SanitizeErrorCode(code) 2330 } 2331 2332 var buff [1024]byte 2333 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2334 2335 body := io.TeeReader(errorBody, ringBuffer) 2336 decoder := json.NewDecoder(body) 2337 decoder.UseNumber() 2338 code, message, err := restjson.GetErrorInfo(decoder) 2339 if err != nil { 2340 var snapshot bytes.Buffer 2341 io.Copy(&snapshot, ringBuffer) 2342 err = &smithy.DeserializationError{ 2343 Err: fmt.Errorf("failed to decode response body, %w", err), 2344 Snapshot: snapshot.Bytes(), 2345 } 2346 return err 2347 } 2348 2349 errorBody.Seek(0, io.SeekStart) 2350 if len(code) != 0 { 2351 errorCode = restjson.SanitizeErrorCode(code) 2352 } 2353 if len(message) != 0 { 2354 errorMessage = message 2355 } 2356 2357 switch { 2358 case strings.EqualFold("AuthorizationErrorException", errorCode): 2359 return awsAwsjson11_deserializeErrorAuthorizationErrorException(response, errorBody) 2360 2361 case strings.EqualFold("ConflictErrorException", errorCode): 2362 return awsAwsjson11_deserializeErrorConflictErrorException(response, errorBody) 2363 2364 case strings.EqualFold("HomeRegionNotSetException", errorCode): 2365 return awsAwsjson11_deserializeErrorHomeRegionNotSetException(response, errorBody) 2366 2367 case strings.EqualFold("InvalidParameterException", errorCode): 2368 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 2369 2370 case strings.EqualFold("InvalidParameterValueException", errorCode): 2371 return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody) 2372 2373 case strings.EqualFold("OperationNotPermittedException", errorCode): 2374 return awsAwsjson11_deserializeErrorOperationNotPermittedException(response, errorBody) 2375 2376 case strings.EqualFold("ResourceInUseException", errorCode): 2377 return awsAwsjson11_deserializeErrorResourceInUseException(response, errorBody) 2378 2379 case strings.EqualFold("ServerInternalErrorException", errorCode): 2380 return awsAwsjson11_deserializeErrorServerInternalErrorException(response, errorBody) 2381 2382 default: 2383 genericError := &smithy.GenericAPIError{ 2384 Code: errorCode, 2385 Message: errorMessage, 2386 } 2387 return genericError 2388 2389 } 2390} 2391 2392type awsAwsjson11_deserializeOpStartDataCollectionByAgentIds struct { 2393} 2394 2395func (*awsAwsjson11_deserializeOpStartDataCollectionByAgentIds) ID() string { 2396 return "OperationDeserializer" 2397} 2398 2399func (m *awsAwsjson11_deserializeOpStartDataCollectionByAgentIds) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2400 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2401) { 2402 out, metadata, err = next.HandleDeserialize(ctx, in) 2403 if err != nil { 2404 return out, metadata, err 2405 } 2406 2407 response, ok := out.RawResponse.(*smithyhttp.Response) 2408 if !ok { 2409 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2410 } 2411 2412 if response.StatusCode < 200 || response.StatusCode >= 300 { 2413 return out, metadata, awsAwsjson11_deserializeOpErrorStartDataCollectionByAgentIds(response, &metadata) 2414 } 2415 output := &StartDataCollectionByAgentIdsOutput{} 2416 out.Result = output 2417 2418 var buff [1024]byte 2419 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2420 2421 body := io.TeeReader(response.Body, ringBuffer) 2422 decoder := json.NewDecoder(body) 2423 decoder.UseNumber() 2424 var shape interface{} 2425 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2426 var snapshot bytes.Buffer 2427 io.Copy(&snapshot, ringBuffer) 2428 err = &smithy.DeserializationError{ 2429 Err: fmt.Errorf("failed to decode response body, %w", err), 2430 Snapshot: snapshot.Bytes(), 2431 } 2432 return out, metadata, err 2433 } 2434 2435 err = awsAwsjson11_deserializeOpDocumentStartDataCollectionByAgentIdsOutput(&output, shape) 2436 if err != nil { 2437 var snapshot bytes.Buffer 2438 io.Copy(&snapshot, ringBuffer) 2439 err = &smithy.DeserializationError{ 2440 Err: fmt.Errorf("failed to decode response body, %w", err), 2441 Snapshot: snapshot.Bytes(), 2442 } 2443 return out, metadata, err 2444 } 2445 2446 return out, metadata, err 2447} 2448 2449func awsAwsjson11_deserializeOpErrorStartDataCollectionByAgentIds(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2450 var errorBuffer bytes.Buffer 2451 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2452 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2453 } 2454 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2455 2456 errorCode := "UnknownError" 2457 errorMessage := errorCode 2458 2459 code := response.Header.Get("X-Amzn-ErrorType") 2460 if len(code) != 0 { 2461 errorCode = restjson.SanitizeErrorCode(code) 2462 } 2463 2464 var buff [1024]byte 2465 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2466 2467 body := io.TeeReader(errorBody, ringBuffer) 2468 decoder := json.NewDecoder(body) 2469 decoder.UseNumber() 2470 code, message, err := restjson.GetErrorInfo(decoder) 2471 if err != nil { 2472 var snapshot bytes.Buffer 2473 io.Copy(&snapshot, ringBuffer) 2474 err = &smithy.DeserializationError{ 2475 Err: fmt.Errorf("failed to decode response body, %w", err), 2476 Snapshot: snapshot.Bytes(), 2477 } 2478 return err 2479 } 2480 2481 errorBody.Seek(0, io.SeekStart) 2482 if len(code) != 0 { 2483 errorCode = restjson.SanitizeErrorCode(code) 2484 } 2485 if len(message) != 0 { 2486 errorMessage = message 2487 } 2488 2489 switch { 2490 case strings.EqualFold("AuthorizationErrorException", errorCode): 2491 return awsAwsjson11_deserializeErrorAuthorizationErrorException(response, errorBody) 2492 2493 case strings.EqualFold("HomeRegionNotSetException", errorCode): 2494 return awsAwsjson11_deserializeErrorHomeRegionNotSetException(response, errorBody) 2495 2496 case strings.EqualFold("InvalidParameterException", errorCode): 2497 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 2498 2499 case strings.EqualFold("InvalidParameterValueException", errorCode): 2500 return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody) 2501 2502 case strings.EqualFold("ServerInternalErrorException", errorCode): 2503 return awsAwsjson11_deserializeErrorServerInternalErrorException(response, errorBody) 2504 2505 default: 2506 genericError := &smithy.GenericAPIError{ 2507 Code: errorCode, 2508 Message: errorMessage, 2509 } 2510 return genericError 2511 2512 } 2513} 2514 2515type awsAwsjson11_deserializeOpStartExportTask struct { 2516} 2517 2518func (*awsAwsjson11_deserializeOpStartExportTask) ID() string { 2519 return "OperationDeserializer" 2520} 2521 2522func (m *awsAwsjson11_deserializeOpStartExportTask) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2523 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2524) { 2525 out, metadata, err = next.HandleDeserialize(ctx, in) 2526 if err != nil { 2527 return out, metadata, err 2528 } 2529 2530 response, ok := out.RawResponse.(*smithyhttp.Response) 2531 if !ok { 2532 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2533 } 2534 2535 if response.StatusCode < 200 || response.StatusCode >= 300 { 2536 return out, metadata, awsAwsjson11_deserializeOpErrorStartExportTask(response, &metadata) 2537 } 2538 output := &StartExportTaskOutput{} 2539 out.Result = output 2540 2541 var buff [1024]byte 2542 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2543 2544 body := io.TeeReader(response.Body, ringBuffer) 2545 decoder := json.NewDecoder(body) 2546 decoder.UseNumber() 2547 var shape interface{} 2548 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2549 var snapshot bytes.Buffer 2550 io.Copy(&snapshot, ringBuffer) 2551 err = &smithy.DeserializationError{ 2552 Err: fmt.Errorf("failed to decode response body, %w", err), 2553 Snapshot: snapshot.Bytes(), 2554 } 2555 return out, metadata, err 2556 } 2557 2558 err = awsAwsjson11_deserializeOpDocumentStartExportTaskOutput(&output, shape) 2559 if err != nil { 2560 var snapshot bytes.Buffer 2561 io.Copy(&snapshot, ringBuffer) 2562 err = &smithy.DeserializationError{ 2563 Err: fmt.Errorf("failed to decode response body, %w", err), 2564 Snapshot: snapshot.Bytes(), 2565 } 2566 return out, metadata, err 2567 } 2568 2569 return out, metadata, err 2570} 2571 2572func awsAwsjson11_deserializeOpErrorStartExportTask(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2573 var errorBuffer bytes.Buffer 2574 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2575 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2576 } 2577 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2578 2579 errorCode := "UnknownError" 2580 errorMessage := errorCode 2581 2582 code := response.Header.Get("X-Amzn-ErrorType") 2583 if len(code) != 0 { 2584 errorCode = restjson.SanitizeErrorCode(code) 2585 } 2586 2587 var buff [1024]byte 2588 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2589 2590 body := io.TeeReader(errorBody, ringBuffer) 2591 decoder := json.NewDecoder(body) 2592 decoder.UseNumber() 2593 code, message, err := restjson.GetErrorInfo(decoder) 2594 if err != nil { 2595 var snapshot bytes.Buffer 2596 io.Copy(&snapshot, ringBuffer) 2597 err = &smithy.DeserializationError{ 2598 Err: fmt.Errorf("failed to decode response body, %w", err), 2599 Snapshot: snapshot.Bytes(), 2600 } 2601 return err 2602 } 2603 2604 errorBody.Seek(0, io.SeekStart) 2605 if len(code) != 0 { 2606 errorCode = restjson.SanitizeErrorCode(code) 2607 } 2608 if len(message) != 0 { 2609 errorMessage = message 2610 } 2611 2612 switch { 2613 case strings.EqualFold("AuthorizationErrorException", errorCode): 2614 return awsAwsjson11_deserializeErrorAuthorizationErrorException(response, errorBody) 2615 2616 case strings.EqualFold("HomeRegionNotSetException", errorCode): 2617 return awsAwsjson11_deserializeErrorHomeRegionNotSetException(response, errorBody) 2618 2619 case strings.EqualFold("InvalidParameterException", errorCode): 2620 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 2621 2622 case strings.EqualFold("InvalidParameterValueException", errorCode): 2623 return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody) 2624 2625 case strings.EqualFold("OperationNotPermittedException", errorCode): 2626 return awsAwsjson11_deserializeErrorOperationNotPermittedException(response, errorBody) 2627 2628 case strings.EqualFold("ServerInternalErrorException", errorCode): 2629 return awsAwsjson11_deserializeErrorServerInternalErrorException(response, errorBody) 2630 2631 default: 2632 genericError := &smithy.GenericAPIError{ 2633 Code: errorCode, 2634 Message: errorMessage, 2635 } 2636 return genericError 2637 2638 } 2639} 2640 2641type awsAwsjson11_deserializeOpStartImportTask struct { 2642} 2643 2644func (*awsAwsjson11_deserializeOpStartImportTask) ID() string { 2645 return "OperationDeserializer" 2646} 2647 2648func (m *awsAwsjson11_deserializeOpStartImportTask) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2649 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2650) { 2651 out, metadata, err = next.HandleDeserialize(ctx, in) 2652 if err != nil { 2653 return out, metadata, err 2654 } 2655 2656 response, ok := out.RawResponse.(*smithyhttp.Response) 2657 if !ok { 2658 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2659 } 2660 2661 if response.StatusCode < 200 || response.StatusCode >= 300 { 2662 return out, metadata, awsAwsjson11_deserializeOpErrorStartImportTask(response, &metadata) 2663 } 2664 output := &StartImportTaskOutput{} 2665 out.Result = output 2666 2667 var buff [1024]byte 2668 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2669 2670 body := io.TeeReader(response.Body, ringBuffer) 2671 decoder := json.NewDecoder(body) 2672 decoder.UseNumber() 2673 var shape interface{} 2674 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2675 var snapshot bytes.Buffer 2676 io.Copy(&snapshot, ringBuffer) 2677 err = &smithy.DeserializationError{ 2678 Err: fmt.Errorf("failed to decode response body, %w", err), 2679 Snapshot: snapshot.Bytes(), 2680 } 2681 return out, metadata, err 2682 } 2683 2684 err = awsAwsjson11_deserializeOpDocumentStartImportTaskOutput(&output, shape) 2685 if err != nil { 2686 var snapshot bytes.Buffer 2687 io.Copy(&snapshot, ringBuffer) 2688 err = &smithy.DeserializationError{ 2689 Err: fmt.Errorf("failed to decode response body, %w", err), 2690 Snapshot: snapshot.Bytes(), 2691 } 2692 return out, metadata, err 2693 } 2694 2695 return out, metadata, err 2696} 2697 2698func awsAwsjson11_deserializeOpErrorStartImportTask(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2699 var errorBuffer bytes.Buffer 2700 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2701 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2702 } 2703 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2704 2705 errorCode := "UnknownError" 2706 errorMessage := errorCode 2707 2708 code := response.Header.Get("X-Amzn-ErrorType") 2709 if len(code) != 0 { 2710 errorCode = restjson.SanitizeErrorCode(code) 2711 } 2712 2713 var buff [1024]byte 2714 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2715 2716 body := io.TeeReader(errorBody, ringBuffer) 2717 decoder := json.NewDecoder(body) 2718 decoder.UseNumber() 2719 code, message, err := restjson.GetErrorInfo(decoder) 2720 if err != nil { 2721 var snapshot bytes.Buffer 2722 io.Copy(&snapshot, ringBuffer) 2723 err = &smithy.DeserializationError{ 2724 Err: fmt.Errorf("failed to decode response body, %w", err), 2725 Snapshot: snapshot.Bytes(), 2726 } 2727 return err 2728 } 2729 2730 errorBody.Seek(0, io.SeekStart) 2731 if len(code) != 0 { 2732 errorCode = restjson.SanitizeErrorCode(code) 2733 } 2734 if len(message) != 0 { 2735 errorMessage = message 2736 } 2737 2738 switch { 2739 case strings.EqualFold("AuthorizationErrorException", errorCode): 2740 return awsAwsjson11_deserializeErrorAuthorizationErrorException(response, errorBody) 2741 2742 case strings.EqualFold("HomeRegionNotSetException", errorCode): 2743 return awsAwsjson11_deserializeErrorHomeRegionNotSetException(response, errorBody) 2744 2745 case strings.EqualFold("InvalidParameterException", errorCode): 2746 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 2747 2748 case strings.EqualFold("InvalidParameterValueException", errorCode): 2749 return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody) 2750 2751 case strings.EqualFold("ResourceInUseException", errorCode): 2752 return awsAwsjson11_deserializeErrorResourceInUseException(response, errorBody) 2753 2754 case strings.EqualFold("ServerInternalErrorException", errorCode): 2755 return awsAwsjson11_deserializeErrorServerInternalErrorException(response, errorBody) 2756 2757 default: 2758 genericError := &smithy.GenericAPIError{ 2759 Code: errorCode, 2760 Message: errorMessage, 2761 } 2762 return genericError 2763 2764 } 2765} 2766 2767type awsAwsjson11_deserializeOpStopContinuousExport struct { 2768} 2769 2770func (*awsAwsjson11_deserializeOpStopContinuousExport) ID() string { 2771 return "OperationDeserializer" 2772} 2773 2774func (m *awsAwsjson11_deserializeOpStopContinuousExport) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2775 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2776) { 2777 out, metadata, err = next.HandleDeserialize(ctx, in) 2778 if err != nil { 2779 return out, metadata, err 2780 } 2781 2782 response, ok := out.RawResponse.(*smithyhttp.Response) 2783 if !ok { 2784 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2785 } 2786 2787 if response.StatusCode < 200 || response.StatusCode >= 300 { 2788 return out, metadata, awsAwsjson11_deserializeOpErrorStopContinuousExport(response, &metadata) 2789 } 2790 output := &StopContinuousExportOutput{} 2791 out.Result = output 2792 2793 var buff [1024]byte 2794 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2795 2796 body := io.TeeReader(response.Body, ringBuffer) 2797 decoder := json.NewDecoder(body) 2798 decoder.UseNumber() 2799 var shape interface{} 2800 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2801 var snapshot bytes.Buffer 2802 io.Copy(&snapshot, ringBuffer) 2803 err = &smithy.DeserializationError{ 2804 Err: fmt.Errorf("failed to decode response body, %w", err), 2805 Snapshot: snapshot.Bytes(), 2806 } 2807 return out, metadata, err 2808 } 2809 2810 err = awsAwsjson11_deserializeOpDocumentStopContinuousExportOutput(&output, shape) 2811 if err != nil { 2812 var snapshot bytes.Buffer 2813 io.Copy(&snapshot, ringBuffer) 2814 err = &smithy.DeserializationError{ 2815 Err: fmt.Errorf("failed to decode response body, %w", err), 2816 Snapshot: snapshot.Bytes(), 2817 } 2818 return out, metadata, err 2819 } 2820 2821 return out, metadata, err 2822} 2823 2824func awsAwsjson11_deserializeOpErrorStopContinuousExport(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2825 var errorBuffer bytes.Buffer 2826 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2827 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2828 } 2829 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2830 2831 errorCode := "UnknownError" 2832 errorMessage := errorCode 2833 2834 code := response.Header.Get("X-Amzn-ErrorType") 2835 if len(code) != 0 { 2836 errorCode = restjson.SanitizeErrorCode(code) 2837 } 2838 2839 var buff [1024]byte 2840 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2841 2842 body := io.TeeReader(errorBody, ringBuffer) 2843 decoder := json.NewDecoder(body) 2844 decoder.UseNumber() 2845 code, message, err := restjson.GetErrorInfo(decoder) 2846 if err != nil { 2847 var snapshot bytes.Buffer 2848 io.Copy(&snapshot, ringBuffer) 2849 err = &smithy.DeserializationError{ 2850 Err: fmt.Errorf("failed to decode response body, %w", err), 2851 Snapshot: snapshot.Bytes(), 2852 } 2853 return err 2854 } 2855 2856 errorBody.Seek(0, io.SeekStart) 2857 if len(code) != 0 { 2858 errorCode = restjson.SanitizeErrorCode(code) 2859 } 2860 if len(message) != 0 { 2861 errorMessage = message 2862 } 2863 2864 switch { 2865 case strings.EqualFold("AuthorizationErrorException", errorCode): 2866 return awsAwsjson11_deserializeErrorAuthorizationErrorException(response, errorBody) 2867 2868 case strings.EqualFold("HomeRegionNotSetException", errorCode): 2869 return awsAwsjson11_deserializeErrorHomeRegionNotSetException(response, errorBody) 2870 2871 case strings.EqualFold("InvalidParameterException", errorCode): 2872 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 2873 2874 case strings.EqualFold("InvalidParameterValueException", errorCode): 2875 return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody) 2876 2877 case strings.EqualFold("OperationNotPermittedException", errorCode): 2878 return awsAwsjson11_deserializeErrorOperationNotPermittedException(response, errorBody) 2879 2880 case strings.EqualFold("ResourceInUseException", errorCode): 2881 return awsAwsjson11_deserializeErrorResourceInUseException(response, errorBody) 2882 2883 case strings.EqualFold("ResourceNotFoundException", errorCode): 2884 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 2885 2886 case strings.EqualFold("ServerInternalErrorException", errorCode): 2887 return awsAwsjson11_deserializeErrorServerInternalErrorException(response, errorBody) 2888 2889 default: 2890 genericError := &smithy.GenericAPIError{ 2891 Code: errorCode, 2892 Message: errorMessage, 2893 } 2894 return genericError 2895 2896 } 2897} 2898 2899type awsAwsjson11_deserializeOpStopDataCollectionByAgentIds struct { 2900} 2901 2902func (*awsAwsjson11_deserializeOpStopDataCollectionByAgentIds) ID() string { 2903 return "OperationDeserializer" 2904} 2905 2906func (m *awsAwsjson11_deserializeOpStopDataCollectionByAgentIds) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2907 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2908) { 2909 out, metadata, err = next.HandleDeserialize(ctx, in) 2910 if err != nil { 2911 return out, metadata, err 2912 } 2913 2914 response, ok := out.RawResponse.(*smithyhttp.Response) 2915 if !ok { 2916 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2917 } 2918 2919 if response.StatusCode < 200 || response.StatusCode >= 300 { 2920 return out, metadata, awsAwsjson11_deserializeOpErrorStopDataCollectionByAgentIds(response, &metadata) 2921 } 2922 output := &StopDataCollectionByAgentIdsOutput{} 2923 out.Result = output 2924 2925 var buff [1024]byte 2926 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2927 2928 body := io.TeeReader(response.Body, ringBuffer) 2929 decoder := json.NewDecoder(body) 2930 decoder.UseNumber() 2931 var shape interface{} 2932 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2933 var snapshot bytes.Buffer 2934 io.Copy(&snapshot, ringBuffer) 2935 err = &smithy.DeserializationError{ 2936 Err: fmt.Errorf("failed to decode response body, %w", err), 2937 Snapshot: snapshot.Bytes(), 2938 } 2939 return out, metadata, err 2940 } 2941 2942 err = awsAwsjson11_deserializeOpDocumentStopDataCollectionByAgentIdsOutput(&output, shape) 2943 if err != nil { 2944 var snapshot bytes.Buffer 2945 io.Copy(&snapshot, ringBuffer) 2946 err = &smithy.DeserializationError{ 2947 Err: fmt.Errorf("failed to decode response body, %w", err), 2948 Snapshot: snapshot.Bytes(), 2949 } 2950 return out, metadata, err 2951 } 2952 2953 return out, metadata, err 2954} 2955 2956func awsAwsjson11_deserializeOpErrorStopDataCollectionByAgentIds(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2957 var errorBuffer bytes.Buffer 2958 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2959 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2960 } 2961 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2962 2963 errorCode := "UnknownError" 2964 errorMessage := errorCode 2965 2966 code := response.Header.Get("X-Amzn-ErrorType") 2967 if len(code) != 0 { 2968 errorCode = restjson.SanitizeErrorCode(code) 2969 } 2970 2971 var buff [1024]byte 2972 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2973 2974 body := io.TeeReader(errorBody, ringBuffer) 2975 decoder := json.NewDecoder(body) 2976 decoder.UseNumber() 2977 code, message, err := restjson.GetErrorInfo(decoder) 2978 if err != nil { 2979 var snapshot bytes.Buffer 2980 io.Copy(&snapshot, ringBuffer) 2981 err = &smithy.DeserializationError{ 2982 Err: fmt.Errorf("failed to decode response body, %w", err), 2983 Snapshot: snapshot.Bytes(), 2984 } 2985 return err 2986 } 2987 2988 errorBody.Seek(0, io.SeekStart) 2989 if len(code) != 0 { 2990 errorCode = restjson.SanitizeErrorCode(code) 2991 } 2992 if len(message) != 0 { 2993 errorMessage = message 2994 } 2995 2996 switch { 2997 case strings.EqualFold("AuthorizationErrorException", errorCode): 2998 return awsAwsjson11_deserializeErrorAuthorizationErrorException(response, errorBody) 2999 3000 case strings.EqualFold("HomeRegionNotSetException", errorCode): 3001 return awsAwsjson11_deserializeErrorHomeRegionNotSetException(response, errorBody) 3002 3003 case strings.EqualFold("InvalidParameterException", errorCode): 3004 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 3005 3006 case strings.EqualFold("InvalidParameterValueException", errorCode): 3007 return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody) 3008 3009 case strings.EqualFold("ServerInternalErrorException", errorCode): 3010 return awsAwsjson11_deserializeErrorServerInternalErrorException(response, errorBody) 3011 3012 default: 3013 genericError := &smithy.GenericAPIError{ 3014 Code: errorCode, 3015 Message: errorMessage, 3016 } 3017 return genericError 3018 3019 } 3020} 3021 3022type awsAwsjson11_deserializeOpUpdateApplication struct { 3023} 3024 3025func (*awsAwsjson11_deserializeOpUpdateApplication) ID() string { 3026 return "OperationDeserializer" 3027} 3028 3029func (m *awsAwsjson11_deserializeOpUpdateApplication) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3030 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3031) { 3032 out, metadata, err = next.HandleDeserialize(ctx, in) 3033 if err != nil { 3034 return out, metadata, err 3035 } 3036 3037 response, ok := out.RawResponse.(*smithyhttp.Response) 3038 if !ok { 3039 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3040 } 3041 3042 if response.StatusCode < 200 || response.StatusCode >= 300 { 3043 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateApplication(response, &metadata) 3044 } 3045 output := &UpdateApplicationOutput{} 3046 out.Result = output 3047 3048 var buff [1024]byte 3049 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3050 3051 body := io.TeeReader(response.Body, ringBuffer) 3052 decoder := json.NewDecoder(body) 3053 decoder.UseNumber() 3054 var shape interface{} 3055 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3056 var snapshot bytes.Buffer 3057 io.Copy(&snapshot, ringBuffer) 3058 err = &smithy.DeserializationError{ 3059 Err: fmt.Errorf("failed to decode response body, %w", err), 3060 Snapshot: snapshot.Bytes(), 3061 } 3062 return out, metadata, err 3063 } 3064 3065 err = awsAwsjson11_deserializeOpDocumentUpdateApplicationOutput(&output, shape) 3066 if err != nil { 3067 var snapshot bytes.Buffer 3068 io.Copy(&snapshot, ringBuffer) 3069 err = &smithy.DeserializationError{ 3070 Err: fmt.Errorf("failed to decode response body, %w", err), 3071 Snapshot: snapshot.Bytes(), 3072 } 3073 return out, metadata, err 3074 } 3075 3076 return out, metadata, err 3077} 3078 3079func awsAwsjson11_deserializeOpErrorUpdateApplication(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3080 var errorBuffer bytes.Buffer 3081 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3082 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3083 } 3084 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3085 3086 errorCode := "UnknownError" 3087 errorMessage := errorCode 3088 3089 code := response.Header.Get("X-Amzn-ErrorType") 3090 if len(code) != 0 { 3091 errorCode = restjson.SanitizeErrorCode(code) 3092 } 3093 3094 var buff [1024]byte 3095 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3096 3097 body := io.TeeReader(errorBody, ringBuffer) 3098 decoder := json.NewDecoder(body) 3099 decoder.UseNumber() 3100 code, message, err := restjson.GetErrorInfo(decoder) 3101 if err != nil { 3102 var snapshot bytes.Buffer 3103 io.Copy(&snapshot, ringBuffer) 3104 err = &smithy.DeserializationError{ 3105 Err: fmt.Errorf("failed to decode response body, %w", err), 3106 Snapshot: snapshot.Bytes(), 3107 } 3108 return err 3109 } 3110 3111 errorBody.Seek(0, io.SeekStart) 3112 if len(code) != 0 { 3113 errorCode = restjson.SanitizeErrorCode(code) 3114 } 3115 if len(message) != 0 { 3116 errorMessage = message 3117 } 3118 3119 switch { 3120 case strings.EqualFold("AuthorizationErrorException", errorCode): 3121 return awsAwsjson11_deserializeErrorAuthorizationErrorException(response, errorBody) 3122 3123 case strings.EqualFold("HomeRegionNotSetException", errorCode): 3124 return awsAwsjson11_deserializeErrorHomeRegionNotSetException(response, errorBody) 3125 3126 case strings.EqualFold("InvalidParameterException", errorCode): 3127 return awsAwsjson11_deserializeErrorInvalidParameterException(response, errorBody) 3128 3129 case strings.EqualFold("InvalidParameterValueException", errorCode): 3130 return awsAwsjson11_deserializeErrorInvalidParameterValueException(response, errorBody) 3131 3132 case strings.EqualFold("ServerInternalErrorException", errorCode): 3133 return awsAwsjson11_deserializeErrorServerInternalErrorException(response, errorBody) 3134 3135 default: 3136 genericError := &smithy.GenericAPIError{ 3137 Code: errorCode, 3138 Message: errorMessage, 3139 } 3140 return genericError 3141 3142 } 3143} 3144 3145func awsAwsjson11_deserializeErrorAuthorizationErrorException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 3146 var buff [1024]byte 3147 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3148 3149 body := io.TeeReader(errorBody, ringBuffer) 3150 decoder := json.NewDecoder(body) 3151 decoder.UseNumber() 3152 var shape interface{} 3153 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3154 var snapshot bytes.Buffer 3155 io.Copy(&snapshot, ringBuffer) 3156 err = &smithy.DeserializationError{ 3157 Err: fmt.Errorf("failed to decode response body, %w", err), 3158 Snapshot: snapshot.Bytes(), 3159 } 3160 return err 3161 } 3162 3163 output := &types.AuthorizationErrorException{} 3164 err := awsAwsjson11_deserializeDocumentAuthorizationErrorException(&output, shape) 3165 3166 if err != nil { 3167 var snapshot bytes.Buffer 3168 io.Copy(&snapshot, ringBuffer) 3169 err = &smithy.DeserializationError{ 3170 Err: fmt.Errorf("failed to decode response body, %w", err), 3171 Snapshot: snapshot.Bytes(), 3172 } 3173 return err 3174 } 3175 3176 errorBody.Seek(0, io.SeekStart) 3177 return output 3178} 3179 3180func awsAwsjson11_deserializeErrorConflictErrorException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 3181 var buff [1024]byte 3182 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3183 3184 body := io.TeeReader(errorBody, ringBuffer) 3185 decoder := json.NewDecoder(body) 3186 decoder.UseNumber() 3187 var shape interface{} 3188 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3189 var snapshot bytes.Buffer 3190 io.Copy(&snapshot, ringBuffer) 3191 err = &smithy.DeserializationError{ 3192 Err: fmt.Errorf("failed to decode response body, %w", err), 3193 Snapshot: snapshot.Bytes(), 3194 } 3195 return err 3196 } 3197 3198 output := &types.ConflictErrorException{} 3199 err := awsAwsjson11_deserializeDocumentConflictErrorException(&output, shape) 3200 3201 if err != nil { 3202 var snapshot bytes.Buffer 3203 io.Copy(&snapshot, ringBuffer) 3204 err = &smithy.DeserializationError{ 3205 Err: fmt.Errorf("failed to decode response body, %w", err), 3206 Snapshot: snapshot.Bytes(), 3207 } 3208 return err 3209 } 3210 3211 errorBody.Seek(0, io.SeekStart) 3212 return output 3213} 3214 3215func awsAwsjson11_deserializeErrorHomeRegionNotSetException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 3216 var buff [1024]byte 3217 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3218 3219 body := io.TeeReader(errorBody, ringBuffer) 3220 decoder := json.NewDecoder(body) 3221 decoder.UseNumber() 3222 var shape interface{} 3223 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3224 var snapshot bytes.Buffer 3225 io.Copy(&snapshot, ringBuffer) 3226 err = &smithy.DeserializationError{ 3227 Err: fmt.Errorf("failed to decode response body, %w", err), 3228 Snapshot: snapshot.Bytes(), 3229 } 3230 return err 3231 } 3232 3233 output := &types.HomeRegionNotSetException{} 3234 err := awsAwsjson11_deserializeDocumentHomeRegionNotSetException(&output, shape) 3235 3236 if err != nil { 3237 var snapshot bytes.Buffer 3238 io.Copy(&snapshot, ringBuffer) 3239 err = &smithy.DeserializationError{ 3240 Err: fmt.Errorf("failed to decode response body, %w", err), 3241 Snapshot: snapshot.Bytes(), 3242 } 3243 return err 3244 } 3245 3246 errorBody.Seek(0, io.SeekStart) 3247 return output 3248} 3249 3250func awsAwsjson11_deserializeErrorInvalidParameterException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 3251 var buff [1024]byte 3252 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3253 3254 body := io.TeeReader(errorBody, ringBuffer) 3255 decoder := json.NewDecoder(body) 3256 decoder.UseNumber() 3257 var shape interface{} 3258 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3259 var snapshot bytes.Buffer 3260 io.Copy(&snapshot, ringBuffer) 3261 err = &smithy.DeserializationError{ 3262 Err: fmt.Errorf("failed to decode response body, %w", err), 3263 Snapshot: snapshot.Bytes(), 3264 } 3265 return err 3266 } 3267 3268 output := &types.InvalidParameterException{} 3269 err := awsAwsjson11_deserializeDocumentInvalidParameterException(&output, shape) 3270 3271 if err != nil { 3272 var snapshot bytes.Buffer 3273 io.Copy(&snapshot, ringBuffer) 3274 err = &smithy.DeserializationError{ 3275 Err: fmt.Errorf("failed to decode response body, %w", err), 3276 Snapshot: snapshot.Bytes(), 3277 } 3278 return err 3279 } 3280 3281 errorBody.Seek(0, io.SeekStart) 3282 return output 3283} 3284 3285func awsAwsjson11_deserializeErrorInvalidParameterValueException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 3286 var buff [1024]byte 3287 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3288 3289 body := io.TeeReader(errorBody, ringBuffer) 3290 decoder := json.NewDecoder(body) 3291 decoder.UseNumber() 3292 var shape interface{} 3293 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3294 var snapshot bytes.Buffer 3295 io.Copy(&snapshot, ringBuffer) 3296 err = &smithy.DeserializationError{ 3297 Err: fmt.Errorf("failed to decode response body, %w", err), 3298 Snapshot: snapshot.Bytes(), 3299 } 3300 return err 3301 } 3302 3303 output := &types.InvalidParameterValueException{} 3304 err := awsAwsjson11_deserializeDocumentInvalidParameterValueException(&output, shape) 3305 3306 if err != nil { 3307 var snapshot bytes.Buffer 3308 io.Copy(&snapshot, ringBuffer) 3309 err = &smithy.DeserializationError{ 3310 Err: fmt.Errorf("failed to decode response body, %w", err), 3311 Snapshot: snapshot.Bytes(), 3312 } 3313 return err 3314 } 3315 3316 errorBody.Seek(0, io.SeekStart) 3317 return output 3318} 3319 3320func awsAwsjson11_deserializeErrorOperationNotPermittedException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 3321 var buff [1024]byte 3322 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3323 3324 body := io.TeeReader(errorBody, ringBuffer) 3325 decoder := json.NewDecoder(body) 3326 decoder.UseNumber() 3327 var shape interface{} 3328 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3329 var snapshot bytes.Buffer 3330 io.Copy(&snapshot, ringBuffer) 3331 err = &smithy.DeserializationError{ 3332 Err: fmt.Errorf("failed to decode response body, %w", err), 3333 Snapshot: snapshot.Bytes(), 3334 } 3335 return err 3336 } 3337 3338 output := &types.OperationNotPermittedException{} 3339 err := awsAwsjson11_deserializeDocumentOperationNotPermittedException(&output, shape) 3340 3341 if err != nil { 3342 var snapshot bytes.Buffer 3343 io.Copy(&snapshot, ringBuffer) 3344 err = &smithy.DeserializationError{ 3345 Err: fmt.Errorf("failed to decode response body, %w", err), 3346 Snapshot: snapshot.Bytes(), 3347 } 3348 return err 3349 } 3350 3351 errorBody.Seek(0, io.SeekStart) 3352 return output 3353} 3354 3355func awsAwsjson11_deserializeErrorResourceInUseException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 3356 var buff [1024]byte 3357 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3358 3359 body := io.TeeReader(errorBody, ringBuffer) 3360 decoder := json.NewDecoder(body) 3361 decoder.UseNumber() 3362 var shape interface{} 3363 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3364 var snapshot bytes.Buffer 3365 io.Copy(&snapshot, ringBuffer) 3366 err = &smithy.DeserializationError{ 3367 Err: fmt.Errorf("failed to decode response body, %w", err), 3368 Snapshot: snapshot.Bytes(), 3369 } 3370 return err 3371 } 3372 3373 output := &types.ResourceInUseException{} 3374 err := awsAwsjson11_deserializeDocumentResourceInUseException(&output, shape) 3375 3376 if err != nil { 3377 var snapshot bytes.Buffer 3378 io.Copy(&snapshot, ringBuffer) 3379 err = &smithy.DeserializationError{ 3380 Err: fmt.Errorf("failed to decode response body, %w", err), 3381 Snapshot: snapshot.Bytes(), 3382 } 3383 return err 3384 } 3385 3386 errorBody.Seek(0, io.SeekStart) 3387 return output 3388} 3389 3390func awsAwsjson11_deserializeErrorResourceNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 3391 var buff [1024]byte 3392 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3393 3394 body := io.TeeReader(errorBody, ringBuffer) 3395 decoder := json.NewDecoder(body) 3396 decoder.UseNumber() 3397 var shape interface{} 3398 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3399 var snapshot bytes.Buffer 3400 io.Copy(&snapshot, ringBuffer) 3401 err = &smithy.DeserializationError{ 3402 Err: fmt.Errorf("failed to decode response body, %w", err), 3403 Snapshot: snapshot.Bytes(), 3404 } 3405 return err 3406 } 3407 3408 output := &types.ResourceNotFoundException{} 3409 err := awsAwsjson11_deserializeDocumentResourceNotFoundException(&output, shape) 3410 3411 if err != nil { 3412 var snapshot bytes.Buffer 3413 io.Copy(&snapshot, ringBuffer) 3414 err = &smithy.DeserializationError{ 3415 Err: fmt.Errorf("failed to decode response body, %w", err), 3416 Snapshot: snapshot.Bytes(), 3417 } 3418 return err 3419 } 3420 3421 errorBody.Seek(0, io.SeekStart) 3422 return output 3423} 3424 3425func awsAwsjson11_deserializeErrorServerInternalErrorException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 3426 var buff [1024]byte 3427 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3428 3429 body := io.TeeReader(errorBody, ringBuffer) 3430 decoder := json.NewDecoder(body) 3431 decoder.UseNumber() 3432 var shape interface{} 3433 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3434 var snapshot bytes.Buffer 3435 io.Copy(&snapshot, ringBuffer) 3436 err = &smithy.DeserializationError{ 3437 Err: fmt.Errorf("failed to decode response body, %w", err), 3438 Snapshot: snapshot.Bytes(), 3439 } 3440 return err 3441 } 3442 3443 output := &types.ServerInternalErrorException{} 3444 err := awsAwsjson11_deserializeDocumentServerInternalErrorException(&output, shape) 3445 3446 if err != nil { 3447 var snapshot bytes.Buffer 3448 io.Copy(&snapshot, ringBuffer) 3449 err = &smithy.DeserializationError{ 3450 Err: fmt.Errorf("failed to decode response body, %w", err), 3451 Snapshot: snapshot.Bytes(), 3452 } 3453 return err 3454 } 3455 3456 errorBody.Seek(0, io.SeekStart) 3457 return output 3458} 3459 3460func awsAwsjson11_deserializeDocumentAgentConfigurationStatus(v **types.AgentConfigurationStatus, value interface{}) error { 3461 if v == nil { 3462 return fmt.Errorf("unexpected nil of type %T", v) 3463 } 3464 if value == nil { 3465 return nil 3466 } 3467 3468 shape, ok := value.(map[string]interface{}) 3469 if !ok { 3470 return fmt.Errorf("unexpected JSON type %v", value) 3471 } 3472 3473 var sv *types.AgentConfigurationStatus 3474 if *v == nil { 3475 sv = &types.AgentConfigurationStatus{} 3476 } else { 3477 sv = *v 3478 } 3479 3480 for key, value := range shape { 3481 switch key { 3482 case "agentId": 3483 if value != nil { 3484 jtv, ok := value.(string) 3485 if !ok { 3486 return fmt.Errorf("expected String to be of type string, got %T instead", value) 3487 } 3488 sv.AgentId = ptr.String(jtv) 3489 } 3490 3491 case "description": 3492 if value != nil { 3493 jtv, ok := value.(string) 3494 if !ok { 3495 return fmt.Errorf("expected String to be of type string, got %T instead", value) 3496 } 3497 sv.Description = ptr.String(jtv) 3498 } 3499 3500 case "operationSucceeded": 3501 if value != nil { 3502 jtv, ok := value.(bool) 3503 if !ok { 3504 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 3505 } 3506 sv.OperationSucceeded = jtv 3507 } 3508 3509 default: 3510 _, _ = key, value 3511 3512 } 3513 } 3514 *v = sv 3515 return nil 3516} 3517 3518func awsAwsjson11_deserializeDocumentAgentConfigurationStatusList(v *[]types.AgentConfigurationStatus, value interface{}) error { 3519 if v == nil { 3520 return fmt.Errorf("unexpected nil of type %T", v) 3521 } 3522 if value == nil { 3523 return nil 3524 } 3525 3526 shape, ok := value.([]interface{}) 3527 if !ok { 3528 return fmt.Errorf("unexpected JSON type %v", value) 3529 } 3530 3531 var cv []types.AgentConfigurationStatus 3532 if *v == nil { 3533 cv = []types.AgentConfigurationStatus{} 3534 } else { 3535 cv = *v 3536 } 3537 3538 for _, value := range shape { 3539 var col types.AgentConfigurationStatus 3540 destAddr := &col 3541 if err := awsAwsjson11_deserializeDocumentAgentConfigurationStatus(&destAddr, value); err != nil { 3542 return err 3543 } 3544 col = *destAddr 3545 cv = append(cv, col) 3546 3547 } 3548 *v = cv 3549 return nil 3550} 3551 3552func awsAwsjson11_deserializeDocumentAgentInfo(v **types.AgentInfo, value interface{}) error { 3553 if v == nil { 3554 return fmt.Errorf("unexpected nil of type %T", v) 3555 } 3556 if value == nil { 3557 return nil 3558 } 3559 3560 shape, ok := value.(map[string]interface{}) 3561 if !ok { 3562 return fmt.Errorf("unexpected JSON type %v", value) 3563 } 3564 3565 var sv *types.AgentInfo 3566 if *v == nil { 3567 sv = &types.AgentInfo{} 3568 } else { 3569 sv = *v 3570 } 3571 3572 for key, value := range shape { 3573 switch key { 3574 case "agentId": 3575 if value != nil { 3576 jtv, ok := value.(string) 3577 if !ok { 3578 return fmt.Errorf("expected AgentId to be of type string, got %T instead", value) 3579 } 3580 sv.AgentId = ptr.String(jtv) 3581 } 3582 3583 case "agentNetworkInfoList": 3584 if err := awsAwsjson11_deserializeDocumentAgentNetworkInfoList(&sv.AgentNetworkInfoList, value); err != nil { 3585 return err 3586 } 3587 3588 case "agentType": 3589 if value != nil { 3590 jtv, ok := value.(string) 3591 if !ok { 3592 return fmt.Errorf("expected String to be of type string, got %T instead", value) 3593 } 3594 sv.AgentType = ptr.String(jtv) 3595 } 3596 3597 case "collectionStatus": 3598 if value != nil { 3599 jtv, ok := value.(string) 3600 if !ok { 3601 return fmt.Errorf("expected String to be of type string, got %T instead", value) 3602 } 3603 sv.CollectionStatus = ptr.String(jtv) 3604 } 3605 3606 case "connectorId": 3607 if value != nil { 3608 jtv, ok := value.(string) 3609 if !ok { 3610 return fmt.Errorf("expected String to be of type string, got %T instead", value) 3611 } 3612 sv.ConnectorId = ptr.String(jtv) 3613 } 3614 3615 case "health": 3616 if value != nil { 3617 jtv, ok := value.(string) 3618 if !ok { 3619 return fmt.Errorf("expected AgentStatus to be of type string, got %T instead", value) 3620 } 3621 sv.Health = types.AgentStatus(jtv) 3622 } 3623 3624 case "hostName": 3625 if value != nil { 3626 jtv, ok := value.(string) 3627 if !ok { 3628 return fmt.Errorf("expected String to be of type string, got %T instead", value) 3629 } 3630 sv.HostName = ptr.String(jtv) 3631 } 3632 3633 case "lastHealthPingTime": 3634 if value != nil { 3635 jtv, ok := value.(string) 3636 if !ok { 3637 return fmt.Errorf("expected String to be of type string, got %T instead", value) 3638 } 3639 sv.LastHealthPingTime = ptr.String(jtv) 3640 } 3641 3642 case "registeredTime": 3643 if value != nil { 3644 jtv, ok := value.(string) 3645 if !ok { 3646 return fmt.Errorf("expected String to be of type string, got %T instead", value) 3647 } 3648 sv.RegisteredTime = ptr.String(jtv) 3649 } 3650 3651 case "version": 3652 if value != nil { 3653 jtv, ok := value.(string) 3654 if !ok { 3655 return fmt.Errorf("expected String to be of type string, got %T instead", value) 3656 } 3657 sv.Version = ptr.String(jtv) 3658 } 3659 3660 default: 3661 _, _ = key, value 3662 3663 } 3664 } 3665 *v = sv 3666 return nil 3667} 3668 3669func awsAwsjson11_deserializeDocumentAgentNetworkInfo(v **types.AgentNetworkInfo, value interface{}) error { 3670 if v == nil { 3671 return fmt.Errorf("unexpected nil of type %T", v) 3672 } 3673 if value == nil { 3674 return nil 3675 } 3676 3677 shape, ok := value.(map[string]interface{}) 3678 if !ok { 3679 return fmt.Errorf("unexpected JSON type %v", value) 3680 } 3681 3682 var sv *types.AgentNetworkInfo 3683 if *v == nil { 3684 sv = &types.AgentNetworkInfo{} 3685 } else { 3686 sv = *v 3687 } 3688 3689 for key, value := range shape { 3690 switch key { 3691 case "ipAddress": 3692 if value != nil { 3693 jtv, ok := value.(string) 3694 if !ok { 3695 return fmt.Errorf("expected String to be of type string, got %T instead", value) 3696 } 3697 sv.IpAddress = ptr.String(jtv) 3698 } 3699 3700 case "macAddress": 3701 if value != nil { 3702 jtv, ok := value.(string) 3703 if !ok { 3704 return fmt.Errorf("expected String to be of type string, got %T instead", value) 3705 } 3706 sv.MacAddress = ptr.String(jtv) 3707 } 3708 3709 default: 3710 _, _ = key, value 3711 3712 } 3713 } 3714 *v = sv 3715 return nil 3716} 3717 3718func awsAwsjson11_deserializeDocumentAgentNetworkInfoList(v *[]types.AgentNetworkInfo, value interface{}) error { 3719 if v == nil { 3720 return fmt.Errorf("unexpected nil of type %T", v) 3721 } 3722 if value == nil { 3723 return nil 3724 } 3725 3726 shape, ok := value.([]interface{}) 3727 if !ok { 3728 return fmt.Errorf("unexpected JSON type %v", value) 3729 } 3730 3731 var cv []types.AgentNetworkInfo 3732 if *v == nil { 3733 cv = []types.AgentNetworkInfo{} 3734 } else { 3735 cv = *v 3736 } 3737 3738 for _, value := range shape { 3739 var col types.AgentNetworkInfo 3740 destAddr := &col 3741 if err := awsAwsjson11_deserializeDocumentAgentNetworkInfo(&destAddr, value); err != nil { 3742 return err 3743 } 3744 col = *destAddr 3745 cv = append(cv, col) 3746 3747 } 3748 *v = cv 3749 return nil 3750} 3751 3752func awsAwsjson11_deserializeDocumentAgentsInfo(v *[]types.AgentInfo, value interface{}) error { 3753 if v == nil { 3754 return fmt.Errorf("unexpected nil of type %T", v) 3755 } 3756 if value == nil { 3757 return nil 3758 } 3759 3760 shape, ok := value.([]interface{}) 3761 if !ok { 3762 return fmt.Errorf("unexpected JSON type %v", value) 3763 } 3764 3765 var cv []types.AgentInfo 3766 if *v == nil { 3767 cv = []types.AgentInfo{} 3768 } else { 3769 cv = *v 3770 } 3771 3772 for _, value := range shape { 3773 var col types.AgentInfo 3774 destAddr := &col 3775 if err := awsAwsjson11_deserializeDocumentAgentInfo(&destAddr, value); err != nil { 3776 return err 3777 } 3778 col = *destAddr 3779 cv = append(cv, col) 3780 3781 } 3782 *v = cv 3783 return nil 3784} 3785 3786func awsAwsjson11_deserializeDocumentAuthorizationErrorException(v **types.AuthorizationErrorException, value interface{}) error { 3787 if v == nil { 3788 return fmt.Errorf("unexpected nil of type %T", v) 3789 } 3790 if value == nil { 3791 return nil 3792 } 3793 3794 shape, ok := value.(map[string]interface{}) 3795 if !ok { 3796 return fmt.Errorf("unexpected JSON type %v", value) 3797 } 3798 3799 var sv *types.AuthorizationErrorException 3800 if *v == nil { 3801 sv = &types.AuthorizationErrorException{} 3802 } else { 3803 sv = *v 3804 } 3805 3806 for key, value := range shape { 3807 switch key { 3808 case "message": 3809 if value != nil { 3810 jtv, ok := value.(string) 3811 if !ok { 3812 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 3813 } 3814 sv.Message = ptr.String(jtv) 3815 } 3816 3817 default: 3818 _, _ = key, value 3819 3820 } 3821 } 3822 *v = sv 3823 return nil 3824} 3825 3826func awsAwsjson11_deserializeDocumentBatchDeleteImportDataError(v **types.BatchDeleteImportDataError, value interface{}) error { 3827 if v == nil { 3828 return fmt.Errorf("unexpected nil of type %T", v) 3829 } 3830 if value == nil { 3831 return nil 3832 } 3833 3834 shape, ok := value.(map[string]interface{}) 3835 if !ok { 3836 return fmt.Errorf("unexpected JSON type %v", value) 3837 } 3838 3839 var sv *types.BatchDeleteImportDataError 3840 if *v == nil { 3841 sv = &types.BatchDeleteImportDataError{} 3842 } else { 3843 sv = *v 3844 } 3845 3846 for key, value := range shape { 3847 switch key { 3848 case "errorCode": 3849 if value != nil { 3850 jtv, ok := value.(string) 3851 if !ok { 3852 return fmt.Errorf("expected BatchDeleteImportDataErrorCode to be of type string, got %T instead", value) 3853 } 3854 sv.ErrorCode = types.BatchDeleteImportDataErrorCode(jtv) 3855 } 3856 3857 case "errorDescription": 3858 if value != nil { 3859 jtv, ok := value.(string) 3860 if !ok { 3861 return fmt.Errorf("expected BatchDeleteImportDataErrorDescription to be of type string, got %T instead", value) 3862 } 3863 sv.ErrorDescription = ptr.String(jtv) 3864 } 3865 3866 case "importTaskId": 3867 if value != nil { 3868 jtv, ok := value.(string) 3869 if !ok { 3870 return fmt.Errorf("expected ImportTaskIdentifier to be of type string, got %T instead", value) 3871 } 3872 sv.ImportTaskId = ptr.String(jtv) 3873 } 3874 3875 default: 3876 _, _ = key, value 3877 3878 } 3879 } 3880 *v = sv 3881 return nil 3882} 3883 3884func awsAwsjson11_deserializeDocumentBatchDeleteImportDataErrorList(v *[]types.BatchDeleteImportDataError, value interface{}) error { 3885 if v == nil { 3886 return fmt.Errorf("unexpected nil of type %T", v) 3887 } 3888 if value == nil { 3889 return nil 3890 } 3891 3892 shape, ok := value.([]interface{}) 3893 if !ok { 3894 return fmt.Errorf("unexpected JSON type %v", value) 3895 } 3896 3897 var cv []types.BatchDeleteImportDataError 3898 if *v == nil { 3899 cv = []types.BatchDeleteImportDataError{} 3900 } else { 3901 cv = *v 3902 } 3903 3904 for _, value := range shape { 3905 var col types.BatchDeleteImportDataError 3906 destAddr := &col 3907 if err := awsAwsjson11_deserializeDocumentBatchDeleteImportDataError(&destAddr, value); err != nil { 3908 return err 3909 } 3910 col = *destAddr 3911 cv = append(cv, col) 3912 3913 } 3914 *v = cv 3915 return nil 3916} 3917 3918func awsAwsjson11_deserializeDocumentConfiguration(v *map[string]string, value interface{}) error { 3919 if v == nil { 3920 return fmt.Errorf("unexpected nil of type %T", v) 3921 } 3922 if value == nil { 3923 return nil 3924 } 3925 3926 shape, ok := value.(map[string]interface{}) 3927 if !ok { 3928 return fmt.Errorf("unexpected JSON type %v", value) 3929 } 3930 3931 var mv map[string]string 3932 if *v == nil { 3933 mv = map[string]string{} 3934 } else { 3935 mv = *v 3936 } 3937 3938 for key, value := range shape { 3939 var parsedVal string 3940 if value != nil { 3941 jtv, ok := value.(string) 3942 if !ok { 3943 return fmt.Errorf("expected String to be of type string, got %T instead", value) 3944 } 3945 parsedVal = jtv 3946 } 3947 mv[key] = parsedVal 3948 3949 } 3950 *v = mv 3951 return nil 3952} 3953 3954func awsAwsjson11_deserializeDocumentConfigurations(v *[]map[string]string, value interface{}) error { 3955 if v == nil { 3956 return fmt.Errorf("unexpected nil of type %T", v) 3957 } 3958 if value == nil { 3959 return nil 3960 } 3961 3962 shape, ok := value.([]interface{}) 3963 if !ok { 3964 return fmt.Errorf("unexpected JSON type %v", value) 3965 } 3966 3967 var cv []map[string]string 3968 if *v == nil { 3969 cv = []map[string]string{} 3970 } else { 3971 cv = *v 3972 } 3973 3974 for _, value := range shape { 3975 var col map[string]string 3976 if err := awsAwsjson11_deserializeDocumentConfiguration(&col, value); err != nil { 3977 return err 3978 } 3979 cv = append(cv, col) 3980 3981 } 3982 *v = cv 3983 return nil 3984} 3985 3986func awsAwsjson11_deserializeDocumentConfigurationTag(v **types.ConfigurationTag, value interface{}) error { 3987 if v == nil { 3988 return fmt.Errorf("unexpected nil of type %T", v) 3989 } 3990 if value == nil { 3991 return nil 3992 } 3993 3994 shape, ok := value.(map[string]interface{}) 3995 if !ok { 3996 return fmt.Errorf("unexpected JSON type %v", value) 3997 } 3998 3999 var sv *types.ConfigurationTag 4000 if *v == nil { 4001 sv = &types.ConfigurationTag{} 4002 } else { 4003 sv = *v 4004 } 4005 4006 for key, value := range shape { 4007 switch key { 4008 case "configurationId": 4009 if value != nil { 4010 jtv, ok := value.(string) 4011 if !ok { 4012 return fmt.Errorf("expected ConfigurationId to be of type string, got %T instead", value) 4013 } 4014 sv.ConfigurationId = ptr.String(jtv) 4015 } 4016 4017 case "configurationType": 4018 if value != nil { 4019 jtv, ok := value.(string) 4020 if !ok { 4021 return fmt.Errorf("expected ConfigurationItemType to be of type string, got %T instead", value) 4022 } 4023 sv.ConfigurationType = types.ConfigurationItemType(jtv) 4024 } 4025 4026 case "key": 4027 if value != nil { 4028 jtv, ok := value.(string) 4029 if !ok { 4030 return fmt.Errorf("expected TagKey to be of type string, got %T instead", value) 4031 } 4032 sv.Key = ptr.String(jtv) 4033 } 4034 4035 case "timeOfCreation": 4036 if value != nil { 4037 jtv, ok := value.(json.Number) 4038 if !ok { 4039 return fmt.Errorf("expected TimeStamp to be json.Number, got %T instead", value) 4040 } 4041 f64, err := jtv.Float64() 4042 if err != nil { 4043 return err 4044 } 4045 sv.TimeOfCreation = ptr.Time(smithytime.ParseEpochSeconds(f64)) 4046 } 4047 4048 case "value": 4049 if value != nil { 4050 jtv, ok := value.(string) 4051 if !ok { 4052 return fmt.Errorf("expected TagValue to be of type string, got %T instead", value) 4053 } 4054 sv.Value = ptr.String(jtv) 4055 } 4056 4057 default: 4058 _, _ = key, value 4059 4060 } 4061 } 4062 *v = sv 4063 return nil 4064} 4065 4066func awsAwsjson11_deserializeDocumentConfigurationTagSet(v *[]types.ConfigurationTag, value interface{}) error { 4067 if v == nil { 4068 return fmt.Errorf("unexpected nil of type %T", v) 4069 } 4070 if value == nil { 4071 return nil 4072 } 4073 4074 shape, ok := value.([]interface{}) 4075 if !ok { 4076 return fmt.Errorf("unexpected JSON type %v", value) 4077 } 4078 4079 var cv []types.ConfigurationTag 4080 if *v == nil { 4081 cv = []types.ConfigurationTag{} 4082 } else { 4083 cv = *v 4084 } 4085 4086 for _, value := range shape { 4087 var col types.ConfigurationTag 4088 destAddr := &col 4089 if err := awsAwsjson11_deserializeDocumentConfigurationTag(&destAddr, value); err != nil { 4090 return err 4091 } 4092 col = *destAddr 4093 cv = append(cv, col) 4094 4095 } 4096 *v = cv 4097 return nil 4098} 4099 4100func awsAwsjson11_deserializeDocumentConflictErrorException(v **types.ConflictErrorException, value interface{}) error { 4101 if v == nil { 4102 return fmt.Errorf("unexpected nil of type %T", v) 4103 } 4104 if value == nil { 4105 return nil 4106 } 4107 4108 shape, ok := value.(map[string]interface{}) 4109 if !ok { 4110 return fmt.Errorf("unexpected JSON type %v", value) 4111 } 4112 4113 var sv *types.ConflictErrorException 4114 if *v == nil { 4115 sv = &types.ConflictErrorException{} 4116 } else { 4117 sv = *v 4118 } 4119 4120 for key, value := range shape { 4121 switch key { 4122 case "message": 4123 if value != nil { 4124 jtv, ok := value.(string) 4125 if !ok { 4126 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 4127 } 4128 sv.Message = ptr.String(jtv) 4129 } 4130 4131 default: 4132 _, _ = key, value 4133 4134 } 4135 } 4136 *v = sv 4137 return nil 4138} 4139 4140func awsAwsjson11_deserializeDocumentContinuousExportDescription(v **types.ContinuousExportDescription, value interface{}) error { 4141 if v == nil { 4142 return fmt.Errorf("unexpected nil of type %T", v) 4143 } 4144 if value == nil { 4145 return nil 4146 } 4147 4148 shape, ok := value.(map[string]interface{}) 4149 if !ok { 4150 return fmt.Errorf("unexpected JSON type %v", value) 4151 } 4152 4153 var sv *types.ContinuousExportDescription 4154 if *v == nil { 4155 sv = &types.ContinuousExportDescription{} 4156 } else { 4157 sv = *v 4158 } 4159 4160 for key, value := range shape { 4161 switch key { 4162 case "dataSource": 4163 if value != nil { 4164 jtv, ok := value.(string) 4165 if !ok { 4166 return fmt.Errorf("expected DataSource to be of type string, got %T instead", value) 4167 } 4168 sv.DataSource = types.DataSource(jtv) 4169 } 4170 4171 case "exportId": 4172 if value != nil { 4173 jtv, ok := value.(string) 4174 if !ok { 4175 return fmt.Errorf("expected ConfigurationsExportId to be of type string, got %T instead", value) 4176 } 4177 sv.ExportId = ptr.String(jtv) 4178 } 4179 4180 case "s3Bucket": 4181 if value != nil { 4182 jtv, ok := value.(string) 4183 if !ok { 4184 return fmt.Errorf("expected S3Bucket to be of type string, got %T instead", value) 4185 } 4186 sv.S3Bucket = ptr.String(jtv) 4187 } 4188 4189 case "schemaStorageConfig": 4190 if err := awsAwsjson11_deserializeDocumentSchemaStorageConfig(&sv.SchemaStorageConfig, value); err != nil { 4191 return err 4192 } 4193 4194 case "startTime": 4195 if value != nil { 4196 jtv, ok := value.(json.Number) 4197 if !ok { 4198 return fmt.Errorf("expected TimeStamp to be json.Number, got %T instead", value) 4199 } 4200 f64, err := jtv.Float64() 4201 if err != nil { 4202 return err 4203 } 4204 sv.StartTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 4205 } 4206 4207 case "status": 4208 if value != nil { 4209 jtv, ok := value.(string) 4210 if !ok { 4211 return fmt.Errorf("expected ContinuousExportStatus to be of type string, got %T instead", value) 4212 } 4213 sv.Status = types.ContinuousExportStatus(jtv) 4214 } 4215 4216 case "statusDetail": 4217 if value != nil { 4218 jtv, ok := value.(string) 4219 if !ok { 4220 return fmt.Errorf("expected StringMax255 to be of type string, got %T instead", value) 4221 } 4222 sv.StatusDetail = ptr.String(jtv) 4223 } 4224 4225 case "stopTime": 4226 if value != nil { 4227 jtv, ok := value.(json.Number) 4228 if !ok { 4229 return fmt.Errorf("expected TimeStamp to be json.Number, got %T instead", value) 4230 } 4231 f64, err := jtv.Float64() 4232 if err != nil { 4233 return err 4234 } 4235 sv.StopTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 4236 } 4237 4238 default: 4239 _, _ = key, value 4240 4241 } 4242 } 4243 *v = sv 4244 return nil 4245} 4246 4247func awsAwsjson11_deserializeDocumentContinuousExportDescriptions(v *[]types.ContinuousExportDescription, value interface{}) error { 4248 if v == nil { 4249 return fmt.Errorf("unexpected nil of type %T", v) 4250 } 4251 if value == nil { 4252 return nil 4253 } 4254 4255 shape, ok := value.([]interface{}) 4256 if !ok { 4257 return fmt.Errorf("unexpected JSON type %v", value) 4258 } 4259 4260 var cv []types.ContinuousExportDescription 4261 if *v == nil { 4262 cv = []types.ContinuousExportDescription{} 4263 } else { 4264 cv = *v 4265 } 4266 4267 for _, value := range shape { 4268 var col types.ContinuousExportDescription 4269 destAddr := &col 4270 if err := awsAwsjson11_deserializeDocumentContinuousExportDescription(&destAddr, value); err != nil { 4271 return err 4272 } 4273 col = *destAddr 4274 cv = append(cv, col) 4275 4276 } 4277 *v = cv 4278 return nil 4279} 4280 4281func awsAwsjson11_deserializeDocumentCustomerAgentInfo(v **types.CustomerAgentInfo, value interface{}) error { 4282 if v == nil { 4283 return fmt.Errorf("unexpected nil of type %T", v) 4284 } 4285 if value == nil { 4286 return nil 4287 } 4288 4289 shape, ok := value.(map[string]interface{}) 4290 if !ok { 4291 return fmt.Errorf("unexpected JSON type %v", value) 4292 } 4293 4294 var sv *types.CustomerAgentInfo 4295 if *v == nil { 4296 sv = &types.CustomerAgentInfo{} 4297 } else { 4298 sv = *v 4299 } 4300 4301 for key, value := range shape { 4302 switch key { 4303 case "activeAgents": 4304 if value != nil { 4305 jtv, ok := value.(json.Number) 4306 if !ok { 4307 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 4308 } 4309 i64, err := jtv.Int64() 4310 if err != nil { 4311 return err 4312 } 4313 sv.ActiveAgents = int32(i64) 4314 } 4315 4316 case "blackListedAgents": 4317 if value != nil { 4318 jtv, ok := value.(json.Number) 4319 if !ok { 4320 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 4321 } 4322 i64, err := jtv.Int64() 4323 if err != nil { 4324 return err 4325 } 4326 sv.BlackListedAgents = int32(i64) 4327 } 4328 4329 case "healthyAgents": 4330 if value != nil { 4331 jtv, ok := value.(json.Number) 4332 if !ok { 4333 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 4334 } 4335 i64, err := jtv.Int64() 4336 if err != nil { 4337 return err 4338 } 4339 sv.HealthyAgents = int32(i64) 4340 } 4341 4342 case "shutdownAgents": 4343 if value != nil { 4344 jtv, ok := value.(json.Number) 4345 if !ok { 4346 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 4347 } 4348 i64, err := jtv.Int64() 4349 if err != nil { 4350 return err 4351 } 4352 sv.ShutdownAgents = int32(i64) 4353 } 4354 4355 case "totalAgents": 4356 if value != nil { 4357 jtv, ok := value.(json.Number) 4358 if !ok { 4359 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 4360 } 4361 i64, err := jtv.Int64() 4362 if err != nil { 4363 return err 4364 } 4365 sv.TotalAgents = int32(i64) 4366 } 4367 4368 case "unhealthyAgents": 4369 if value != nil { 4370 jtv, ok := value.(json.Number) 4371 if !ok { 4372 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 4373 } 4374 i64, err := jtv.Int64() 4375 if err != nil { 4376 return err 4377 } 4378 sv.UnhealthyAgents = int32(i64) 4379 } 4380 4381 case "unknownAgents": 4382 if value != nil { 4383 jtv, ok := value.(json.Number) 4384 if !ok { 4385 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 4386 } 4387 i64, err := jtv.Int64() 4388 if err != nil { 4389 return err 4390 } 4391 sv.UnknownAgents = int32(i64) 4392 } 4393 4394 default: 4395 _, _ = key, value 4396 4397 } 4398 } 4399 *v = sv 4400 return nil 4401} 4402 4403func awsAwsjson11_deserializeDocumentCustomerConnectorInfo(v **types.CustomerConnectorInfo, value interface{}) error { 4404 if v == nil { 4405 return fmt.Errorf("unexpected nil of type %T", v) 4406 } 4407 if value == nil { 4408 return nil 4409 } 4410 4411 shape, ok := value.(map[string]interface{}) 4412 if !ok { 4413 return fmt.Errorf("unexpected JSON type %v", value) 4414 } 4415 4416 var sv *types.CustomerConnectorInfo 4417 if *v == nil { 4418 sv = &types.CustomerConnectorInfo{} 4419 } else { 4420 sv = *v 4421 } 4422 4423 for key, value := range shape { 4424 switch key { 4425 case "activeConnectors": 4426 if value != nil { 4427 jtv, ok := value.(json.Number) 4428 if !ok { 4429 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 4430 } 4431 i64, err := jtv.Int64() 4432 if err != nil { 4433 return err 4434 } 4435 sv.ActiveConnectors = int32(i64) 4436 } 4437 4438 case "blackListedConnectors": 4439 if value != nil { 4440 jtv, ok := value.(json.Number) 4441 if !ok { 4442 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 4443 } 4444 i64, err := jtv.Int64() 4445 if err != nil { 4446 return err 4447 } 4448 sv.BlackListedConnectors = int32(i64) 4449 } 4450 4451 case "healthyConnectors": 4452 if value != nil { 4453 jtv, ok := value.(json.Number) 4454 if !ok { 4455 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 4456 } 4457 i64, err := jtv.Int64() 4458 if err != nil { 4459 return err 4460 } 4461 sv.HealthyConnectors = int32(i64) 4462 } 4463 4464 case "shutdownConnectors": 4465 if value != nil { 4466 jtv, ok := value.(json.Number) 4467 if !ok { 4468 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 4469 } 4470 i64, err := jtv.Int64() 4471 if err != nil { 4472 return err 4473 } 4474 sv.ShutdownConnectors = int32(i64) 4475 } 4476 4477 case "totalConnectors": 4478 if value != nil { 4479 jtv, ok := value.(json.Number) 4480 if !ok { 4481 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 4482 } 4483 i64, err := jtv.Int64() 4484 if err != nil { 4485 return err 4486 } 4487 sv.TotalConnectors = int32(i64) 4488 } 4489 4490 case "unhealthyConnectors": 4491 if value != nil { 4492 jtv, ok := value.(json.Number) 4493 if !ok { 4494 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 4495 } 4496 i64, err := jtv.Int64() 4497 if err != nil { 4498 return err 4499 } 4500 sv.UnhealthyConnectors = int32(i64) 4501 } 4502 4503 case "unknownConnectors": 4504 if value != nil { 4505 jtv, ok := value.(json.Number) 4506 if !ok { 4507 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 4508 } 4509 i64, err := jtv.Int64() 4510 if err != nil { 4511 return err 4512 } 4513 sv.UnknownConnectors = int32(i64) 4514 } 4515 4516 default: 4517 _, _ = key, value 4518 4519 } 4520 } 4521 *v = sv 4522 return nil 4523} 4524 4525func awsAwsjson11_deserializeDocumentDescribeConfigurationsAttribute(v *map[string]string, value interface{}) error { 4526 if v == nil { 4527 return fmt.Errorf("unexpected nil of type %T", v) 4528 } 4529 if value == nil { 4530 return nil 4531 } 4532 4533 shape, ok := value.(map[string]interface{}) 4534 if !ok { 4535 return fmt.Errorf("unexpected JSON type %v", value) 4536 } 4537 4538 var mv map[string]string 4539 if *v == nil { 4540 mv = map[string]string{} 4541 } else { 4542 mv = *v 4543 } 4544 4545 for key, value := range shape { 4546 var parsedVal string 4547 if value != nil { 4548 jtv, ok := value.(string) 4549 if !ok { 4550 return fmt.Errorf("expected String to be of type string, got %T instead", value) 4551 } 4552 parsedVal = jtv 4553 } 4554 mv[key] = parsedVal 4555 4556 } 4557 *v = mv 4558 return nil 4559} 4560 4561func awsAwsjson11_deserializeDocumentDescribeConfigurationsAttributes(v *[]map[string]string, value interface{}) error { 4562 if v == nil { 4563 return fmt.Errorf("unexpected nil of type %T", v) 4564 } 4565 if value == nil { 4566 return nil 4567 } 4568 4569 shape, ok := value.([]interface{}) 4570 if !ok { 4571 return fmt.Errorf("unexpected JSON type %v", value) 4572 } 4573 4574 var cv []map[string]string 4575 if *v == nil { 4576 cv = []map[string]string{} 4577 } else { 4578 cv = *v 4579 } 4580 4581 for _, value := range shape { 4582 var col map[string]string 4583 if err := awsAwsjson11_deserializeDocumentDescribeConfigurationsAttribute(&col, value); err != nil { 4584 return err 4585 } 4586 cv = append(cv, col) 4587 4588 } 4589 *v = cv 4590 return nil 4591} 4592 4593func awsAwsjson11_deserializeDocumentExportInfo(v **types.ExportInfo, value interface{}) error { 4594 if v == nil { 4595 return fmt.Errorf("unexpected nil of type %T", v) 4596 } 4597 if value == nil { 4598 return nil 4599 } 4600 4601 shape, ok := value.(map[string]interface{}) 4602 if !ok { 4603 return fmt.Errorf("unexpected JSON type %v", value) 4604 } 4605 4606 var sv *types.ExportInfo 4607 if *v == nil { 4608 sv = &types.ExportInfo{} 4609 } else { 4610 sv = *v 4611 } 4612 4613 for key, value := range shape { 4614 switch key { 4615 case "configurationsDownloadUrl": 4616 if value != nil { 4617 jtv, ok := value.(string) 4618 if !ok { 4619 return fmt.Errorf("expected ConfigurationsDownloadUrl to be of type string, got %T instead", value) 4620 } 4621 sv.ConfigurationsDownloadUrl = ptr.String(jtv) 4622 } 4623 4624 case "exportId": 4625 if value != nil { 4626 jtv, ok := value.(string) 4627 if !ok { 4628 return fmt.Errorf("expected ConfigurationsExportId to be of type string, got %T instead", value) 4629 } 4630 sv.ExportId = ptr.String(jtv) 4631 } 4632 4633 case "exportRequestTime": 4634 if value != nil { 4635 jtv, ok := value.(json.Number) 4636 if !ok { 4637 return fmt.Errorf("expected ExportRequestTime to be json.Number, got %T instead", value) 4638 } 4639 f64, err := jtv.Float64() 4640 if err != nil { 4641 return err 4642 } 4643 sv.ExportRequestTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 4644 } 4645 4646 case "exportStatus": 4647 if value != nil { 4648 jtv, ok := value.(string) 4649 if !ok { 4650 return fmt.Errorf("expected ExportStatus to be of type string, got %T instead", value) 4651 } 4652 sv.ExportStatus = types.ExportStatus(jtv) 4653 } 4654 4655 case "isTruncated": 4656 if value != nil { 4657 jtv, ok := value.(bool) 4658 if !ok { 4659 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 4660 } 4661 sv.IsTruncated = jtv 4662 } 4663 4664 case "requestedEndTime": 4665 if value != nil { 4666 jtv, ok := value.(json.Number) 4667 if !ok { 4668 return fmt.Errorf("expected TimeStamp to be json.Number, got %T instead", value) 4669 } 4670 f64, err := jtv.Float64() 4671 if err != nil { 4672 return err 4673 } 4674 sv.RequestedEndTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 4675 } 4676 4677 case "requestedStartTime": 4678 if value != nil { 4679 jtv, ok := value.(json.Number) 4680 if !ok { 4681 return fmt.Errorf("expected TimeStamp to be json.Number, got %T instead", value) 4682 } 4683 f64, err := jtv.Float64() 4684 if err != nil { 4685 return err 4686 } 4687 sv.RequestedStartTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 4688 } 4689 4690 case "statusMessage": 4691 if value != nil { 4692 jtv, ok := value.(string) 4693 if !ok { 4694 return fmt.Errorf("expected ExportStatusMessage to be of type string, got %T instead", value) 4695 } 4696 sv.StatusMessage = ptr.String(jtv) 4697 } 4698 4699 default: 4700 _, _ = key, value 4701 4702 } 4703 } 4704 *v = sv 4705 return nil 4706} 4707 4708func awsAwsjson11_deserializeDocumentExportsInfo(v *[]types.ExportInfo, value interface{}) error { 4709 if v == nil { 4710 return fmt.Errorf("unexpected nil of type %T", v) 4711 } 4712 if value == nil { 4713 return nil 4714 } 4715 4716 shape, ok := value.([]interface{}) 4717 if !ok { 4718 return fmt.Errorf("unexpected JSON type %v", value) 4719 } 4720 4721 var cv []types.ExportInfo 4722 if *v == nil { 4723 cv = []types.ExportInfo{} 4724 } else { 4725 cv = *v 4726 } 4727 4728 for _, value := range shape { 4729 var col types.ExportInfo 4730 destAddr := &col 4731 if err := awsAwsjson11_deserializeDocumentExportInfo(&destAddr, value); err != nil { 4732 return err 4733 } 4734 col = *destAddr 4735 cv = append(cv, col) 4736 4737 } 4738 *v = cv 4739 return nil 4740} 4741 4742func awsAwsjson11_deserializeDocumentHomeRegionNotSetException(v **types.HomeRegionNotSetException, value interface{}) error { 4743 if v == nil { 4744 return fmt.Errorf("unexpected nil of type %T", v) 4745 } 4746 if value == nil { 4747 return nil 4748 } 4749 4750 shape, ok := value.(map[string]interface{}) 4751 if !ok { 4752 return fmt.Errorf("unexpected JSON type %v", value) 4753 } 4754 4755 var sv *types.HomeRegionNotSetException 4756 if *v == nil { 4757 sv = &types.HomeRegionNotSetException{} 4758 } else { 4759 sv = *v 4760 } 4761 4762 for key, value := range shape { 4763 switch key { 4764 case "message": 4765 if value != nil { 4766 jtv, ok := value.(string) 4767 if !ok { 4768 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 4769 } 4770 sv.Message = ptr.String(jtv) 4771 } 4772 4773 default: 4774 _, _ = key, value 4775 4776 } 4777 } 4778 *v = sv 4779 return nil 4780} 4781 4782func awsAwsjson11_deserializeDocumentImportTask(v **types.ImportTask, value interface{}) error { 4783 if v == nil { 4784 return fmt.Errorf("unexpected nil of type %T", v) 4785 } 4786 if value == nil { 4787 return nil 4788 } 4789 4790 shape, ok := value.(map[string]interface{}) 4791 if !ok { 4792 return fmt.Errorf("unexpected JSON type %v", value) 4793 } 4794 4795 var sv *types.ImportTask 4796 if *v == nil { 4797 sv = &types.ImportTask{} 4798 } else { 4799 sv = *v 4800 } 4801 4802 for key, value := range shape { 4803 switch key { 4804 case "applicationImportFailure": 4805 if value != nil { 4806 jtv, ok := value.(json.Number) 4807 if !ok { 4808 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 4809 } 4810 i64, err := jtv.Int64() 4811 if err != nil { 4812 return err 4813 } 4814 sv.ApplicationImportFailure = int32(i64) 4815 } 4816 4817 case "applicationImportSuccess": 4818 if value != nil { 4819 jtv, ok := value.(json.Number) 4820 if !ok { 4821 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 4822 } 4823 i64, err := jtv.Int64() 4824 if err != nil { 4825 return err 4826 } 4827 sv.ApplicationImportSuccess = int32(i64) 4828 } 4829 4830 case "clientRequestToken": 4831 if value != nil { 4832 jtv, ok := value.(string) 4833 if !ok { 4834 return fmt.Errorf("expected ClientRequestToken to be of type string, got %T instead", value) 4835 } 4836 sv.ClientRequestToken = ptr.String(jtv) 4837 } 4838 4839 case "errorsAndFailedEntriesZip": 4840 if value != nil { 4841 jtv, ok := value.(string) 4842 if !ok { 4843 return fmt.Errorf("expected S3PresignedUrl to be of type string, got %T instead", value) 4844 } 4845 sv.ErrorsAndFailedEntriesZip = ptr.String(jtv) 4846 } 4847 4848 case "importCompletionTime": 4849 if value != nil { 4850 jtv, ok := value.(json.Number) 4851 if !ok { 4852 return fmt.Errorf("expected TimeStamp to be json.Number, got %T instead", value) 4853 } 4854 f64, err := jtv.Float64() 4855 if err != nil { 4856 return err 4857 } 4858 sv.ImportCompletionTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 4859 } 4860 4861 case "importDeletedTime": 4862 if value != nil { 4863 jtv, ok := value.(json.Number) 4864 if !ok { 4865 return fmt.Errorf("expected TimeStamp to be json.Number, got %T instead", value) 4866 } 4867 f64, err := jtv.Float64() 4868 if err != nil { 4869 return err 4870 } 4871 sv.ImportDeletedTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 4872 } 4873 4874 case "importRequestTime": 4875 if value != nil { 4876 jtv, ok := value.(json.Number) 4877 if !ok { 4878 return fmt.Errorf("expected TimeStamp to be json.Number, got %T instead", value) 4879 } 4880 f64, err := jtv.Float64() 4881 if err != nil { 4882 return err 4883 } 4884 sv.ImportRequestTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 4885 } 4886 4887 case "importTaskId": 4888 if value != nil { 4889 jtv, ok := value.(string) 4890 if !ok { 4891 return fmt.Errorf("expected ImportTaskIdentifier to be of type string, got %T instead", value) 4892 } 4893 sv.ImportTaskId = ptr.String(jtv) 4894 } 4895 4896 case "importUrl": 4897 if value != nil { 4898 jtv, ok := value.(string) 4899 if !ok { 4900 return fmt.Errorf("expected ImportURL to be of type string, got %T instead", value) 4901 } 4902 sv.ImportUrl = ptr.String(jtv) 4903 } 4904 4905 case "name": 4906 if value != nil { 4907 jtv, ok := value.(string) 4908 if !ok { 4909 return fmt.Errorf("expected ImportTaskName to be of type string, got %T instead", value) 4910 } 4911 sv.Name = ptr.String(jtv) 4912 } 4913 4914 case "serverImportFailure": 4915 if value != nil { 4916 jtv, ok := value.(json.Number) 4917 if !ok { 4918 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 4919 } 4920 i64, err := jtv.Int64() 4921 if err != nil { 4922 return err 4923 } 4924 sv.ServerImportFailure = int32(i64) 4925 } 4926 4927 case "serverImportSuccess": 4928 if value != nil { 4929 jtv, ok := value.(json.Number) 4930 if !ok { 4931 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 4932 } 4933 i64, err := jtv.Int64() 4934 if err != nil { 4935 return err 4936 } 4937 sv.ServerImportSuccess = int32(i64) 4938 } 4939 4940 case "status": 4941 if value != nil { 4942 jtv, ok := value.(string) 4943 if !ok { 4944 return fmt.Errorf("expected ImportStatus to be of type string, got %T instead", value) 4945 } 4946 sv.Status = types.ImportStatus(jtv) 4947 } 4948 4949 default: 4950 _, _ = key, value 4951 4952 } 4953 } 4954 *v = sv 4955 return nil 4956} 4957 4958func awsAwsjson11_deserializeDocumentImportTaskList(v *[]types.ImportTask, value interface{}) error { 4959 if v == nil { 4960 return fmt.Errorf("unexpected nil of type %T", v) 4961 } 4962 if value == nil { 4963 return nil 4964 } 4965 4966 shape, ok := value.([]interface{}) 4967 if !ok { 4968 return fmt.Errorf("unexpected JSON type %v", value) 4969 } 4970 4971 var cv []types.ImportTask 4972 if *v == nil { 4973 cv = []types.ImportTask{} 4974 } else { 4975 cv = *v 4976 } 4977 4978 for _, value := range shape { 4979 var col types.ImportTask 4980 destAddr := &col 4981 if err := awsAwsjson11_deserializeDocumentImportTask(&destAddr, value); err != nil { 4982 return err 4983 } 4984 col = *destAddr 4985 cv = append(cv, col) 4986 4987 } 4988 *v = cv 4989 return nil 4990} 4991 4992func awsAwsjson11_deserializeDocumentInvalidParameterException(v **types.InvalidParameterException, value interface{}) error { 4993 if v == nil { 4994 return fmt.Errorf("unexpected nil of type %T", v) 4995 } 4996 if value == nil { 4997 return nil 4998 } 4999 5000 shape, ok := value.(map[string]interface{}) 5001 if !ok { 5002 return fmt.Errorf("unexpected JSON type %v", value) 5003 } 5004 5005 var sv *types.InvalidParameterException 5006 if *v == nil { 5007 sv = &types.InvalidParameterException{} 5008 } else { 5009 sv = *v 5010 } 5011 5012 for key, value := range shape { 5013 switch key { 5014 case "message": 5015 if value != nil { 5016 jtv, ok := value.(string) 5017 if !ok { 5018 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 5019 } 5020 sv.Message = ptr.String(jtv) 5021 } 5022 5023 default: 5024 _, _ = key, value 5025 5026 } 5027 } 5028 *v = sv 5029 return nil 5030} 5031 5032func awsAwsjson11_deserializeDocumentInvalidParameterValueException(v **types.InvalidParameterValueException, value interface{}) error { 5033 if v == nil { 5034 return fmt.Errorf("unexpected nil of type %T", v) 5035 } 5036 if value == nil { 5037 return nil 5038 } 5039 5040 shape, ok := value.(map[string]interface{}) 5041 if !ok { 5042 return fmt.Errorf("unexpected JSON type %v", value) 5043 } 5044 5045 var sv *types.InvalidParameterValueException 5046 if *v == nil { 5047 sv = &types.InvalidParameterValueException{} 5048 } else { 5049 sv = *v 5050 } 5051 5052 for key, value := range shape { 5053 switch key { 5054 case "message": 5055 if value != nil { 5056 jtv, ok := value.(string) 5057 if !ok { 5058 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 5059 } 5060 sv.Message = ptr.String(jtv) 5061 } 5062 5063 default: 5064 _, _ = key, value 5065 5066 } 5067 } 5068 *v = sv 5069 return nil 5070} 5071 5072func awsAwsjson11_deserializeDocumentNeighborConnectionDetail(v **types.NeighborConnectionDetail, value interface{}) error { 5073 if v == nil { 5074 return fmt.Errorf("unexpected nil of type %T", v) 5075 } 5076 if value == nil { 5077 return nil 5078 } 5079 5080 shape, ok := value.(map[string]interface{}) 5081 if !ok { 5082 return fmt.Errorf("unexpected JSON type %v", value) 5083 } 5084 5085 var sv *types.NeighborConnectionDetail 5086 if *v == nil { 5087 sv = &types.NeighborConnectionDetail{} 5088 } else { 5089 sv = *v 5090 } 5091 5092 for key, value := range shape { 5093 switch key { 5094 case "connectionsCount": 5095 if value != nil { 5096 jtv, ok := value.(json.Number) 5097 if !ok { 5098 return fmt.Errorf("expected Long to be json.Number, got %T instead", value) 5099 } 5100 i64, err := jtv.Int64() 5101 if err != nil { 5102 return err 5103 } 5104 sv.ConnectionsCount = i64 5105 } 5106 5107 case "destinationPort": 5108 if value != nil { 5109 jtv, ok := value.(json.Number) 5110 if !ok { 5111 return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value) 5112 } 5113 i64, err := jtv.Int64() 5114 if err != nil { 5115 return err 5116 } 5117 sv.DestinationPort = ptr.Int32(int32(i64)) 5118 } 5119 5120 case "destinationServerId": 5121 if value != nil { 5122 jtv, ok := value.(string) 5123 if !ok { 5124 return fmt.Errorf("expected ConfigurationId to be of type string, got %T instead", value) 5125 } 5126 sv.DestinationServerId = ptr.String(jtv) 5127 } 5128 5129 case "sourceServerId": 5130 if value != nil { 5131 jtv, ok := value.(string) 5132 if !ok { 5133 return fmt.Errorf("expected ConfigurationId to be of type string, got %T instead", value) 5134 } 5135 sv.SourceServerId = ptr.String(jtv) 5136 } 5137 5138 case "transportProtocol": 5139 if value != nil { 5140 jtv, ok := value.(string) 5141 if !ok { 5142 return fmt.Errorf("expected String to be of type string, got %T instead", value) 5143 } 5144 sv.TransportProtocol = ptr.String(jtv) 5145 } 5146 5147 default: 5148 _, _ = key, value 5149 5150 } 5151 } 5152 *v = sv 5153 return nil 5154} 5155 5156func awsAwsjson11_deserializeDocumentNeighborDetailsList(v *[]types.NeighborConnectionDetail, value interface{}) error { 5157 if v == nil { 5158 return fmt.Errorf("unexpected nil of type %T", v) 5159 } 5160 if value == nil { 5161 return nil 5162 } 5163 5164 shape, ok := value.([]interface{}) 5165 if !ok { 5166 return fmt.Errorf("unexpected JSON type %v", value) 5167 } 5168 5169 var cv []types.NeighborConnectionDetail 5170 if *v == nil { 5171 cv = []types.NeighborConnectionDetail{} 5172 } else { 5173 cv = *v 5174 } 5175 5176 for _, value := range shape { 5177 var col types.NeighborConnectionDetail 5178 destAddr := &col 5179 if err := awsAwsjson11_deserializeDocumentNeighborConnectionDetail(&destAddr, value); err != nil { 5180 return err 5181 } 5182 col = *destAddr 5183 cv = append(cv, col) 5184 5185 } 5186 *v = cv 5187 return nil 5188} 5189 5190func awsAwsjson11_deserializeDocumentOperationNotPermittedException(v **types.OperationNotPermittedException, value interface{}) error { 5191 if v == nil { 5192 return fmt.Errorf("unexpected nil of type %T", v) 5193 } 5194 if value == nil { 5195 return nil 5196 } 5197 5198 shape, ok := value.(map[string]interface{}) 5199 if !ok { 5200 return fmt.Errorf("unexpected JSON type %v", value) 5201 } 5202 5203 var sv *types.OperationNotPermittedException 5204 if *v == nil { 5205 sv = &types.OperationNotPermittedException{} 5206 } else { 5207 sv = *v 5208 } 5209 5210 for key, value := range shape { 5211 switch key { 5212 case "message": 5213 if value != nil { 5214 jtv, ok := value.(string) 5215 if !ok { 5216 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 5217 } 5218 sv.Message = ptr.String(jtv) 5219 } 5220 5221 default: 5222 _, _ = key, value 5223 5224 } 5225 } 5226 *v = sv 5227 return nil 5228} 5229 5230func awsAwsjson11_deserializeDocumentResourceInUseException(v **types.ResourceInUseException, value interface{}) error { 5231 if v == nil { 5232 return fmt.Errorf("unexpected nil of type %T", v) 5233 } 5234 if value == nil { 5235 return nil 5236 } 5237 5238 shape, ok := value.(map[string]interface{}) 5239 if !ok { 5240 return fmt.Errorf("unexpected JSON type %v", value) 5241 } 5242 5243 var sv *types.ResourceInUseException 5244 if *v == nil { 5245 sv = &types.ResourceInUseException{} 5246 } else { 5247 sv = *v 5248 } 5249 5250 for key, value := range shape { 5251 switch key { 5252 case "message": 5253 if value != nil { 5254 jtv, ok := value.(string) 5255 if !ok { 5256 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 5257 } 5258 sv.Message = ptr.String(jtv) 5259 } 5260 5261 default: 5262 _, _ = key, value 5263 5264 } 5265 } 5266 *v = sv 5267 return nil 5268} 5269 5270func awsAwsjson11_deserializeDocumentResourceNotFoundException(v **types.ResourceNotFoundException, value interface{}) error { 5271 if v == nil { 5272 return fmt.Errorf("unexpected nil of type %T", v) 5273 } 5274 if value == nil { 5275 return nil 5276 } 5277 5278 shape, ok := value.(map[string]interface{}) 5279 if !ok { 5280 return fmt.Errorf("unexpected JSON type %v", value) 5281 } 5282 5283 var sv *types.ResourceNotFoundException 5284 if *v == nil { 5285 sv = &types.ResourceNotFoundException{} 5286 } else { 5287 sv = *v 5288 } 5289 5290 for key, value := range shape { 5291 switch key { 5292 case "message": 5293 if value != nil { 5294 jtv, ok := value.(string) 5295 if !ok { 5296 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 5297 } 5298 sv.Message = ptr.String(jtv) 5299 } 5300 5301 default: 5302 _, _ = key, value 5303 5304 } 5305 } 5306 *v = sv 5307 return nil 5308} 5309 5310func awsAwsjson11_deserializeDocumentSchemaStorageConfig(v *map[string]string, value interface{}) error { 5311 if v == nil { 5312 return fmt.Errorf("unexpected nil of type %T", v) 5313 } 5314 if value == nil { 5315 return nil 5316 } 5317 5318 shape, ok := value.(map[string]interface{}) 5319 if !ok { 5320 return fmt.Errorf("unexpected JSON type %v", value) 5321 } 5322 5323 var mv map[string]string 5324 if *v == nil { 5325 mv = map[string]string{} 5326 } else { 5327 mv = *v 5328 } 5329 5330 for key, value := range shape { 5331 var parsedVal string 5332 if value != nil { 5333 jtv, ok := value.(string) 5334 if !ok { 5335 return fmt.Errorf("expected String to be of type string, got %T instead", value) 5336 } 5337 parsedVal = jtv 5338 } 5339 mv[key] = parsedVal 5340 5341 } 5342 *v = mv 5343 return nil 5344} 5345 5346func awsAwsjson11_deserializeDocumentServerInternalErrorException(v **types.ServerInternalErrorException, value interface{}) error { 5347 if v == nil { 5348 return fmt.Errorf("unexpected nil of type %T", v) 5349 } 5350 if value == nil { 5351 return nil 5352 } 5353 5354 shape, ok := value.(map[string]interface{}) 5355 if !ok { 5356 return fmt.Errorf("unexpected JSON type %v", value) 5357 } 5358 5359 var sv *types.ServerInternalErrorException 5360 if *v == nil { 5361 sv = &types.ServerInternalErrorException{} 5362 } else { 5363 sv = *v 5364 } 5365 5366 for key, value := range shape { 5367 switch key { 5368 case "message": 5369 if value != nil { 5370 jtv, ok := value.(string) 5371 if !ok { 5372 return fmt.Errorf("expected Message to be of type string, got %T instead", value) 5373 } 5374 sv.Message = ptr.String(jtv) 5375 } 5376 5377 default: 5378 _, _ = key, value 5379 5380 } 5381 } 5382 *v = sv 5383 return nil 5384} 5385 5386func awsAwsjson11_deserializeOpDocumentAssociateConfigurationItemsToApplicationOutput(v **AssociateConfigurationItemsToApplicationOutput, value interface{}) error { 5387 if v == nil { 5388 return fmt.Errorf("unexpected nil of type %T", v) 5389 } 5390 if value == nil { 5391 return nil 5392 } 5393 5394 shape, ok := value.(map[string]interface{}) 5395 if !ok { 5396 return fmt.Errorf("unexpected JSON type %v", value) 5397 } 5398 5399 var sv *AssociateConfigurationItemsToApplicationOutput 5400 if *v == nil { 5401 sv = &AssociateConfigurationItemsToApplicationOutput{} 5402 } else { 5403 sv = *v 5404 } 5405 5406 for key, value := range shape { 5407 switch key { 5408 default: 5409 _, _ = key, value 5410 5411 } 5412 } 5413 *v = sv 5414 return nil 5415} 5416 5417func awsAwsjson11_deserializeOpDocumentBatchDeleteImportDataOutput(v **BatchDeleteImportDataOutput, value interface{}) error { 5418 if v == nil { 5419 return fmt.Errorf("unexpected nil of type %T", v) 5420 } 5421 if value == nil { 5422 return nil 5423 } 5424 5425 shape, ok := value.(map[string]interface{}) 5426 if !ok { 5427 return fmt.Errorf("unexpected JSON type %v", value) 5428 } 5429 5430 var sv *BatchDeleteImportDataOutput 5431 if *v == nil { 5432 sv = &BatchDeleteImportDataOutput{} 5433 } else { 5434 sv = *v 5435 } 5436 5437 for key, value := range shape { 5438 switch key { 5439 case "errors": 5440 if err := awsAwsjson11_deserializeDocumentBatchDeleteImportDataErrorList(&sv.Errors, value); err != nil { 5441 return err 5442 } 5443 5444 default: 5445 _, _ = key, value 5446 5447 } 5448 } 5449 *v = sv 5450 return nil 5451} 5452 5453func awsAwsjson11_deserializeOpDocumentCreateApplicationOutput(v **CreateApplicationOutput, value interface{}) error { 5454 if v == nil { 5455 return fmt.Errorf("unexpected nil of type %T", v) 5456 } 5457 if value == nil { 5458 return nil 5459 } 5460 5461 shape, ok := value.(map[string]interface{}) 5462 if !ok { 5463 return fmt.Errorf("unexpected JSON type %v", value) 5464 } 5465 5466 var sv *CreateApplicationOutput 5467 if *v == nil { 5468 sv = &CreateApplicationOutput{} 5469 } else { 5470 sv = *v 5471 } 5472 5473 for key, value := range shape { 5474 switch key { 5475 case "configurationId": 5476 if value != nil { 5477 jtv, ok := value.(string) 5478 if !ok { 5479 return fmt.Errorf("expected String to be of type string, got %T instead", value) 5480 } 5481 sv.ConfigurationId = ptr.String(jtv) 5482 } 5483 5484 default: 5485 _, _ = key, value 5486 5487 } 5488 } 5489 *v = sv 5490 return nil 5491} 5492 5493func awsAwsjson11_deserializeOpDocumentCreateTagsOutput(v **CreateTagsOutput, value interface{}) error { 5494 if v == nil { 5495 return fmt.Errorf("unexpected nil of type %T", v) 5496 } 5497 if value == nil { 5498 return nil 5499 } 5500 5501 shape, ok := value.(map[string]interface{}) 5502 if !ok { 5503 return fmt.Errorf("unexpected JSON type %v", value) 5504 } 5505 5506 var sv *CreateTagsOutput 5507 if *v == nil { 5508 sv = &CreateTagsOutput{} 5509 } else { 5510 sv = *v 5511 } 5512 5513 for key, value := range shape { 5514 switch key { 5515 default: 5516 _, _ = key, value 5517 5518 } 5519 } 5520 *v = sv 5521 return nil 5522} 5523 5524func awsAwsjson11_deserializeOpDocumentDeleteApplicationsOutput(v **DeleteApplicationsOutput, value interface{}) error { 5525 if v == nil { 5526 return fmt.Errorf("unexpected nil of type %T", v) 5527 } 5528 if value == nil { 5529 return nil 5530 } 5531 5532 shape, ok := value.(map[string]interface{}) 5533 if !ok { 5534 return fmt.Errorf("unexpected JSON type %v", value) 5535 } 5536 5537 var sv *DeleteApplicationsOutput 5538 if *v == nil { 5539 sv = &DeleteApplicationsOutput{} 5540 } else { 5541 sv = *v 5542 } 5543 5544 for key, value := range shape { 5545 switch key { 5546 default: 5547 _, _ = key, value 5548 5549 } 5550 } 5551 *v = sv 5552 return nil 5553} 5554 5555func awsAwsjson11_deserializeOpDocumentDeleteTagsOutput(v **DeleteTagsOutput, value interface{}) error { 5556 if v == nil { 5557 return fmt.Errorf("unexpected nil of type %T", v) 5558 } 5559 if value == nil { 5560 return nil 5561 } 5562 5563 shape, ok := value.(map[string]interface{}) 5564 if !ok { 5565 return fmt.Errorf("unexpected JSON type %v", value) 5566 } 5567 5568 var sv *DeleteTagsOutput 5569 if *v == nil { 5570 sv = &DeleteTagsOutput{} 5571 } else { 5572 sv = *v 5573 } 5574 5575 for key, value := range shape { 5576 switch key { 5577 default: 5578 _, _ = key, value 5579 5580 } 5581 } 5582 *v = sv 5583 return nil 5584} 5585 5586func awsAwsjson11_deserializeOpDocumentDescribeAgentsOutput(v **DescribeAgentsOutput, value interface{}) error { 5587 if v == nil { 5588 return fmt.Errorf("unexpected nil of type %T", v) 5589 } 5590 if value == nil { 5591 return nil 5592 } 5593 5594 shape, ok := value.(map[string]interface{}) 5595 if !ok { 5596 return fmt.Errorf("unexpected JSON type %v", value) 5597 } 5598 5599 var sv *DescribeAgentsOutput 5600 if *v == nil { 5601 sv = &DescribeAgentsOutput{} 5602 } else { 5603 sv = *v 5604 } 5605 5606 for key, value := range shape { 5607 switch key { 5608 case "agentsInfo": 5609 if err := awsAwsjson11_deserializeDocumentAgentsInfo(&sv.AgentsInfo, value); err != nil { 5610 return err 5611 } 5612 5613 case "nextToken": 5614 if value != nil { 5615 jtv, ok := value.(string) 5616 if !ok { 5617 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 5618 } 5619 sv.NextToken = ptr.String(jtv) 5620 } 5621 5622 default: 5623 _, _ = key, value 5624 5625 } 5626 } 5627 *v = sv 5628 return nil 5629} 5630 5631func awsAwsjson11_deserializeOpDocumentDescribeConfigurationsOutput(v **DescribeConfigurationsOutput, 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 *DescribeConfigurationsOutput 5645 if *v == nil { 5646 sv = &DescribeConfigurationsOutput{} 5647 } else { 5648 sv = *v 5649 } 5650 5651 for key, value := range shape { 5652 switch key { 5653 case "configurations": 5654 if err := awsAwsjson11_deserializeDocumentDescribeConfigurationsAttributes(&sv.Configurations, value); err != nil { 5655 return err 5656 } 5657 5658 default: 5659 _, _ = key, value 5660 5661 } 5662 } 5663 *v = sv 5664 return nil 5665} 5666 5667func awsAwsjson11_deserializeOpDocumentDescribeContinuousExportsOutput(v **DescribeContinuousExportsOutput, value interface{}) error { 5668 if v == nil { 5669 return fmt.Errorf("unexpected nil of type %T", v) 5670 } 5671 if value == nil { 5672 return nil 5673 } 5674 5675 shape, ok := value.(map[string]interface{}) 5676 if !ok { 5677 return fmt.Errorf("unexpected JSON type %v", value) 5678 } 5679 5680 var sv *DescribeContinuousExportsOutput 5681 if *v == nil { 5682 sv = &DescribeContinuousExportsOutput{} 5683 } else { 5684 sv = *v 5685 } 5686 5687 for key, value := range shape { 5688 switch key { 5689 case "descriptions": 5690 if err := awsAwsjson11_deserializeDocumentContinuousExportDescriptions(&sv.Descriptions, value); err != nil { 5691 return err 5692 } 5693 5694 case "nextToken": 5695 if value != nil { 5696 jtv, ok := value.(string) 5697 if !ok { 5698 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 5699 } 5700 sv.NextToken = ptr.String(jtv) 5701 } 5702 5703 default: 5704 _, _ = key, value 5705 5706 } 5707 } 5708 *v = sv 5709 return nil 5710} 5711 5712func awsAwsjson11_deserializeOpDocumentDescribeExportConfigurationsOutput(v **DescribeExportConfigurationsOutput, value interface{}) error { 5713 if v == nil { 5714 return fmt.Errorf("unexpected nil of type %T", v) 5715 } 5716 if value == nil { 5717 return nil 5718 } 5719 5720 shape, ok := value.(map[string]interface{}) 5721 if !ok { 5722 return fmt.Errorf("unexpected JSON type %v", value) 5723 } 5724 5725 var sv *DescribeExportConfigurationsOutput 5726 if *v == nil { 5727 sv = &DescribeExportConfigurationsOutput{} 5728 } else { 5729 sv = *v 5730 } 5731 5732 for key, value := range shape { 5733 switch key { 5734 case "exportsInfo": 5735 if err := awsAwsjson11_deserializeDocumentExportsInfo(&sv.ExportsInfo, value); err != nil { 5736 return err 5737 } 5738 5739 case "nextToken": 5740 if value != nil { 5741 jtv, ok := value.(string) 5742 if !ok { 5743 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 5744 } 5745 sv.NextToken = ptr.String(jtv) 5746 } 5747 5748 default: 5749 _, _ = key, value 5750 5751 } 5752 } 5753 *v = sv 5754 return nil 5755} 5756 5757func awsAwsjson11_deserializeOpDocumentDescribeExportTasksOutput(v **DescribeExportTasksOutput, value interface{}) error { 5758 if v == nil { 5759 return fmt.Errorf("unexpected nil of type %T", v) 5760 } 5761 if value == nil { 5762 return nil 5763 } 5764 5765 shape, ok := value.(map[string]interface{}) 5766 if !ok { 5767 return fmt.Errorf("unexpected JSON type %v", value) 5768 } 5769 5770 var sv *DescribeExportTasksOutput 5771 if *v == nil { 5772 sv = &DescribeExportTasksOutput{} 5773 } else { 5774 sv = *v 5775 } 5776 5777 for key, value := range shape { 5778 switch key { 5779 case "exportsInfo": 5780 if err := awsAwsjson11_deserializeDocumentExportsInfo(&sv.ExportsInfo, value); err != nil { 5781 return err 5782 } 5783 5784 case "nextToken": 5785 if value != nil { 5786 jtv, ok := value.(string) 5787 if !ok { 5788 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 5789 } 5790 sv.NextToken = ptr.String(jtv) 5791 } 5792 5793 default: 5794 _, _ = key, value 5795 5796 } 5797 } 5798 *v = sv 5799 return nil 5800} 5801 5802func awsAwsjson11_deserializeOpDocumentDescribeImportTasksOutput(v **DescribeImportTasksOutput, value interface{}) error { 5803 if v == nil { 5804 return fmt.Errorf("unexpected nil of type %T", v) 5805 } 5806 if value == nil { 5807 return nil 5808 } 5809 5810 shape, ok := value.(map[string]interface{}) 5811 if !ok { 5812 return fmt.Errorf("unexpected JSON type %v", value) 5813 } 5814 5815 var sv *DescribeImportTasksOutput 5816 if *v == nil { 5817 sv = &DescribeImportTasksOutput{} 5818 } else { 5819 sv = *v 5820 } 5821 5822 for key, value := range shape { 5823 switch key { 5824 case "nextToken": 5825 if value != nil { 5826 jtv, ok := value.(string) 5827 if !ok { 5828 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 5829 } 5830 sv.NextToken = ptr.String(jtv) 5831 } 5832 5833 case "tasks": 5834 if err := awsAwsjson11_deserializeDocumentImportTaskList(&sv.Tasks, value); err != nil { 5835 return err 5836 } 5837 5838 default: 5839 _, _ = key, value 5840 5841 } 5842 } 5843 *v = sv 5844 return nil 5845} 5846 5847func awsAwsjson11_deserializeOpDocumentDescribeTagsOutput(v **DescribeTagsOutput, value interface{}) error { 5848 if v == nil { 5849 return fmt.Errorf("unexpected nil of type %T", v) 5850 } 5851 if value == nil { 5852 return nil 5853 } 5854 5855 shape, ok := value.(map[string]interface{}) 5856 if !ok { 5857 return fmt.Errorf("unexpected JSON type %v", value) 5858 } 5859 5860 var sv *DescribeTagsOutput 5861 if *v == nil { 5862 sv = &DescribeTagsOutput{} 5863 } else { 5864 sv = *v 5865 } 5866 5867 for key, value := range shape { 5868 switch key { 5869 case "nextToken": 5870 if value != nil { 5871 jtv, ok := value.(string) 5872 if !ok { 5873 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 5874 } 5875 sv.NextToken = ptr.String(jtv) 5876 } 5877 5878 case "tags": 5879 if err := awsAwsjson11_deserializeDocumentConfigurationTagSet(&sv.Tags, value); err != nil { 5880 return err 5881 } 5882 5883 default: 5884 _, _ = key, value 5885 5886 } 5887 } 5888 *v = sv 5889 return nil 5890} 5891 5892func awsAwsjson11_deserializeOpDocumentDisassociateConfigurationItemsFromApplicationOutput(v **DisassociateConfigurationItemsFromApplicationOutput, value interface{}) error { 5893 if v == nil { 5894 return fmt.Errorf("unexpected nil of type %T", v) 5895 } 5896 if value == nil { 5897 return nil 5898 } 5899 5900 shape, ok := value.(map[string]interface{}) 5901 if !ok { 5902 return fmt.Errorf("unexpected JSON type %v", value) 5903 } 5904 5905 var sv *DisassociateConfigurationItemsFromApplicationOutput 5906 if *v == nil { 5907 sv = &DisassociateConfigurationItemsFromApplicationOutput{} 5908 } else { 5909 sv = *v 5910 } 5911 5912 for key, value := range shape { 5913 switch key { 5914 default: 5915 _, _ = key, value 5916 5917 } 5918 } 5919 *v = sv 5920 return nil 5921} 5922 5923func awsAwsjson11_deserializeOpDocumentExportConfigurationsOutput(v **ExportConfigurationsOutput, value interface{}) error { 5924 if v == nil { 5925 return fmt.Errorf("unexpected nil of type %T", v) 5926 } 5927 if value == nil { 5928 return nil 5929 } 5930 5931 shape, ok := value.(map[string]interface{}) 5932 if !ok { 5933 return fmt.Errorf("unexpected JSON type %v", value) 5934 } 5935 5936 var sv *ExportConfigurationsOutput 5937 if *v == nil { 5938 sv = &ExportConfigurationsOutput{} 5939 } else { 5940 sv = *v 5941 } 5942 5943 for key, value := range shape { 5944 switch key { 5945 case "exportId": 5946 if value != nil { 5947 jtv, ok := value.(string) 5948 if !ok { 5949 return fmt.Errorf("expected ConfigurationsExportId to be of type string, got %T instead", value) 5950 } 5951 sv.ExportId = ptr.String(jtv) 5952 } 5953 5954 default: 5955 _, _ = key, value 5956 5957 } 5958 } 5959 *v = sv 5960 return nil 5961} 5962 5963func awsAwsjson11_deserializeOpDocumentGetDiscoverySummaryOutput(v **GetDiscoverySummaryOutput, value interface{}) error { 5964 if v == nil { 5965 return fmt.Errorf("unexpected nil of type %T", v) 5966 } 5967 if value == nil { 5968 return nil 5969 } 5970 5971 shape, ok := value.(map[string]interface{}) 5972 if !ok { 5973 return fmt.Errorf("unexpected JSON type %v", value) 5974 } 5975 5976 var sv *GetDiscoverySummaryOutput 5977 if *v == nil { 5978 sv = &GetDiscoverySummaryOutput{} 5979 } else { 5980 sv = *v 5981 } 5982 5983 for key, value := range shape { 5984 switch key { 5985 case "agentSummary": 5986 if err := awsAwsjson11_deserializeDocumentCustomerAgentInfo(&sv.AgentSummary, value); err != nil { 5987 return err 5988 } 5989 5990 case "applications": 5991 if value != nil { 5992 jtv, ok := value.(json.Number) 5993 if !ok { 5994 return fmt.Errorf("expected Long to be json.Number, got %T instead", value) 5995 } 5996 i64, err := jtv.Int64() 5997 if err != nil { 5998 return err 5999 } 6000 sv.Applications = i64 6001 } 6002 6003 case "connectorSummary": 6004 if err := awsAwsjson11_deserializeDocumentCustomerConnectorInfo(&sv.ConnectorSummary, value); err != nil { 6005 return err 6006 } 6007 6008 case "servers": 6009 if value != nil { 6010 jtv, ok := value.(json.Number) 6011 if !ok { 6012 return fmt.Errorf("expected Long to be json.Number, got %T instead", value) 6013 } 6014 i64, err := jtv.Int64() 6015 if err != nil { 6016 return err 6017 } 6018 sv.Servers = i64 6019 } 6020 6021 case "serversMappedToApplications": 6022 if value != nil { 6023 jtv, ok := value.(json.Number) 6024 if !ok { 6025 return fmt.Errorf("expected Long to be json.Number, got %T instead", value) 6026 } 6027 i64, err := jtv.Int64() 6028 if err != nil { 6029 return err 6030 } 6031 sv.ServersMappedToApplications = i64 6032 } 6033 6034 case "serversMappedtoTags": 6035 if value != nil { 6036 jtv, ok := value.(json.Number) 6037 if !ok { 6038 return fmt.Errorf("expected Long to be json.Number, got %T instead", value) 6039 } 6040 i64, err := jtv.Int64() 6041 if err != nil { 6042 return err 6043 } 6044 sv.ServersMappedtoTags = i64 6045 } 6046 6047 default: 6048 _, _ = key, value 6049 6050 } 6051 } 6052 *v = sv 6053 return nil 6054} 6055 6056func awsAwsjson11_deserializeOpDocumentListConfigurationsOutput(v **ListConfigurationsOutput, value interface{}) error { 6057 if v == nil { 6058 return fmt.Errorf("unexpected nil of type %T", v) 6059 } 6060 if value == nil { 6061 return nil 6062 } 6063 6064 shape, ok := value.(map[string]interface{}) 6065 if !ok { 6066 return fmt.Errorf("unexpected JSON type %v", value) 6067 } 6068 6069 var sv *ListConfigurationsOutput 6070 if *v == nil { 6071 sv = &ListConfigurationsOutput{} 6072 } else { 6073 sv = *v 6074 } 6075 6076 for key, value := range shape { 6077 switch key { 6078 case "configurations": 6079 if err := awsAwsjson11_deserializeDocumentConfigurations(&sv.Configurations, value); err != nil { 6080 return err 6081 } 6082 6083 case "nextToken": 6084 if value != nil { 6085 jtv, ok := value.(string) 6086 if !ok { 6087 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 6088 } 6089 sv.NextToken = ptr.String(jtv) 6090 } 6091 6092 default: 6093 _, _ = key, value 6094 6095 } 6096 } 6097 *v = sv 6098 return nil 6099} 6100 6101func awsAwsjson11_deserializeOpDocumentListServerNeighborsOutput(v **ListServerNeighborsOutput, value interface{}) error { 6102 if v == nil { 6103 return fmt.Errorf("unexpected nil of type %T", v) 6104 } 6105 if value == nil { 6106 return nil 6107 } 6108 6109 shape, ok := value.(map[string]interface{}) 6110 if !ok { 6111 return fmt.Errorf("unexpected JSON type %v", value) 6112 } 6113 6114 var sv *ListServerNeighborsOutput 6115 if *v == nil { 6116 sv = &ListServerNeighborsOutput{} 6117 } else { 6118 sv = *v 6119 } 6120 6121 for key, value := range shape { 6122 switch key { 6123 case "knownDependencyCount": 6124 if value != nil { 6125 jtv, ok := value.(json.Number) 6126 if !ok { 6127 return fmt.Errorf("expected Long to be json.Number, got %T instead", value) 6128 } 6129 i64, err := jtv.Int64() 6130 if err != nil { 6131 return err 6132 } 6133 sv.KnownDependencyCount = i64 6134 } 6135 6136 case "neighbors": 6137 if err := awsAwsjson11_deserializeDocumentNeighborDetailsList(&sv.Neighbors, value); err != nil { 6138 return err 6139 } 6140 6141 case "nextToken": 6142 if value != nil { 6143 jtv, ok := value.(string) 6144 if !ok { 6145 return fmt.Errorf("expected String to be of type string, got %T instead", value) 6146 } 6147 sv.NextToken = ptr.String(jtv) 6148 } 6149 6150 default: 6151 _, _ = key, value 6152 6153 } 6154 } 6155 *v = sv 6156 return nil 6157} 6158 6159func awsAwsjson11_deserializeOpDocumentStartContinuousExportOutput(v **StartContinuousExportOutput, value interface{}) error { 6160 if v == nil { 6161 return fmt.Errorf("unexpected nil of type %T", v) 6162 } 6163 if value == nil { 6164 return nil 6165 } 6166 6167 shape, ok := value.(map[string]interface{}) 6168 if !ok { 6169 return fmt.Errorf("unexpected JSON type %v", value) 6170 } 6171 6172 var sv *StartContinuousExportOutput 6173 if *v == nil { 6174 sv = &StartContinuousExportOutput{} 6175 } else { 6176 sv = *v 6177 } 6178 6179 for key, value := range shape { 6180 switch key { 6181 case "dataSource": 6182 if value != nil { 6183 jtv, ok := value.(string) 6184 if !ok { 6185 return fmt.Errorf("expected DataSource to be of type string, got %T instead", value) 6186 } 6187 sv.DataSource = types.DataSource(jtv) 6188 } 6189 6190 case "exportId": 6191 if value != nil { 6192 jtv, ok := value.(string) 6193 if !ok { 6194 return fmt.Errorf("expected ConfigurationsExportId to be of type string, got %T instead", value) 6195 } 6196 sv.ExportId = ptr.String(jtv) 6197 } 6198 6199 case "s3Bucket": 6200 if value != nil { 6201 jtv, ok := value.(string) 6202 if !ok { 6203 return fmt.Errorf("expected S3Bucket to be of type string, got %T instead", value) 6204 } 6205 sv.S3Bucket = ptr.String(jtv) 6206 } 6207 6208 case "schemaStorageConfig": 6209 if err := awsAwsjson11_deserializeDocumentSchemaStorageConfig(&sv.SchemaStorageConfig, value); err != nil { 6210 return err 6211 } 6212 6213 case "startTime": 6214 if value != nil { 6215 jtv, ok := value.(json.Number) 6216 if !ok { 6217 return fmt.Errorf("expected TimeStamp to be json.Number, got %T instead", value) 6218 } 6219 f64, err := jtv.Float64() 6220 if err != nil { 6221 return err 6222 } 6223 sv.StartTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 6224 } 6225 6226 default: 6227 _, _ = key, value 6228 6229 } 6230 } 6231 *v = sv 6232 return nil 6233} 6234 6235func awsAwsjson11_deserializeOpDocumentStartDataCollectionByAgentIdsOutput(v **StartDataCollectionByAgentIdsOutput, value interface{}) error { 6236 if v == nil { 6237 return fmt.Errorf("unexpected nil of type %T", v) 6238 } 6239 if value == nil { 6240 return nil 6241 } 6242 6243 shape, ok := value.(map[string]interface{}) 6244 if !ok { 6245 return fmt.Errorf("unexpected JSON type %v", value) 6246 } 6247 6248 var sv *StartDataCollectionByAgentIdsOutput 6249 if *v == nil { 6250 sv = &StartDataCollectionByAgentIdsOutput{} 6251 } else { 6252 sv = *v 6253 } 6254 6255 for key, value := range shape { 6256 switch key { 6257 case "agentsConfigurationStatus": 6258 if err := awsAwsjson11_deserializeDocumentAgentConfigurationStatusList(&sv.AgentsConfigurationStatus, value); err != nil { 6259 return err 6260 } 6261 6262 default: 6263 _, _ = key, value 6264 6265 } 6266 } 6267 *v = sv 6268 return nil 6269} 6270 6271func awsAwsjson11_deserializeOpDocumentStartExportTaskOutput(v **StartExportTaskOutput, value interface{}) error { 6272 if v == nil { 6273 return fmt.Errorf("unexpected nil of type %T", v) 6274 } 6275 if value == nil { 6276 return nil 6277 } 6278 6279 shape, ok := value.(map[string]interface{}) 6280 if !ok { 6281 return fmt.Errorf("unexpected JSON type %v", value) 6282 } 6283 6284 var sv *StartExportTaskOutput 6285 if *v == nil { 6286 sv = &StartExportTaskOutput{} 6287 } else { 6288 sv = *v 6289 } 6290 6291 for key, value := range shape { 6292 switch key { 6293 case "exportId": 6294 if value != nil { 6295 jtv, ok := value.(string) 6296 if !ok { 6297 return fmt.Errorf("expected ConfigurationsExportId to be of type string, got %T instead", value) 6298 } 6299 sv.ExportId = ptr.String(jtv) 6300 } 6301 6302 default: 6303 _, _ = key, value 6304 6305 } 6306 } 6307 *v = sv 6308 return nil 6309} 6310 6311func awsAwsjson11_deserializeOpDocumentStartImportTaskOutput(v **StartImportTaskOutput, value interface{}) error { 6312 if v == nil { 6313 return fmt.Errorf("unexpected nil of type %T", v) 6314 } 6315 if value == nil { 6316 return nil 6317 } 6318 6319 shape, ok := value.(map[string]interface{}) 6320 if !ok { 6321 return fmt.Errorf("unexpected JSON type %v", value) 6322 } 6323 6324 var sv *StartImportTaskOutput 6325 if *v == nil { 6326 sv = &StartImportTaskOutput{} 6327 } else { 6328 sv = *v 6329 } 6330 6331 for key, value := range shape { 6332 switch key { 6333 case "task": 6334 if err := awsAwsjson11_deserializeDocumentImportTask(&sv.Task, value); err != nil { 6335 return err 6336 } 6337 6338 default: 6339 _, _ = key, value 6340 6341 } 6342 } 6343 *v = sv 6344 return nil 6345} 6346 6347func awsAwsjson11_deserializeOpDocumentStopContinuousExportOutput(v **StopContinuousExportOutput, value interface{}) error { 6348 if v == nil { 6349 return fmt.Errorf("unexpected nil of type %T", v) 6350 } 6351 if value == nil { 6352 return nil 6353 } 6354 6355 shape, ok := value.(map[string]interface{}) 6356 if !ok { 6357 return fmt.Errorf("unexpected JSON type %v", value) 6358 } 6359 6360 var sv *StopContinuousExportOutput 6361 if *v == nil { 6362 sv = &StopContinuousExportOutput{} 6363 } else { 6364 sv = *v 6365 } 6366 6367 for key, value := range shape { 6368 switch key { 6369 case "startTime": 6370 if value != nil { 6371 jtv, ok := value.(json.Number) 6372 if !ok { 6373 return fmt.Errorf("expected TimeStamp to be json.Number, got %T instead", value) 6374 } 6375 f64, err := jtv.Float64() 6376 if err != nil { 6377 return err 6378 } 6379 sv.StartTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 6380 } 6381 6382 case "stopTime": 6383 if value != nil { 6384 jtv, ok := value.(json.Number) 6385 if !ok { 6386 return fmt.Errorf("expected TimeStamp to be json.Number, got %T instead", value) 6387 } 6388 f64, err := jtv.Float64() 6389 if err != nil { 6390 return err 6391 } 6392 sv.StopTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 6393 } 6394 6395 default: 6396 _, _ = key, value 6397 6398 } 6399 } 6400 *v = sv 6401 return nil 6402} 6403 6404func awsAwsjson11_deserializeOpDocumentStopDataCollectionByAgentIdsOutput(v **StopDataCollectionByAgentIdsOutput, value interface{}) error { 6405 if v == nil { 6406 return fmt.Errorf("unexpected nil of type %T", v) 6407 } 6408 if value == nil { 6409 return nil 6410 } 6411 6412 shape, ok := value.(map[string]interface{}) 6413 if !ok { 6414 return fmt.Errorf("unexpected JSON type %v", value) 6415 } 6416 6417 var sv *StopDataCollectionByAgentIdsOutput 6418 if *v == nil { 6419 sv = &StopDataCollectionByAgentIdsOutput{} 6420 } else { 6421 sv = *v 6422 } 6423 6424 for key, value := range shape { 6425 switch key { 6426 case "agentsConfigurationStatus": 6427 if err := awsAwsjson11_deserializeDocumentAgentConfigurationStatusList(&sv.AgentsConfigurationStatus, value); err != nil { 6428 return err 6429 } 6430 6431 default: 6432 _, _ = key, value 6433 6434 } 6435 } 6436 *v = sv 6437 return nil 6438} 6439 6440func awsAwsjson11_deserializeOpDocumentUpdateApplicationOutput(v **UpdateApplicationOutput, value interface{}) error { 6441 if v == nil { 6442 return fmt.Errorf("unexpected nil of type %T", v) 6443 } 6444 if value == nil { 6445 return nil 6446 } 6447 6448 shape, ok := value.(map[string]interface{}) 6449 if !ok { 6450 return fmt.Errorf("unexpected JSON type %v", value) 6451 } 6452 6453 var sv *UpdateApplicationOutput 6454 if *v == nil { 6455 sv = &UpdateApplicationOutput{} 6456 } else { 6457 sv = *v 6458 } 6459 6460 for key, value := range shape { 6461 switch key { 6462 default: 6463 _, _ = key, value 6464 6465 } 6466 } 6467 *v = sv 6468 return nil 6469} 6470