1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package iotthingsgraph 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/iotthingsgraph/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_deserializeOpAssociateEntityToThing struct { 23} 24 25func (*awsAwsjson11_deserializeOpAssociateEntityToThing) ID() string { 26 return "OperationDeserializer" 27} 28 29func (m *awsAwsjson11_deserializeOpAssociateEntityToThing) 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_deserializeOpErrorAssociateEntityToThing(response, &metadata) 44 } 45 output := &AssociateEntityToThingOutput{} 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_deserializeOpDocumentAssociateEntityToThingOutput(&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_deserializeOpErrorAssociateEntityToThing(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("InternalFailureException", errorCode): 121 return awsAwsjson11_deserializeErrorInternalFailureException(response, errorBody) 122 123 case strings.EqualFold("InvalidRequestException", errorCode): 124 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 125 126 case strings.EqualFold("ResourceNotFoundException", errorCode): 127 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 128 129 case strings.EqualFold("ThrottlingException", errorCode): 130 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 131 132 default: 133 genericError := &smithy.GenericAPIError{ 134 Code: errorCode, 135 Message: errorMessage, 136 } 137 return genericError 138 139 } 140} 141 142type awsAwsjson11_deserializeOpCreateFlowTemplate struct { 143} 144 145func (*awsAwsjson11_deserializeOpCreateFlowTemplate) ID() string { 146 return "OperationDeserializer" 147} 148 149func (m *awsAwsjson11_deserializeOpCreateFlowTemplate) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 150 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 151) { 152 out, metadata, err = next.HandleDeserialize(ctx, in) 153 if err != nil { 154 return out, metadata, err 155 } 156 157 response, ok := out.RawResponse.(*smithyhttp.Response) 158 if !ok { 159 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 160 } 161 162 if response.StatusCode < 200 || response.StatusCode >= 300 { 163 return out, metadata, awsAwsjson11_deserializeOpErrorCreateFlowTemplate(response, &metadata) 164 } 165 output := &CreateFlowTemplateOutput{} 166 out.Result = output 167 168 var buff [1024]byte 169 ringBuffer := smithyio.NewRingBuffer(buff[:]) 170 171 body := io.TeeReader(response.Body, ringBuffer) 172 decoder := json.NewDecoder(body) 173 decoder.UseNumber() 174 var shape interface{} 175 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 176 var snapshot bytes.Buffer 177 io.Copy(&snapshot, ringBuffer) 178 err = &smithy.DeserializationError{ 179 Err: fmt.Errorf("failed to decode response body, %w", err), 180 Snapshot: snapshot.Bytes(), 181 } 182 return out, metadata, err 183 } 184 185 err = awsAwsjson11_deserializeOpDocumentCreateFlowTemplateOutput(&output, shape) 186 if err != nil { 187 var snapshot bytes.Buffer 188 io.Copy(&snapshot, ringBuffer) 189 err = &smithy.DeserializationError{ 190 Err: fmt.Errorf("failed to decode response body, %w", err), 191 Snapshot: snapshot.Bytes(), 192 } 193 return out, metadata, err 194 } 195 196 return out, metadata, err 197} 198 199func awsAwsjson11_deserializeOpErrorCreateFlowTemplate(response *smithyhttp.Response, metadata *middleware.Metadata) error { 200 var errorBuffer bytes.Buffer 201 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 202 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 203 } 204 errorBody := bytes.NewReader(errorBuffer.Bytes()) 205 206 errorCode := "UnknownError" 207 errorMessage := errorCode 208 209 code := response.Header.Get("X-Amzn-ErrorType") 210 if len(code) != 0 { 211 errorCode = restjson.SanitizeErrorCode(code) 212 } 213 214 var buff [1024]byte 215 ringBuffer := smithyio.NewRingBuffer(buff[:]) 216 217 body := io.TeeReader(errorBody, ringBuffer) 218 decoder := json.NewDecoder(body) 219 decoder.UseNumber() 220 code, message, err := restjson.GetErrorInfo(decoder) 221 if err != nil { 222 var snapshot bytes.Buffer 223 io.Copy(&snapshot, ringBuffer) 224 err = &smithy.DeserializationError{ 225 Err: fmt.Errorf("failed to decode response body, %w", err), 226 Snapshot: snapshot.Bytes(), 227 } 228 return err 229 } 230 231 errorBody.Seek(0, io.SeekStart) 232 if len(code) != 0 { 233 errorCode = restjson.SanitizeErrorCode(code) 234 } 235 if len(message) != 0 { 236 errorMessage = message 237 } 238 239 switch { 240 case strings.EqualFold("InternalFailureException", errorCode): 241 return awsAwsjson11_deserializeErrorInternalFailureException(response, errorBody) 242 243 case strings.EqualFold("InvalidRequestException", errorCode): 244 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 245 246 case strings.EqualFold("LimitExceededException", errorCode): 247 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 248 249 case strings.EqualFold("ResourceAlreadyExistsException", errorCode): 250 return awsAwsjson11_deserializeErrorResourceAlreadyExistsException(response, errorBody) 251 252 case strings.EqualFold("ThrottlingException", errorCode): 253 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 254 255 default: 256 genericError := &smithy.GenericAPIError{ 257 Code: errorCode, 258 Message: errorMessage, 259 } 260 return genericError 261 262 } 263} 264 265type awsAwsjson11_deserializeOpCreateSystemInstance struct { 266} 267 268func (*awsAwsjson11_deserializeOpCreateSystemInstance) ID() string { 269 return "OperationDeserializer" 270} 271 272func (m *awsAwsjson11_deserializeOpCreateSystemInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 273 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 274) { 275 out, metadata, err = next.HandleDeserialize(ctx, in) 276 if err != nil { 277 return out, metadata, err 278 } 279 280 response, ok := out.RawResponse.(*smithyhttp.Response) 281 if !ok { 282 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 283 } 284 285 if response.StatusCode < 200 || response.StatusCode >= 300 { 286 return out, metadata, awsAwsjson11_deserializeOpErrorCreateSystemInstance(response, &metadata) 287 } 288 output := &CreateSystemInstanceOutput{} 289 out.Result = output 290 291 var buff [1024]byte 292 ringBuffer := smithyio.NewRingBuffer(buff[:]) 293 294 body := io.TeeReader(response.Body, ringBuffer) 295 decoder := json.NewDecoder(body) 296 decoder.UseNumber() 297 var shape interface{} 298 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 299 var snapshot bytes.Buffer 300 io.Copy(&snapshot, ringBuffer) 301 err = &smithy.DeserializationError{ 302 Err: fmt.Errorf("failed to decode response body, %w", err), 303 Snapshot: snapshot.Bytes(), 304 } 305 return out, metadata, err 306 } 307 308 err = awsAwsjson11_deserializeOpDocumentCreateSystemInstanceOutput(&output, shape) 309 if err != nil { 310 var snapshot bytes.Buffer 311 io.Copy(&snapshot, ringBuffer) 312 err = &smithy.DeserializationError{ 313 Err: fmt.Errorf("failed to decode response body, %w", err), 314 Snapshot: snapshot.Bytes(), 315 } 316 return out, metadata, err 317 } 318 319 return out, metadata, err 320} 321 322func awsAwsjson11_deserializeOpErrorCreateSystemInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error { 323 var errorBuffer bytes.Buffer 324 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 325 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 326 } 327 errorBody := bytes.NewReader(errorBuffer.Bytes()) 328 329 errorCode := "UnknownError" 330 errorMessage := errorCode 331 332 code := response.Header.Get("X-Amzn-ErrorType") 333 if len(code) != 0 { 334 errorCode = restjson.SanitizeErrorCode(code) 335 } 336 337 var buff [1024]byte 338 ringBuffer := smithyio.NewRingBuffer(buff[:]) 339 340 body := io.TeeReader(errorBody, ringBuffer) 341 decoder := json.NewDecoder(body) 342 decoder.UseNumber() 343 code, message, err := restjson.GetErrorInfo(decoder) 344 if err != nil { 345 var snapshot bytes.Buffer 346 io.Copy(&snapshot, ringBuffer) 347 err = &smithy.DeserializationError{ 348 Err: fmt.Errorf("failed to decode response body, %w", err), 349 Snapshot: snapshot.Bytes(), 350 } 351 return err 352 } 353 354 errorBody.Seek(0, io.SeekStart) 355 if len(code) != 0 { 356 errorCode = restjson.SanitizeErrorCode(code) 357 } 358 if len(message) != 0 { 359 errorMessage = message 360 } 361 362 switch { 363 case strings.EqualFold("InternalFailureException", errorCode): 364 return awsAwsjson11_deserializeErrorInternalFailureException(response, errorBody) 365 366 case strings.EqualFold("InvalidRequestException", errorCode): 367 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 368 369 case strings.EqualFold("LimitExceededException", errorCode): 370 return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody) 371 372 case strings.EqualFold("ResourceAlreadyExistsException", errorCode): 373 return awsAwsjson11_deserializeErrorResourceAlreadyExistsException(response, errorBody) 374 375 case strings.EqualFold("ThrottlingException", errorCode): 376 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 377 378 default: 379 genericError := &smithy.GenericAPIError{ 380 Code: errorCode, 381 Message: errorMessage, 382 } 383 return genericError 384 385 } 386} 387 388type awsAwsjson11_deserializeOpCreateSystemTemplate struct { 389} 390 391func (*awsAwsjson11_deserializeOpCreateSystemTemplate) ID() string { 392 return "OperationDeserializer" 393} 394 395func (m *awsAwsjson11_deserializeOpCreateSystemTemplate) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 396 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 397) { 398 out, metadata, err = next.HandleDeserialize(ctx, in) 399 if err != nil { 400 return out, metadata, err 401 } 402 403 response, ok := out.RawResponse.(*smithyhttp.Response) 404 if !ok { 405 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 406 } 407 408 if response.StatusCode < 200 || response.StatusCode >= 300 { 409 return out, metadata, awsAwsjson11_deserializeOpErrorCreateSystemTemplate(response, &metadata) 410 } 411 output := &CreateSystemTemplateOutput{} 412 out.Result = output 413 414 var buff [1024]byte 415 ringBuffer := smithyio.NewRingBuffer(buff[:]) 416 417 body := io.TeeReader(response.Body, ringBuffer) 418 decoder := json.NewDecoder(body) 419 decoder.UseNumber() 420 var shape interface{} 421 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 422 var snapshot bytes.Buffer 423 io.Copy(&snapshot, ringBuffer) 424 err = &smithy.DeserializationError{ 425 Err: fmt.Errorf("failed to decode response body, %w", err), 426 Snapshot: snapshot.Bytes(), 427 } 428 return out, metadata, err 429 } 430 431 err = awsAwsjson11_deserializeOpDocumentCreateSystemTemplateOutput(&output, shape) 432 if err != nil { 433 var snapshot bytes.Buffer 434 io.Copy(&snapshot, ringBuffer) 435 err = &smithy.DeserializationError{ 436 Err: fmt.Errorf("failed to decode response body, %w", err), 437 Snapshot: snapshot.Bytes(), 438 } 439 return out, metadata, err 440 } 441 442 return out, metadata, err 443} 444 445func awsAwsjson11_deserializeOpErrorCreateSystemTemplate(response *smithyhttp.Response, metadata *middleware.Metadata) error { 446 var errorBuffer bytes.Buffer 447 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 448 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 449 } 450 errorBody := bytes.NewReader(errorBuffer.Bytes()) 451 452 errorCode := "UnknownError" 453 errorMessage := errorCode 454 455 code := response.Header.Get("X-Amzn-ErrorType") 456 if len(code) != 0 { 457 errorCode = restjson.SanitizeErrorCode(code) 458 } 459 460 var buff [1024]byte 461 ringBuffer := smithyio.NewRingBuffer(buff[:]) 462 463 body := io.TeeReader(errorBody, ringBuffer) 464 decoder := json.NewDecoder(body) 465 decoder.UseNumber() 466 code, message, err := restjson.GetErrorInfo(decoder) 467 if err != nil { 468 var snapshot bytes.Buffer 469 io.Copy(&snapshot, ringBuffer) 470 err = &smithy.DeserializationError{ 471 Err: fmt.Errorf("failed to decode response body, %w", err), 472 Snapshot: snapshot.Bytes(), 473 } 474 return err 475 } 476 477 errorBody.Seek(0, io.SeekStart) 478 if len(code) != 0 { 479 errorCode = restjson.SanitizeErrorCode(code) 480 } 481 if len(message) != 0 { 482 errorMessage = message 483 } 484 485 switch { 486 case strings.EqualFold("InternalFailureException", errorCode): 487 return awsAwsjson11_deserializeErrorInternalFailureException(response, errorBody) 488 489 case strings.EqualFold("InvalidRequestException", errorCode): 490 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 491 492 case strings.EqualFold("ResourceAlreadyExistsException", errorCode): 493 return awsAwsjson11_deserializeErrorResourceAlreadyExistsException(response, errorBody) 494 495 case strings.EqualFold("ThrottlingException", errorCode): 496 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 497 498 default: 499 genericError := &smithy.GenericAPIError{ 500 Code: errorCode, 501 Message: errorMessage, 502 } 503 return genericError 504 505 } 506} 507 508type awsAwsjson11_deserializeOpDeleteFlowTemplate struct { 509} 510 511func (*awsAwsjson11_deserializeOpDeleteFlowTemplate) ID() string { 512 return "OperationDeserializer" 513} 514 515func (m *awsAwsjson11_deserializeOpDeleteFlowTemplate) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 516 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 517) { 518 out, metadata, err = next.HandleDeserialize(ctx, in) 519 if err != nil { 520 return out, metadata, err 521 } 522 523 response, ok := out.RawResponse.(*smithyhttp.Response) 524 if !ok { 525 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 526 } 527 528 if response.StatusCode < 200 || response.StatusCode >= 300 { 529 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteFlowTemplate(response, &metadata) 530 } 531 output := &DeleteFlowTemplateOutput{} 532 out.Result = output 533 534 var buff [1024]byte 535 ringBuffer := smithyio.NewRingBuffer(buff[:]) 536 537 body := io.TeeReader(response.Body, ringBuffer) 538 decoder := json.NewDecoder(body) 539 decoder.UseNumber() 540 var shape interface{} 541 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 542 var snapshot bytes.Buffer 543 io.Copy(&snapshot, ringBuffer) 544 err = &smithy.DeserializationError{ 545 Err: fmt.Errorf("failed to decode response body, %w", err), 546 Snapshot: snapshot.Bytes(), 547 } 548 return out, metadata, err 549 } 550 551 err = awsAwsjson11_deserializeOpDocumentDeleteFlowTemplateOutput(&output, shape) 552 if err != nil { 553 var snapshot bytes.Buffer 554 io.Copy(&snapshot, ringBuffer) 555 err = &smithy.DeserializationError{ 556 Err: fmt.Errorf("failed to decode response body, %w", err), 557 Snapshot: snapshot.Bytes(), 558 } 559 return out, metadata, err 560 } 561 562 return out, metadata, err 563} 564 565func awsAwsjson11_deserializeOpErrorDeleteFlowTemplate(response *smithyhttp.Response, metadata *middleware.Metadata) error { 566 var errorBuffer bytes.Buffer 567 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 568 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 569 } 570 errorBody := bytes.NewReader(errorBuffer.Bytes()) 571 572 errorCode := "UnknownError" 573 errorMessage := errorCode 574 575 code := response.Header.Get("X-Amzn-ErrorType") 576 if len(code) != 0 { 577 errorCode = restjson.SanitizeErrorCode(code) 578 } 579 580 var buff [1024]byte 581 ringBuffer := smithyio.NewRingBuffer(buff[:]) 582 583 body := io.TeeReader(errorBody, ringBuffer) 584 decoder := json.NewDecoder(body) 585 decoder.UseNumber() 586 code, message, err := restjson.GetErrorInfo(decoder) 587 if err != nil { 588 var snapshot bytes.Buffer 589 io.Copy(&snapshot, ringBuffer) 590 err = &smithy.DeserializationError{ 591 Err: fmt.Errorf("failed to decode response body, %w", err), 592 Snapshot: snapshot.Bytes(), 593 } 594 return err 595 } 596 597 errorBody.Seek(0, io.SeekStart) 598 if len(code) != 0 { 599 errorCode = restjson.SanitizeErrorCode(code) 600 } 601 if len(message) != 0 { 602 errorMessage = message 603 } 604 605 switch { 606 case strings.EqualFold("InternalFailureException", errorCode): 607 return awsAwsjson11_deserializeErrorInternalFailureException(response, errorBody) 608 609 case strings.EqualFold("InvalidRequestException", errorCode): 610 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 611 612 case strings.EqualFold("ResourceInUseException", errorCode): 613 return awsAwsjson11_deserializeErrorResourceInUseException(response, errorBody) 614 615 case strings.EqualFold("ThrottlingException", errorCode): 616 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 617 618 default: 619 genericError := &smithy.GenericAPIError{ 620 Code: errorCode, 621 Message: errorMessage, 622 } 623 return genericError 624 625 } 626} 627 628type awsAwsjson11_deserializeOpDeleteNamespace struct { 629} 630 631func (*awsAwsjson11_deserializeOpDeleteNamespace) ID() string { 632 return "OperationDeserializer" 633} 634 635func (m *awsAwsjson11_deserializeOpDeleteNamespace) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 636 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 637) { 638 out, metadata, err = next.HandleDeserialize(ctx, in) 639 if err != nil { 640 return out, metadata, err 641 } 642 643 response, ok := out.RawResponse.(*smithyhttp.Response) 644 if !ok { 645 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 646 } 647 648 if response.StatusCode < 200 || response.StatusCode >= 300 { 649 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteNamespace(response, &metadata) 650 } 651 output := &DeleteNamespaceOutput{} 652 out.Result = output 653 654 var buff [1024]byte 655 ringBuffer := smithyio.NewRingBuffer(buff[:]) 656 657 body := io.TeeReader(response.Body, ringBuffer) 658 decoder := json.NewDecoder(body) 659 decoder.UseNumber() 660 var shape interface{} 661 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 662 var snapshot bytes.Buffer 663 io.Copy(&snapshot, ringBuffer) 664 err = &smithy.DeserializationError{ 665 Err: fmt.Errorf("failed to decode response body, %w", err), 666 Snapshot: snapshot.Bytes(), 667 } 668 return out, metadata, err 669 } 670 671 err = awsAwsjson11_deserializeOpDocumentDeleteNamespaceOutput(&output, shape) 672 if err != nil { 673 var snapshot bytes.Buffer 674 io.Copy(&snapshot, ringBuffer) 675 err = &smithy.DeserializationError{ 676 Err: fmt.Errorf("failed to decode response body, %w", err), 677 Snapshot: snapshot.Bytes(), 678 } 679 return out, metadata, err 680 } 681 682 return out, metadata, err 683} 684 685func awsAwsjson11_deserializeOpErrorDeleteNamespace(response *smithyhttp.Response, metadata *middleware.Metadata) error { 686 var errorBuffer bytes.Buffer 687 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 688 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 689 } 690 errorBody := bytes.NewReader(errorBuffer.Bytes()) 691 692 errorCode := "UnknownError" 693 errorMessage := errorCode 694 695 code := response.Header.Get("X-Amzn-ErrorType") 696 if len(code) != 0 { 697 errorCode = restjson.SanitizeErrorCode(code) 698 } 699 700 var buff [1024]byte 701 ringBuffer := smithyio.NewRingBuffer(buff[:]) 702 703 body := io.TeeReader(errorBody, ringBuffer) 704 decoder := json.NewDecoder(body) 705 decoder.UseNumber() 706 code, message, err := restjson.GetErrorInfo(decoder) 707 if err != nil { 708 var snapshot bytes.Buffer 709 io.Copy(&snapshot, ringBuffer) 710 err = &smithy.DeserializationError{ 711 Err: fmt.Errorf("failed to decode response body, %w", err), 712 Snapshot: snapshot.Bytes(), 713 } 714 return err 715 } 716 717 errorBody.Seek(0, io.SeekStart) 718 if len(code) != 0 { 719 errorCode = restjson.SanitizeErrorCode(code) 720 } 721 if len(message) != 0 { 722 errorMessage = message 723 } 724 725 switch { 726 case strings.EqualFold("InternalFailureException", errorCode): 727 return awsAwsjson11_deserializeErrorInternalFailureException(response, errorBody) 728 729 case strings.EqualFold("ThrottlingException", errorCode): 730 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 731 732 default: 733 genericError := &smithy.GenericAPIError{ 734 Code: errorCode, 735 Message: errorMessage, 736 } 737 return genericError 738 739 } 740} 741 742type awsAwsjson11_deserializeOpDeleteSystemInstance struct { 743} 744 745func (*awsAwsjson11_deserializeOpDeleteSystemInstance) ID() string { 746 return "OperationDeserializer" 747} 748 749func (m *awsAwsjson11_deserializeOpDeleteSystemInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 750 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 751) { 752 out, metadata, err = next.HandleDeserialize(ctx, in) 753 if err != nil { 754 return out, metadata, err 755 } 756 757 response, ok := out.RawResponse.(*smithyhttp.Response) 758 if !ok { 759 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 760 } 761 762 if response.StatusCode < 200 || response.StatusCode >= 300 { 763 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteSystemInstance(response, &metadata) 764 } 765 output := &DeleteSystemInstanceOutput{} 766 out.Result = output 767 768 var buff [1024]byte 769 ringBuffer := smithyio.NewRingBuffer(buff[:]) 770 771 body := io.TeeReader(response.Body, ringBuffer) 772 decoder := json.NewDecoder(body) 773 decoder.UseNumber() 774 var shape interface{} 775 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 776 var snapshot bytes.Buffer 777 io.Copy(&snapshot, ringBuffer) 778 err = &smithy.DeserializationError{ 779 Err: fmt.Errorf("failed to decode response body, %w", err), 780 Snapshot: snapshot.Bytes(), 781 } 782 return out, metadata, err 783 } 784 785 err = awsAwsjson11_deserializeOpDocumentDeleteSystemInstanceOutput(&output, shape) 786 if err != nil { 787 var snapshot bytes.Buffer 788 io.Copy(&snapshot, ringBuffer) 789 err = &smithy.DeserializationError{ 790 Err: fmt.Errorf("failed to decode response body, %w", err), 791 Snapshot: snapshot.Bytes(), 792 } 793 return out, metadata, err 794 } 795 796 return out, metadata, err 797} 798 799func awsAwsjson11_deserializeOpErrorDeleteSystemInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error { 800 var errorBuffer bytes.Buffer 801 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 802 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 803 } 804 errorBody := bytes.NewReader(errorBuffer.Bytes()) 805 806 errorCode := "UnknownError" 807 errorMessage := errorCode 808 809 code := response.Header.Get("X-Amzn-ErrorType") 810 if len(code) != 0 { 811 errorCode = restjson.SanitizeErrorCode(code) 812 } 813 814 var buff [1024]byte 815 ringBuffer := smithyio.NewRingBuffer(buff[:]) 816 817 body := io.TeeReader(errorBody, ringBuffer) 818 decoder := json.NewDecoder(body) 819 decoder.UseNumber() 820 code, message, err := restjson.GetErrorInfo(decoder) 821 if err != nil { 822 var snapshot bytes.Buffer 823 io.Copy(&snapshot, ringBuffer) 824 err = &smithy.DeserializationError{ 825 Err: fmt.Errorf("failed to decode response body, %w", err), 826 Snapshot: snapshot.Bytes(), 827 } 828 return err 829 } 830 831 errorBody.Seek(0, io.SeekStart) 832 if len(code) != 0 { 833 errorCode = restjson.SanitizeErrorCode(code) 834 } 835 if len(message) != 0 { 836 errorMessage = message 837 } 838 839 switch { 840 case strings.EqualFold("InternalFailureException", errorCode): 841 return awsAwsjson11_deserializeErrorInternalFailureException(response, errorBody) 842 843 case strings.EqualFold("InvalidRequestException", errorCode): 844 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 845 846 case strings.EqualFold("ResourceInUseException", errorCode): 847 return awsAwsjson11_deserializeErrorResourceInUseException(response, errorBody) 848 849 case strings.EqualFold("ThrottlingException", errorCode): 850 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 851 852 default: 853 genericError := &smithy.GenericAPIError{ 854 Code: errorCode, 855 Message: errorMessage, 856 } 857 return genericError 858 859 } 860} 861 862type awsAwsjson11_deserializeOpDeleteSystemTemplate struct { 863} 864 865func (*awsAwsjson11_deserializeOpDeleteSystemTemplate) ID() string { 866 return "OperationDeserializer" 867} 868 869func (m *awsAwsjson11_deserializeOpDeleteSystemTemplate) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 870 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 871) { 872 out, metadata, err = next.HandleDeserialize(ctx, in) 873 if err != nil { 874 return out, metadata, err 875 } 876 877 response, ok := out.RawResponse.(*smithyhttp.Response) 878 if !ok { 879 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 880 } 881 882 if response.StatusCode < 200 || response.StatusCode >= 300 { 883 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteSystemTemplate(response, &metadata) 884 } 885 output := &DeleteSystemTemplateOutput{} 886 out.Result = output 887 888 var buff [1024]byte 889 ringBuffer := smithyio.NewRingBuffer(buff[:]) 890 891 body := io.TeeReader(response.Body, ringBuffer) 892 decoder := json.NewDecoder(body) 893 decoder.UseNumber() 894 var shape interface{} 895 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 896 var snapshot bytes.Buffer 897 io.Copy(&snapshot, ringBuffer) 898 err = &smithy.DeserializationError{ 899 Err: fmt.Errorf("failed to decode response body, %w", err), 900 Snapshot: snapshot.Bytes(), 901 } 902 return out, metadata, err 903 } 904 905 err = awsAwsjson11_deserializeOpDocumentDeleteSystemTemplateOutput(&output, shape) 906 if err != nil { 907 var snapshot bytes.Buffer 908 io.Copy(&snapshot, ringBuffer) 909 err = &smithy.DeserializationError{ 910 Err: fmt.Errorf("failed to decode response body, %w", err), 911 Snapshot: snapshot.Bytes(), 912 } 913 return out, metadata, err 914 } 915 916 return out, metadata, err 917} 918 919func awsAwsjson11_deserializeOpErrorDeleteSystemTemplate(response *smithyhttp.Response, metadata *middleware.Metadata) error { 920 var errorBuffer bytes.Buffer 921 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 922 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 923 } 924 errorBody := bytes.NewReader(errorBuffer.Bytes()) 925 926 errorCode := "UnknownError" 927 errorMessage := errorCode 928 929 code := response.Header.Get("X-Amzn-ErrorType") 930 if len(code) != 0 { 931 errorCode = restjson.SanitizeErrorCode(code) 932 } 933 934 var buff [1024]byte 935 ringBuffer := smithyio.NewRingBuffer(buff[:]) 936 937 body := io.TeeReader(errorBody, ringBuffer) 938 decoder := json.NewDecoder(body) 939 decoder.UseNumber() 940 code, message, err := restjson.GetErrorInfo(decoder) 941 if err != nil { 942 var snapshot bytes.Buffer 943 io.Copy(&snapshot, ringBuffer) 944 err = &smithy.DeserializationError{ 945 Err: fmt.Errorf("failed to decode response body, %w", err), 946 Snapshot: snapshot.Bytes(), 947 } 948 return err 949 } 950 951 errorBody.Seek(0, io.SeekStart) 952 if len(code) != 0 { 953 errorCode = restjson.SanitizeErrorCode(code) 954 } 955 if len(message) != 0 { 956 errorMessage = message 957 } 958 959 switch { 960 case strings.EqualFold("InternalFailureException", errorCode): 961 return awsAwsjson11_deserializeErrorInternalFailureException(response, errorBody) 962 963 case strings.EqualFold("InvalidRequestException", errorCode): 964 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 965 966 case strings.EqualFold("ResourceInUseException", errorCode): 967 return awsAwsjson11_deserializeErrorResourceInUseException(response, errorBody) 968 969 case strings.EqualFold("ThrottlingException", errorCode): 970 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 971 972 default: 973 genericError := &smithy.GenericAPIError{ 974 Code: errorCode, 975 Message: errorMessage, 976 } 977 return genericError 978 979 } 980} 981 982type awsAwsjson11_deserializeOpDeploySystemInstance struct { 983} 984 985func (*awsAwsjson11_deserializeOpDeploySystemInstance) ID() string { 986 return "OperationDeserializer" 987} 988 989func (m *awsAwsjson11_deserializeOpDeploySystemInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 990 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 991) { 992 out, metadata, err = next.HandleDeserialize(ctx, in) 993 if err != nil { 994 return out, metadata, err 995 } 996 997 response, ok := out.RawResponse.(*smithyhttp.Response) 998 if !ok { 999 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1000 } 1001 1002 if response.StatusCode < 200 || response.StatusCode >= 300 { 1003 return out, metadata, awsAwsjson11_deserializeOpErrorDeploySystemInstance(response, &metadata) 1004 } 1005 output := &DeploySystemInstanceOutput{} 1006 out.Result = output 1007 1008 var buff [1024]byte 1009 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1010 1011 body := io.TeeReader(response.Body, ringBuffer) 1012 decoder := json.NewDecoder(body) 1013 decoder.UseNumber() 1014 var shape interface{} 1015 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1016 var snapshot bytes.Buffer 1017 io.Copy(&snapshot, ringBuffer) 1018 err = &smithy.DeserializationError{ 1019 Err: fmt.Errorf("failed to decode response body, %w", err), 1020 Snapshot: snapshot.Bytes(), 1021 } 1022 return out, metadata, err 1023 } 1024 1025 err = awsAwsjson11_deserializeOpDocumentDeploySystemInstanceOutput(&output, shape) 1026 if err != nil { 1027 var snapshot bytes.Buffer 1028 io.Copy(&snapshot, ringBuffer) 1029 err = &smithy.DeserializationError{ 1030 Err: fmt.Errorf("failed to decode response body, %w", err), 1031 Snapshot: snapshot.Bytes(), 1032 } 1033 return out, metadata, err 1034 } 1035 1036 return out, metadata, err 1037} 1038 1039func awsAwsjson11_deserializeOpErrorDeploySystemInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1040 var errorBuffer bytes.Buffer 1041 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1042 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1043 } 1044 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1045 1046 errorCode := "UnknownError" 1047 errorMessage := errorCode 1048 1049 code := response.Header.Get("X-Amzn-ErrorType") 1050 if len(code) != 0 { 1051 errorCode = restjson.SanitizeErrorCode(code) 1052 } 1053 1054 var buff [1024]byte 1055 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1056 1057 body := io.TeeReader(errorBody, ringBuffer) 1058 decoder := json.NewDecoder(body) 1059 decoder.UseNumber() 1060 code, message, err := restjson.GetErrorInfo(decoder) 1061 if err != nil { 1062 var snapshot bytes.Buffer 1063 io.Copy(&snapshot, ringBuffer) 1064 err = &smithy.DeserializationError{ 1065 Err: fmt.Errorf("failed to decode response body, %w", err), 1066 Snapshot: snapshot.Bytes(), 1067 } 1068 return err 1069 } 1070 1071 errorBody.Seek(0, io.SeekStart) 1072 if len(code) != 0 { 1073 errorCode = restjson.SanitizeErrorCode(code) 1074 } 1075 if len(message) != 0 { 1076 errorMessage = message 1077 } 1078 1079 switch { 1080 case strings.EqualFold("InternalFailureException", errorCode): 1081 return awsAwsjson11_deserializeErrorInternalFailureException(response, errorBody) 1082 1083 case strings.EqualFold("InvalidRequestException", errorCode): 1084 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 1085 1086 case strings.EqualFold("ResourceInUseException", errorCode): 1087 return awsAwsjson11_deserializeErrorResourceInUseException(response, errorBody) 1088 1089 case strings.EqualFold("ResourceNotFoundException", errorCode): 1090 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 1091 1092 case strings.EqualFold("ThrottlingException", errorCode): 1093 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 1094 1095 default: 1096 genericError := &smithy.GenericAPIError{ 1097 Code: errorCode, 1098 Message: errorMessage, 1099 } 1100 return genericError 1101 1102 } 1103} 1104 1105type awsAwsjson11_deserializeOpDeprecateFlowTemplate struct { 1106} 1107 1108func (*awsAwsjson11_deserializeOpDeprecateFlowTemplate) ID() string { 1109 return "OperationDeserializer" 1110} 1111 1112func (m *awsAwsjson11_deserializeOpDeprecateFlowTemplate) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1113 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1114) { 1115 out, metadata, err = next.HandleDeserialize(ctx, in) 1116 if err != nil { 1117 return out, metadata, err 1118 } 1119 1120 response, ok := out.RawResponse.(*smithyhttp.Response) 1121 if !ok { 1122 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1123 } 1124 1125 if response.StatusCode < 200 || response.StatusCode >= 300 { 1126 return out, metadata, awsAwsjson11_deserializeOpErrorDeprecateFlowTemplate(response, &metadata) 1127 } 1128 output := &DeprecateFlowTemplateOutput{} 1129 out.Result = output 1130 1131 var buff [1024]byte 1132 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1133 1134 body := io.TeeReader(response.Body, ringBuffer) 1135 decoder := json.NewDecoder(body) 1136 decoder.UseNumber() 1137 var shape interface{} 1138 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1139 var snapshot bytes.Buffer 1140 io.Copy(&snapshot, ringBuffer) 1141 err = &smithy.DeserializationError{ 1142 Err: fmt.Errorf("failed to decode response body, %w", err), 1143 Snapshot: snapshot.Bytes(), 1144 } 1145 return out, metadata, err 1146 } 1147 1148 err = awsAwsjson11_deserializeOpDocumentDeprecateFlowTemplateOutput(&output, shape) 1149 if err != nil { 1150 var snapshot bytes.Buffer 1151 io.Copy(&snapshot, ringBuffer) 1152 err = &smithy.DeserializationError{ 1153 Err: fmt.Errorf("failed to decode response body, %w", err), 1154 Snapshot: snapshot.Bytes(), 1155 } 1156 return out, metadata, err 1157 } 1158 1159 return out, metadata, err 1160} 1161 1162func awsAwsjson11_deserializeOpErrorDeprecateFlowTemplate(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1163 var errorBuffer bytes.Buffer 1164 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1165 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1166 } 1167 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1168 1169 errorCode := "UnknownError" 1170 errorMessage := errorCode 1171 1172 code := response.Header.Get("X-Amzn-ErrorType") 1173 if len(code) != 0 { 1174 errorCode = restjson.SanitizeErrorCode(code) 1175 } 1176 1177 var buff [1024]byte 1178 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1179 1180 body := io.TeeReader(errorBody, ringBuffer) 1181 decoder := json.NewDecoder(body) 1182 decoder.UseNumber() 1183 code, message, err := restjson.GetErrorInfo(decoder) 1184 if err != nil { 1185 var snapshot bytes.Buffer 1186 io.Copy(&snapshot, ringBuffer) 1187 err = &smithy.DeserializationError{ 1188 Err: fmt.Errorf("failed to decode response body, %w", err), 1189 Snapshot: snapshot.Bytes(), 1190 } 1191 return err 1192 } 1193 1194 errorBody.Seek(0, io.SeekStart) 1195 if len(code) != 0 { 1196 errorCode = restjson.SanitizeErrorCode(code) 1197 } 1198 if len(message) != 0 { 1199 errorMessage = message 1200 } 1201 1202 switch { 1203 case strings.EqualFold("InternalFailureException", errorCode): 1204 return awsAwsjson11_deserializeErrorInternalFailureException(response, errorBody) 1205 1206 case strings.EqualFold("InvalidRequestException", errorCode): 1207 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 1208 1209 case strings.EqualFold("ResourceNotFoundException", errorCode): 1210 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 1211 1212 case strings.EqualFold("ThrottlingException", errorCode): 1213 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 1214 1215 default: 1216 genericError := &smithy.GenericAPIError{ 1217 Code: errorCode, 1218 Message: errorMessage, 1219 } 1220 return genericError 1221 1222 } 1223} 1224 1225type awsAwsjson11_deserializeOpDeprecateSystemTemplate struct { 1226} 1227 1228func (*awsAwsjson11_deserializeOpDeprecateSystemTemplate) ID() string { 1229 return "OperationDeserializer" 1230} 1231 1232func (m *awsAwsjson11_deserializeOpDeprecateSystemTemplate) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1233 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1234) { 1235 out, metadata, err = next.HandleDeserialize(ctx, in) 1236 if err != nil { 1237 return out, metadata, err 1238 } 1239 1240 response, ok := out.RawResponse.(*smithyhttp.Response) 1241 if !ok { 1242 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1243 } 1244 1245 if response.StatusCode < 200 || response.StatusCode >= 300 { 1246 return out, metadata, awsAwsjson11_deserializeOpErrorDeprecateSystemTemplate(response, &metadata) 1247 } 1248 output := &DeprecateSystemTemplateOutput{} 1249 out.Result = output 1250 1251 var buff [1024]byte 1252 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1253 1254 body := io.TeeReader(response.Body, ringBuffer) 1255 decoder := json.NewDecoder(body) 1256 decoder.UseNumber() 1257 var shape interface{} 1258 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1259 var snapshot bytes.Buffer 1260 io.Copy(&snapshot, ringBuffer) 1261 err = &smithy.DeserializationError{ 1262 Err: fmt.Errorf("failed to decode response body, %w", err), 1263 Snapshot: snapshot.Bytes(), 1264 } 1265 return out, metadata, err 1266 } 1267 1268 err = awsAwsjson11_deserializeOpDocumentDeprecateSystemTemplateOutput(&output, shape) 1269 if err != nil { 1270 var snapshot bytes.Buffer 1271 io.Copy(&snapshot, ringBuffer) 1272 err = &smithy.DeserializationError{ 1273 Err: fmt.Errorf("failed to decode response body, %w", err), 1274 Snapshot: snapshot.Bytes(), 1275 } 1276 return out, metadata, err 1277 } 1278 1279 return out, metadata, err 1280} 1281 1282func awsAwsjson11_deserializeOpErrorDeprecateSystemTemplate(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1283 var errorBuffer bytes.Buffer 1284 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1285 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1286 } 1287 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1288 1289 errorCode := "UnknownError" 1290 errorMessage := errorCode 1291 1292 code := response.Header.Get("X-Amzn-ErrorType") 1293 if len(code) != 0 { 1294 errorCode = restjson.SanitizeErrorCode(code) 1295 } 1296 1297 var buff [1024]byte 1298 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1299 1300 body := io.TeeReader(errorBody, ringBuffer) 1301 decoder := json.NewDecoder(body) 1302 decoder.UseNumber() 1303 code, message, err := restjson.GetErrorInfo(decoder) 1304 if err != nil { 1305 var snapshot bytes.Buffer 1306 io.Copy(&snapshot, ringBuffer) 1307 err = &smithy.DeserializationError{ 1308 Err: fmt.Errorf("failed to decode response body, %w", err), 1309 Snapshot: snapshot.Bytes(), 1310 } 1311 return err 1312 } 1313 1314 errorBody.Seek(0, io.SeekStart) 1315 if len(code) != 0 { 1316 errorCode = restjson.SanitizeErrorCode(code) 1317 } 1318 if len(message) != 0 { 1319 errorMessage = message 1320 } 1321 1322 switch { 1323 case strings.EqualFold("InternalFailureException", errorCode): 1324 return awsAwsjson11_deserializeErrorInternalFailureException(response, errorBody) 1325 1326 case strings.EqualFold("InvalidRequestException", errorCode): 1327 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 1328 1329 case strings.EqualFold("ResourceNotFoundException", errorCode): 1330 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 1331 1332 case strings.EqualFold("ThrottlingException", errorCode): 1333 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 1334 1335 default: 1336 genericError := &smithy.GenericAPIError{ 1337 Code: errorCode, 1338 Message: errorMessage, 1339 } 1340 return genericError 1341 1342 } 1343} 1344 1345type awsAwsjson11_deserializeOpDescribeNamespace struct { 1346} 1347 1348func (*awsAwsjson11_deserializeOpDescribeNamespace) ID() string { 1349 return "OperationDeserializer" 1350} 1351 1352func (m *awsAwsjson11_deserializeOpDescribeNamespace) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1353 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1354) { 1355 out, metadata, err = next.HandleDeserialize(ctx, in) 1356 if err != nil { 1357 return out, metadata, err 1358 } 1359 1360 response, ok := out.RawResponse.(*smithyhttp.Response) 1361 if !ok { 1362 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1363 } 1364 1365 if response.StatusCode < 200 || response.StatusCode >= 300 { 1366 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeNamespace(response, &metadata) 1367 } 1368 output := &DescribeNamespaceOutput{} 1369 out.Result = output 1370 1371 var buff [1024]byte 1372 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1373 1374 body := io.TeeReader(response.Body, ringBuffer) 1375 decoder := json.NewDecoder(body) 1376 decoder.UseNumber() 1377 var shape interface{} 1378 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1379 var snapshot bytes.Buffer 1380 io.Copy(&snapshot, ringBuffer) 1381 err = &smithy.DeserializationError{ 1382 Err: fmt.Errorf("failed to decode response body, %w", err), 1383 Snapshot: snapshot.Bytes(), 1384 } 1385 return out, metadata, err 1386 } 1387 1388 err = awsAwsjson11_deserializeOpDocumentDescribeNamespaceOutput(&output, shape) 1389 if err != nil { 1390 var snapshot bytes.Buffer 1391 io.Copy(&snapshot, ringBuffer) 1392 err = &smithy.DeserializationError{ 1393 Err: fmt.Errorf("failed to decode response body, %w", err), 1394 Snapshot: snapshot.Bytes(), 1395 } 1396 return out, metadata, err 1397 } 1398 1399 return out, metadata, err 1400} 1401 1402func awsAwsjson11_deserializeOpErrorDescribeNamespace(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1403 var errorBuffer bytes.Buffer 1404 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1405 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1406 } 1407 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1408 1409 errorCode := "UnknownError" 1410 errorMessage := errorCode 1411 1412 code := response.Header.Get("X-Amzn-ErrorType") 1413 if len(code) != 0 { 1414 errorCode = restjson.SanitizeErrorCode(code) 1415 } 1416 1417 var buff [1024]byte 1418 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1419 1420 body := io.TeeReader(errorBody, ringBuffer) 1421 decoder := json.NewDecoder(body) 1422 decoder.UseNumber() 1423 code, message, err := restjson.GetErrorInfo(decoder) 1424 if err != nil { 1425 var snapshot bytes.Buffer 1426 io.Copy(&snapshot, ringBuffer) 1427 err = &smithy.DeserializationError{ 1428 Err: fmt.Errorf("failed to decode response body, %w", err), 1429 Snapshot: snapshot.Bytes(), 1430 } 1431 return err 1432 } 1433 1434 errorBody.Seek(0, io.SeekStart) 1435 if len(code) != 0 { 1436 errorCode = restjson.SanitizeErrorCode(code) 1437 } 1438 if len(message) != 0 { 1439 errorMessage = message 1440 } 1441 1442 switch { 1443 case strings.EqualFold("InternalFailureException", errorCode): 1444 return awsAwsjson11_deserializeErrorInternalFailureException(response, errorBody) 1445 1446 case strings.EqualFold("InvalidRequestException", errorCode): 1447 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 1448 1449 case strings.EqualFold("ResourceNotFoundException", errorCode): 1450 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 1451 1452 case strings.EqualFold("ThrottlingException", errorCode): 1453 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 1454 1455 default: 1456 genericError := &smithy.GenericAPIError{ 1457 Code: errorCode, 1458 Message: errorMessage, 1459 } 1460 return genericError 1461 1462 } 1463} 1464 1465type awsAwsjson11_deserializeOpDissociateEntityFromThing struct { 1466} 1467 1468func (*awsAwsjson11_deserializeOpDissociateEntityFromThing) ID() string { 1469 return "OperationDeserializer" 1470} 1471 1472func (m *awsAwsjson11_deserializeOpDissociateEntityFromThing) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1473 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1474) { 1475 out, metadata, err = next.HandleDeserialize(ctx, in) 1476 if err != nil { 1477 return out, metadata, err 1478 } 1479 1480 response, ok := out.RawResponse.(*smithyhttp.Response) 1481 if !ok { 1482 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1483 } 1484 1485 if response.StatusCode < 200 || response.StatusCode >= 300 { 1486 return out, metadata, awsAwsjson11_deserializeOpErrorDissociateEntityFromThing(response, &metadata) 1487 } 1488 output := &DissociateEntityFromThingOutput{} 1489 out.Result = output 1490 1491 var buff [1024]byte 1492 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1493 1494 body := io.TeeReader(response.Body, ringBuffer) 1495 decoder := json.NewDecoder(body) 1496 decoder.UseNumber() 1497 var shape interface{} 1498 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1499 var snapshot bytes.Buffer 1500 io.Copy(&snapshot, ringBuffer) 1501 err = &smithy.DeserializationError{ 1502 Err: fmt.Errorf("failed to decode response body, %w", err), 1503 Snapshot: snapshot.Bytes(), 1504 } 1505 return out, metadata, err 1506 } 1507 1508 err = awsAwsjson11_deserializeOpDocumentDissociateEntityFromThingOutput(&output, shape) 1509 if err != nil { 1510 var snapshot bytes.Buffer 1511 io.Copy(&snapshot, ringBuffer) 1512 err = &smithy.DeserializationError{ 1513 Err: fmt.Errorf("failed to decode response body, %w", err), 1514 Snapshot: snapshot.Bytes(), 1515 } 1516 return out, metadata, err 1517 } 1518 1519 return out, metadata, err 1520} 1521 1522func awsAwsjson11_deserializeOpErrorDissociateEntityFromThing(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1523 var errorBuffer bytes.Buffer 1524 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1525 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1526 } 1527 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1528 1529 errorCode := "UnknownError" 1530 errorMessage := errorCode 1531 1532 code := response.Header.Get("X-Amzn-ErrorType") 1533 if len(code) != 0 { 1534 errorCode = restjson.SanitizeErrorCode(code) 1535 } 1536 1537 var buff [1024]byte 1538 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1539 1540 body := io.TeeReader(errorBody, ringBuffer) 1541 decoder := json.NewDecoder(body) 1542 decoder.UseNumber() 1543 code, message, err := restjson.GetErrorInfo(decoder) 1544 if err != nil { 1545 var snapshot bytes.Buffer 1546 io.Copy(&snapshot, ringBuffer) 1547 err = &smithy.DeserializationError{ 1548 Err: fmt.Errorf("failed to decode response body, %w", err), 1549 Snapshot: snapshot.Bytes(), 1550 } 1551 return err 1552 } 1553 1554 errorBody.Seek(0, io.SeekStart) 1555 if len(code) != 0 { 1556 errorCode = restjson.SanitizeErrorCode(code) 1557 } 1558 if len(message) != 0 { 1559 errorMessage = message 1560 } 1561 1562 switch { 1563 case strings.EqualFold("InternalFailureException", errorCode): 1564 return awsAwsjson11_deserializeErrorInternalFailureException(response, errorBody) 1565 1566 case strings.EqualFold("InvalidRequestException", errorCode): 1567 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 1568 1569 case strings.EqualFold("ResourceNotFoundException", errorCode): 1570 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 1571 1572 case strings.EqualFold("ThrottlingException", errorCode): 1573 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 1574 1575 default: 1576 genericError := &smithy.GenericAPIError{ 1577 Code: errorCode, 1578 Message: errorMessage, 1579 } 1580 return genericError 1581 1582 } 1583} 1584 1585type awsAwsjson11_deserializeOpGetEntities struct { 1586} 1587 1588func (*awsAwsjson11_deserializeOpGetEntities) ID() string { 1589 return "OperationDeserializer" 1590} 1591 1592func (m *awsAwsjson11_deserializeOpGetEntities) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1593 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1594) { 1595 out, metadata, err = next.HandleDeserialize(ctx, in) 1596 if err != nil { 1597 return out, metadata, err 1598 } 1599 1600 response, ok := out.RawResponse.(*smithyhttp.Response) 1601 if !ok { 1602 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1603 } 1604 1605 if response.StatusCode < 200 || response.StatusCode >= 300 { 1606 return out, metadata, awsAwsjson11_deserializeOpErrorGetEntities(response, &metadata) 1607 } 1608 output := &GetEntitiesOutput{} 1609 out.Result = output 1610 1611 var buff [1024]byte 1612 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1613 1614 body := io.TeeReader(response.Body, ringBuffer) 1615 decoder := json.NewDecoder(body) 1616 decoder.UseNumber() 1617 var shape interface{} 1618 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1619 var snapshot bytes.Buffer 1620 io.Copy(&snapshot, ringBuffer) 1621 err = &smithy.DeserializationError{ 1622 Err: fmt.Errorf("failed to decode response body, %w", err), 1623 Snapshot: snapshot.Bytes(), 1624 } 1625 return out, metadata, err 1626 } 1627 1628 err = awsAwsjson11_deserializeOpDocumentGetEntitiesOutput(&output, shape) 1629 if err != nil { 1630 var snapshot bytes.Buffer 1631 io.Copy(&snapshot, ringBuffer) 1632 err = &smithy.DeserializationError{ 1633 Err: fmt.Errorf("failed to decode response body, %w", err), 1634 Snapshot: snapshot.Bytes(), 1635 } 1636 return out, metadata, err 1637 } 1638 1639 return out, metadata, err 1640} 1641 1642func awsAwsjson11_deserializeOpErrorGetEntities(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1643 var errorBuffer bytes.Buffer 1644 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1645 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1646 } 1647 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1648 1649 errorCode := "UnknownError" 1650 errorMessage := errorCode 1651 1652 code := response.Header.Get("X-Amzn-ErrorType") 1653 if len(code) != 0 { 1654 errorCode = restjson.SanitizeErrorCode(code) 1655 } 1656 1657 var buff [1024]byte 1658 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1659 1660 body := io.TeeReader(errorBody, ringBuffer) 1661 decoder := json.NewDecoder(body) 1662 decoder.UseNumber() 1663 code, message, err := restjson.GetErrorInfo(decoder) 1664 if err != nil { 1665 var snapshot bytes.Buffer 1666 io.Copy(&snapshot, ringBuffer) 1667 err = &smithy.DeserializationError{ 1668 Err: fmt.Errorf("failed to decode response body, %w", err), 1669 Snapshot: snapshot.Bytes(), 1670 } 1671 return err 1672 } 1673 1674 errorBody.Seek(0, io.SeekStart) 1675 if len(code) != 0 { 1676 errorCode = restjson.SanitizeErrorCode(code) 1677 } 1678 if len(message) != 0 { 1679 errorMessage = message 1680 } 1681 1682 switch { 1683 case strings.EqualFold("InternalFailureException", errorCode): 1684 return awsAwsjson11_deserializeErrorInternalFailureException(response, errorBody) 1685 1686 case strings.EqualFold("InvalidRequestException", errorCode): 1687 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 1688 1689 case strings.EqualFold("ResourceNotFoundException", errorCode): 1690 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 1691 1692 case strings.EqualFold("ThrottlingException", errorCode): 1693 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 1694 1695 default: 1696 genericError := &smithy.GenericAPIError{ 1697 Code: errorCode, 1698 Message: errorMessage, 1699 } 1700 return genericError 1701 1702 } 1703} 1704 1705type awsAwsjson11_deserializeOpGetFlowTemplate struct { 1706} 1707 1708func (*awsAwsjson11_deserializeOpGetFlowTemplate) ID() string { 1709 return "OperationDeserializer" 1710} 1711 1712func (m *awsAwsjson11_deserializeOpGetFlowTemplate) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1713 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1714) { 1715 out, metadata, err = next.HandleDeserialize(ctx, in) 1716 if err != nil { 1717 return out, metadata, err 1718 } 1719 1720 response, ok := out.RawResponse.(*smithyhttp.Response) 1721 if !ok { 1722 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1723 } 1724 1725 if response.StatusCode < 200 || response.StatusCode >= 300 { 1726 return out, metadata, awsAwsjson11_deserializeOpErrorGetFlowTemplate(response, &metadata) 1727 } 1728 output := &GetFlowTemplateOutput{} 1729 out.Result = output 1730 1731 var buff [1024]byte 1732 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1733 1734 body := io.TeeReader(response.Body, ringBuffer) 1735 decoder := json.NewDecoder(body) 1736 decoder.UseNumber() 1737 var shape interface{} 1738 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1739 var snapshot bytes.Buffer 1740 io.Copy(&snapshot, ringBuffer) 1741 err = &smithy.DeserializationError{ 1742 Err: fmt.Errorf("failed to decode response body, %w", err), 1743 Snapshot: snapshot.Bytes(), 1744 } 1745 return out, metadata, err 1746 } 1747 1748 err = awsAwsjson11_deserializeOpDocumentGetFlowTemplateOutput(&output, shape) 1749 if err != nil { 1750 var snapshot bytes.Buffer 1751 io.Copy(&snapshot, ringBuffer) 1752 err = &smithy.DeserializationError{ 1753 Err: fmt.Errorf("failed to decode response body, %w", err), 1754 Snapshot: snapshot.Bytes(), 1755 } 1756 return out, metadata, err 1757 } 1758 1759 return out, metadata, err 1760} 1761 1762func awsAwsjson11_deserializeOpErrorGetFlowTemplate(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1763 var errorBuffer bytes.Buffer 1764 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1765 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1766 } 1767 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1768 1769 errorCode := "UnknownError" 1770 errorMessage := errorCode 1771 1772 code := response.Header.Get("X-Amzn-ErrorType") 1773 if len(code) != 0 { 1774 errorCode = restjson.SanitizeErrorCode(code) 1775 } 1776 1777 var buff [1024]byte 1778 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1779 1780 body := io.TeeReader(errorBody, ringBuffer) 1781 decoder := json.NewDecoder(body) 1782 decoder.UseNumber() 1783 code, message, err := restjson.GetErrorInfo(decoder) 1784 if err != nil { 1785 var snapshot bytes.Buffer 1786 io.Copy(&snapshot, ringBuffer) 1787 err = &smithy.DeserializationError{ 1788 Err: fmt.Errorf("failed to decode response body, %w", err), 1789 Snapshot: snapshot.Bytes(), 1790 } 1791 return err 1792 } 1793 1794 errorBody.Seek(0, io.SeekStart) 1795 if len(code) != 0 { 1796 errorCode = restjson.SanitizeErrorCode(code) 1797 } 1798 if len(message) != 0 { 1799 errorMessage = message 1800 } 1801 1802 switch { 1803 case strings.EqualFold("InternalFailureException", errorCode): 1804 return awsAwsjson11_deserializeErrorInternalFailureException(response, errorBody) 1805 1806 case strings.EqualFold("InvalidRequestException", errorCode): 1807 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 1808 1809 case strings.EqualFold("ResourceNotFoundException", errorCode): 1810 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 1811 1812 case strings.EqualFold("ThrottlingException", errorCode): 1813 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 1814 1815 default: 1816 genericError := &smithy.GenericAPIError{ 1817 Code: errorCode, 1818 Message: errorMessage, 1819 } 1820 return genericError 1821 1822 } 1823} 1824 1825type awsAwsjson11_deserializeOpGetFlowTemplateRevisions struct { 1826} 1827 1828func (*awsAwsjson11_deserializeOpGetFlowTemplateRevisions) ID() string { 1829 return "OperationDeserializer" 1830} 1831 1832func (m *awsAwsjson11_deserializeOpGetFlowTemplateRevisions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1833 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1834) { 1835 out, metadata, err = next.HandleDeserialize(ctx, in) 1836 if err != nil { 1837 return out, metadata, err 1838 } 1839 1840 response, ok := out.RawResponse.(*smithyhttp.Response) 1841 if !ok { 1842 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1843 } 1844 1845 if response.StatusCode < 200 || response.StatusCode >= 300 { 1846 return out, metadata, awsAwsjson11_deserializeOpErrorGetFlowTemplateRevisions(response, &metadata) 1847 } 1848 output := &GetFlowTemplateRevisionsOutput{} 1849 out.Result = output 1850 1851 var buff [1024]byte 1852 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1853 1854 body := io.TeeReader(response.Body, ringBuffer) 1855 decoder := json.NewDecoder(body) 1856 decoder.UseNumber() 1857 var shape interface{} 1858 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1859 var snapshot bytes.Buffer 1860 io.Copy(&snapshot, ringBuffer) 1861 err = &smithy.DeserializationError{ 1862 Err: fmt.Errorf("failed to decode response body, %w", err), 1863 Snapshot: snapshot.Bytes(), 1864 } 1865 return out, metadata, err 1866 } 1867 1868 err = awsAwsjson11_deserializeOpDocumentGetFlowTemplateRevisionsOutput(&output, shape) 1869 if err != nil { 1870 var snapshot bytes.Buffer 1871 io.Copy(&snapshot, ringBuffer) 1872 err = &smithy.DeserializationError{ 1873 Err: fmt.Errorf("failed to decode response body, %w", err), 1874 Snapshot: snapshot.Bytes(), 1875 } 1876 return out, metadata, err 1877 } 1878 1879 return out, metadata, err 1880} 1881 1882func awsAwsjson11_deserializeOpErrorGetFlowTemplateRevisions(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1883 var errorBuffer bytes.Buffer 1884 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1885 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1886 } 1887 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1888 1889 errorCode := "UnknownError" 1890 errorMessage := errorCode 1891 1892 code := response.Header.Get("X-Amzn-ErrorType") 1893 if len(code) != 0 { 1894 errorCode = restjson.SanitizeErrorCode(code) 1895 } 1896 1897 var buff [1024]byte 1898 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1899 1900 body := io.TeeReader(errorBody, ringBuffer) 1901 decoder := json.NewDecoder(body) 1902 decoder.UseNumber() 1903 code, message, err := restjson.GetErrorInfo(decoder) 1904 if err != nil { 1905 var snapshot bytes.Buffer 1906 io.Copy(&snapshot, ringBuffer) 1907 err = &smithy.DeserializationError{ 1908 Err: fmt.Errorf("failed to decode response body, %w", err), 1909 Snapshot: snapshot.Bytes(), 1910 } 1911 return err 1912 } 1913 1914 errorBody.Seek(0, io.SeekStart) 1915 if len(code) != 0 { 1916 errorCode = restjson.SanitizeErrorCode(code) 1917 } 1918 if len(message) != 0 { 1919 errorMessage = message 1920 } 1921 1922 switch { 1923 case strings.EqualFold("InternalFailureException", errorCode): 1924 return awsAwsjson11_deserializeErrorInternalFailureException(response, errorBody) 1925 1926 case strings.EqualFold("InvalidRequestException", errorCode): 1927 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 1928 1929 case strings.EqualFold("ResourceNotFoundException", errorCode): 1930 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 1931 1932 case strings.EqualFold("ThrottlingException", errorCode): 1933 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 1934 1935 default: 1936 genericError := &smithy.GenericAPIError{ 1937 Code: errorCode, 1938 Message: errorMessage, 1939 } 1940 return genericError 1941 1942 } 1943} 1944 1945type awsAwsjson11_deserializeOpGetNamespaceDeletionStatus struct { 1946} 1947 1948func (*awsAwsjson11_deserializeOpGetNamespaceDeletionStatus) ID() string { 1949 return "OperationDeserializer" 1950} 1951 1952func (m *awsAwsjson11_deserializeOpGetNamespaceDeletionStatus) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1953 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1954) { 1955 out, metadata, err = next.HandleDeserialize(ctx, in) 1956 if err != nil { 1957 return out, metadata, err 1958 } 1959 1960 response, ok := out.RawResponse.(*smithyhttp.Response) 1961 if !ok { 1962 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1963 } 1964 1965 if response.StatusCode < 200 || response.StatusCode >= 300 { 1966 return out, metadata, awsAwsjson11_deserializeOpErrorGetNamespaceDeletionStatus(response, &metadata) 1967 } 1968 output := &GetNamespaceDeletionStatusOutput{} 1969 out.Result = output 1970 1971 var buff [1024]byte 1972 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1973 1974 body := io.TeeReader(response.Body, ringBuffer) 1975 decoder := json.NewDecoder(body) 1976 decoder.UseNumber() 1977 var shape interface{} 1978 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1979 var snapshot bytes.Buffer 1980 io.Copy(&snapshot, ringBuffer) 1981 err = &smithy.DeserializationError{ 1982 Err: fmt.Errorf("failed to decode response body, %w", err), 1983 Snapshot: snapshot.Bytes(), 1984 } 1985 return out, metadata, err 1986 } 1987 1988 err = awsAwsjson11_deserializeOpDocumentGetNamespaceDeletionStatusOutput(&output, shape) 1989 if err != nil { 1990 var snapshot bytes.Buffer 1991 io.Copy(&snapshot, ringBuffer) 1992 err = &smithy.DeserializationError{ 1993 Err: fmt.Errorf("failed to decode response body, %w", err), 1994 Snapshot: snapshot.Bytes(), 1995 } 1996 return out, metadata, err 1997 } 1998 1999 return out, metadata, err 2000} 2001 2002func awsAwsjson11_deserializeOpErrorGetNamespaceDeletionStatus(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2003 var errorBuffer bytes.Buffer 2004 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2005 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2006 } 2007 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2008 2009 errorCode := "UnknownError" 2010 errorMessage := errorCode 2011 2012 code := response.Header.Get("X-Amzn-ErrorType") 2013 if len(code) != 0 { 2014 errorCode = restjson.SanitizeErrorCode(code) 2015 } 2016 2017 var buff [1024]byte 2018 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2019 2020 body := io.TeeReader(errorBody, ringBuffer) 2021 decoder := json.NewDecoder(body) 2022 decoder.UseNumber() 2023 code, message, err := restjson.GetErrorInfo(decoder) 2024 if err != nil { 2025 var snapshot bytes.Buffer 2026 io.Copy(&snapshot, ringBuffer) 2027 err = &smithy.DeserializationError{ 2028 Err: fmt.Errorf("failed to decode response body, %w", err), 2029 Snapshot: snapshot.Bytes(), 2030 } 2031 return err 2032 } 2033 2034 errorBody.Seek(0, io.SeekStart) 2035 if len(code) != 0 { 2036 errorCode = restjson.SanitizeErrorCode(code) 2037 } 2038 if len(message) != 0 { 2039 errorMessage = message 2040 } 2041 2042 switch { 2043 case strings.EqualFold("InternalFailureException", errorCode): 2044 return awsAwsjson11_deserializeErrorInternalFailureException(response, errorBody) 2045 2046 case strings.EqualFold("InvalidRequestException", errorCode): 2047 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 2048 2049 case strings.EqualFold("ThrottlingException", errorCode): 2050 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 2051 2052 default: 2053 genericError := &smithy.GenericAPIError{ 2054 Code: errorCode, 2055 Message: errorMessage, 2056 } 2057 return genericError 2058 2059 } 2060} 2061 2062type awsAwsjson11_deserializeOpGetSystemInstance struct { 2063} 2064 2065func (*awsAwsjson11_deserializeOpGetSystemInstance) ID() string { 2066 return "OperationDeserializer" 2067} 2068 2069func (m *awsAwsjson11_deserializeOpGetSystemInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2070 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2071) { 2072 out, metadata, err = next.HandleDeserialize(ctx, in) 2073 if err != nil { 2074 return out, metadata, err 2075 } 2076 2077 response, ok := out.RawResponse.(*smithyhttp.Response) 2078 if !ok { 2079 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2080 } 2081 2082 if response.StatusCode < 200 || response.StatusCode >= 300 { 2083 return out, metadata, awsAwsjson11_deserializeOpErrorGetSystemInstance(response, &metadata) 2084 } 2085 output := &GetSystemInstanceOutput{} 2086 out.Result = output 2087 2088 var buff [1024]byte 2089 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2090 2091 body := io.TeeReader(response.Body, ringBuffer) 2092 decoder := json.NewDecoder(body) 2093 decoder.UseNumber() 2094 var shape interface{} 2095 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2096 var snapshot bytes.Buffer 2097 io.Copy(&snapshot, ringBuffer) 2098 err = &smithy.DeserializationError{ 2099 Err: fmt.Errorf("failed to decode response body, %w", err), 2100 Snapshot: snapshot.Bytes(), 2101 } 2102 return out, metadata, err 2103 } 2104 2105 err = awsAwsjson11_deserializeOpDocumentGetSystemInstanceOutput(&output, shape) 2106 if err != nil { 2107 var snapshot bytes.Buffer 2108 io.Copy(&snapshot, ringBuffer) 2109 err = &smithy.DeserializationError{ 2110 Err: fmt.Errorf("failed to decode response body, %w", err), 2111 Snapshot: snapshot.Bytes(), 2112 } 2113 return out, metadata, err 2114 } 2115 2116 return out, metadata, err 2117} 2118 2119func awsAwsjson11_deserializeOpErrorGetSystemInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2120 var errorBuffer bytes.Buffer 2121 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2122 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2123 } 2124 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2125 2126 errorCode := "UnknownError" 2127 errorMessage := errorCode 2128 2129 code := response.Header.Get("X-Amzn-ErrorType") 2130 if len(code) != 0 { 2131 errorCode = restjson.SanitizeErrorCode(code) 2132 } 2133 2134 var buff [1024]byte 2135 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2136 2137 body := io.TeeReader(errorBody, ringBuffer) 2138 decoder := json.NewDecoder(body) 2139 decoder.UseNumber() 2140 code, message, err := restjson.GetErrorInfo(decoder) 2141 if err != nil { 2142 var snapshot bytes.Buffer 2143 io.Copy(&snapshot, ringBuffer) 2144 err = &smithy.DeserializationError{ 2145 Err: fmt.Errorf("failed to decode response body, %w", err), 2146 Snapshot: snapshot.Bytes(), 2147 } 2148 return err 2149 } 2150 2151 errorBody.Seek(0, io.SeekStart) 2152 if len(code) != 0 { 2153 errorCode = restjson.SanitizeErrorCode(code) 2154 } 2155 if len(message) != 0 { 2156 errorMessage = message 2157 } 2158 2159 switch { 2160 case strings.EqualFold("InternalFailureException", errorCode): 2161 return awsAwsjson11_deserializeErrorInternalFailureException(response, errorBody) 2162 2163 case strings.EqualFold("InvalidRequestException", errorCode): 2164 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 2165 2166 case strings.EqualFold("ResourceNotFoundException", errorCode): 2167 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 2168 2169 case strings.EqualFold("ThrottlingException", errorCode): 2170 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 2171 2172 default: 2173 genericError := &smithy.GenericAPIError{ 2174 Code: errorCode, 2175 Message: errorMessage, 2176 } 2177 return genericError 2178 2179 } 2180} 2181 2182type awsAwsjson11_deserializeOpGetSystemTemplate struct { 2183} 2184 2185func (*awsAwsjson11_deserializeOpGetSystemTemplate) ID() string { 2186 return "OperationDeserializer" 2187} 2188 2189func (m *awsAwsjson11_deserializeOpGetSystemTemplate) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2190 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2191) { 2192 out, metadata, err = next.HandleDeserialize(ctx, in) 2193 if err != nil { 2194 return out, metadata, err 2195 } 2196 2197 response, ok := out.RawResponse.(*smithyhttp.Response) 2198 if !ok { 2199 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2200 } 2201 2202 if response.StatusCode < 200 || response.StatusCode >= 300 { 2203 return out, metadata, awsAwsjson11_deserializeOpErrorGetSystemTemplate(response, &metadata) 2204 } 2205 output := &GetSystemTemplateOutput{} 2206 out.Result = output 2207 2208 var buff [1024]byte 2209 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2210 2211 body := io.TeeReader(response.Body, ringBuffer) 2212 decoder := json.NewDecoder(body) 2213 decoder.UseNumber() 2214 var shape interface{} 2215 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2216 var snapshot bytes.Buffer 2217 io.Copy(&snapshot, ringBuffer) 2218 err = &smithy.DeserializationError{ 2219 Err: fmt.Errorf("failed to decode response body, %w", err), 2220 Snapshot: snapshot.Bytes(), 2221 } 2222 return out, metadata, err 2223 } 2224 2225 err = awsAwsjson11_deserializeOpDocumentGetSystemTemplateOutput(&output, shape) 2226 if err != nil { 2227 var snapshot bytes.Buffer 2228 io.Copy(&snapshot, ringBuffer) 2229 err = &smithy.DeserializationError{ 2230 Err: fmt.Errorf("failed to decode response body, %w", err), 2231 Snapshot: snapshot.Bytes(), 2232 } 2233 return out, metadata, err 2234 } 2235 2236 return out, metadata, err 2237} 2238 2239func awsAwsjson11_deserializeOpErrorGetSystemTemplate(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2240 var errorBuffer bytes.Buffer 2241 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2242 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2243 } 2244 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2245 2246 errorCode := "UnknownError" 2247 errorMessage := errorCode 2248 2249 code := response.Header.Get("X-Amzn-ErrorType") 2250 if len(code) != 0 { 2251 errorCode = restjson.SanitizeErrorCode(code) 2252 } 2253 2254 var buff [1024]byte 2255 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2256 2257 body := io.TeeReader(errorBody, ringBuffer) 2258 decoder := json.NewDecoder(body) 2259 decoder.UseNumber() 2260 code, message, err := restjson.GetErrorInfo(decoder) 2261 if err != nil { 2262 var snapshot bytes.Buffer 2263 io.Copy(&snapshot, ringBuffer) 2264 err = &smithy.DeserializationError{ 2265 Err: fmt.Errorf("failed to decode response body, %w", err), 2266 Snapshot: snapshot.Bytes(), 2267 } 2268 return err 2269 } 2270 2271 errorBody.Seek(0, io.SeekStart) 2272 if len(code) != 0 { 2273 errorCode = restjson.SanitizeErrorCode(code) 2274 } 2275 if len(message) != 0 { 2276 errorMessage = message 2277 } 2278 2279 switch { 2280 case strings.EqualFold("InternalFailureException", errorCode): 2281 return awsAwsjson11_deserializeErrorInternalFailureException(response, errorBody) 2282 2283 case strings.EqualFold("InvalidRequestException", errorCode): 2284 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 2285 2286 case strings.EqualFold("ResourceNotFoundException", errorCode): 2287 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 2288 2289 case strings.EqualFold("ThrottlingException", errorCode): 2290 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 2291 2292 default: 2293 genericError := &smithy.GenericAPIError{ 2294 Code: errorCode, 2295 Message: errorMessage, 2296 } 2297 return genericError 2298 2299 } 2300} 2301 2302type awsAwsjson11_deserializeOpGetSystemTemplateRevisions struct { 2303} 2304 2305func (*awsAwsjson11_deserializeOpGetSystemTemplateRevisions) ID() string { 2306 return "OperationDeserializer" 2307} 2308 2309func (m *awsAwsjson11_deserializeOpGetSystemTemplateRevisions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2310 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2311) { 2312 out, metadata, err = next.HandleDeserialize(ctx, in) 2313 if err != nil { 2314 return out, metadata, err 2315 } 2316 2317 response, ok := out.RawResponse.(*smithyhttp.Response) 2318 if !ok { 2319 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2320 } 2321 2322 if response.StatusCode < 200 || response.StatusCode >= 300 { 2323 return out, metadata, awsAwsjson11_deserializeOpErrorGetSystemTemplateRevisions(response, &metadata) 2324 } 2325 output := &GetSystemTemplateRevisionsOutput{} 2326 out.Result = output 2327 2328 var buff [1024]byte 2329 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2330 2331 body := io.TeeReader(response.Body, ringBuffer) 2332 decoder := json.NewDecoder(body) 2333 decoder.UseNumber() 2334 var shape interface{} 2335 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2336 var snapshot bytes.Buffer 2337 io.Copy(&snapshot, ringBuffer) 2338 err = &smithy.DeserializationError{ 2339 Err: fmt.Errorf("failed to decode response body, %w", err), 2340 Snapshot: snapshot.Bytes(), 2341 } 2342 return out, metadata, err 2343 } 2344 2345 err = awsAwsjson11_deserializeOpDocumentGetSystemTemplateRevisionsOutput(&output, shape) 2346 if err != nil { 2347 var snapshot bytes.Buffer 2348 io.Copy(&snapshot, ringBuffer) 2349 err = &smithy.DeserializationError{ 2350 Err: fmt.Errorf("failed to decode response body, %w", err), 2351 Snapshot: snapshot.Bytes(), 2352 } 2353 return out, metadata, err 2354 } 2355 2356 return out, metadata, err 2357} 2358 2359func awsAwsjson11_deserializeOpErrorGetSystemTemplateRevisions(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2360 var errorBuffer bytes.Buffer 2361 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2362 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2363 } 2364 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2365 2366 errorCode := "UnknownError" 2367 errorMessage := errorCode 2368 2369 code := response.Header.Get("X-Amzn-ErrorType") 2370 if len(code) != 0 { 2371 errorCode = restjson.SanitizeErrorCode(code) 2372 } 2373 2374 var buff [1024]byte 2375 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2376 2377 body := io.TeeReader(errorBody, ringBuffer) 2378 decoder := json.NewDecoder(body) 2379 decoder.UseNumber() 2380 code, message, err := restjson.GetErrorInfo(decoder) 2381 if err != nil { 2382 var snapshot bytes.Buffer 2383 io.Copy(&snapshot, ringBuffer) 2384 err = &smithy.DeserializationError{ 2385 Err: fmt.Errorf("failed to decode response body, %w", err), 2386 Snapshot: snapshot.Bytes(), 2387 } 2388 return err 2389 } 2390 2391 errorBody.Seek(0, io.SeekStart) 2392 if len(code) != 0 { 2393 errorCode = restjson.SanitizeErrorCode(code) 2394 } 2395 if len(message) != 0 { 2396 errorMessage = message 2397 } 2398 2399 switch { 2400 case strings.EqualFold("InternalFailureException", errorCode): 2401 return awsAwsjson11_deserializeErrorInternalFailureException(response, errorBody) 2402 2403 case strings.EqualFold("InvalidRequestException", errorCode): 2404 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 2405 2406 case strings.EqualFold("ResourceNotFoundException", errorCode): 2407 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 2408 2409 case strings.EqualFold("ThrottlingException", errorCode): 2410 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 2411 2412 default: 2413 genericError := &smithy.GenericAPIError{ 2414 Code: errorCode, 2415 Message: errorMessage, 2416 } 2417 return genericError 2418 2419 } 2420} 2421 2422type awsAwsjson11_deserializeOpGetUploadStatus struct { 2423} 2424 2425func (*awsAwsjson11_deserializeOpGetUploadStatus) ID() string { 2426 return "OperationDeserializer" 2427} 2428 2429func (m *awsAwsjson11_deserializeOpGetUploadStatus) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2430 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2431) { 2432 out, metadata, err = next.HandleDeserialize(ctx, in) 2433 if err != nil { 2434 return out, metadata, err 2435 } 2436 2437 response, ok := out.RawResponse.(*smithyhttp.Response) 2438 if !ok { 2439 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2440 } 2441 2442 if response.StatusCode < 200 || response.StatusCode >= 300 { 2443 return out, metadata, awsAwsjson11_deserializeOpErrorGetUploadStatus(response, &metadata) 2444 } 2445 output := &GetUploadStatusOutput{} 2446 out.Result = output 2447 2448 var buff [1024]byte 2449 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2450 2451 body := io.TeeReader(response.Body, ringBuffer) 2452 decoder := json.NewDecoder(body) 2453 decoder.UseNumber() 2454 var shape interface{} 2455 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2456 var snapshot bytes.Buffer 2457 io.Copy(&snapshot, ringBuffer) 2458 err = &smithy.DeserializationError{ 2459 Err: fmt.Errorf("failed to decode response body, %w", err), 2460 Snapshot: snapshot.Bytes(), 2461 } 2462 return out, metadata, err 2463 } 2464 2465 err = awsAwsjson11_deserializeOpDocumentGetUploadStatusOutput(&output, shape) 2466 if err != nil { 2467 var snapshot bytes.Buffer 2468 io.Copy(&snapshot, ringBuffer) 2469 err = &smithy.DeserializationError{ 2470 Err: fmt.Errorf("failed to decode response body, %w", err), 2471 Snapshot: snapshot.Bytes(), 2472 } 2473 return out, metadata, err 2474 } 2475 2476 return out, metadata, err 2477} 2478 2479func awsAwsjson11_deserializeOpErrorGetUploadStatus(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2480 var errorBuffer bytes.Buffer 2481 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2482 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2483 } 2484 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2485 2486 errorCode := "UnknownError" 2487 errorMessage := errorCode 2488 2489 code := response.Header.Get("X-Amzn-ErrorType") 2490 if len(code) != 0 { 2491 errorCode = restjson.SanitizeErrorCode(code) 2492 } 2493 2494 var buff [1024]byte 2495 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2496 2497 body := io.TeeReader(errorBody, ringBuffer) 2498 decoder := json.NewDecoder(body) 2499 decoder.UseNumber() 2500 code, message, err := restjson.GetErrorInfo(decoder) 2501 if err != nil { 2502 var snapshot bytes.Buffer 2503 io.Copy(&snapshot, ringBuffer) 2504 err = &smithy.DeserializationError{ 2505 Err: fmt.Errorf("failed to decode response body, %w", err), 2506 Snapshot: snapshot.Bytes(), 2507 } 2508 return err 2509 } 2510 2511 errorBody.Seek(0, io.SeekStart) 2512 if len(code) != 0 { 2513 errorCode = restjson.SanitizeErrorCode(code) 2514 } 2515 if len(message) != 0 { 2516 errorMessage = message 2517 } 2518 2519 switch { 2520 case strings.EqualFold("InternalFailureException", errorCode): 2521 return awsAwsjson11_deserializeErrorInternalFailureException(response, errorBody) 2522 2523 case strings.EqualFold("InvalidRequestException", errorCode): 2524 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 2525 2526 case strings.EqualFold("ResourceNotFoundException", errorCode): 2527 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 2528 2529 case strings.EqualFold("ThrottlingException", errorCode): 2530 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 2531 2532 default: 2533 genericError := &smithy.GenericAPIError{ 2534 Code: errorCode, 2535 Message: errorMessage, 2536 } 2537 return genericError 2538 2539 } 2540} 2541 2542type awsAwsjson11_deserializeOpListFlowExecutionMessages struct { 2543} 2544 2545func (*awsAwsjson11_deserializeOpListFlowExecutionMessages) ID() string { 2546 return "OperationDeserializer" 2547} 2548 2549func (m *awsAwsjson11_deserializeOpListFlowExecutionMessages) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2550 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2551) { 2552 out, metadata, err = next.HandleDeserialize(ctx, in) 2553 if err != nil { 2554 return out, metadata, err 2555 } 2556 2557 response, ok := out.RawResponse.(*smithyhttp.Response) 2558 if !ok { 2559 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2560 } 2561 2562 if response.StatusCode < 200 || response.StatusCode >= 300 { 2563 return out, metadata, awsAwsjson11_deserializeOpErrorListFlowExecutionMessages(response, &metadata) 2564 } 2565 output := &ListFlowExecutionMessagesOutput{} 2566 out.Result = output 2567 2568 var buff [1024]byte 2569 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2570 2571 body := io.TeeReader(response.Body, ringBuffer) 2572 decoder := json.NewDecoder(body) 2573 decoder.UseNumber() 2574 var shape interface{} 2575 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2576 var snapshot bytes.Buffer 2577 io.Copy(&snapshot, ringBuffer) 2578 err = &smithy.DeserializationError{ 2579 Err: fmt.Errorf("failed to decode response body, %w", err), 2580 Snapshot: snapshot.Bytes(), 2581 } 2582 return out, metadata, err 2583 } 2584 2585 err = awsAwsjson11_deserializeOpDocumentListFlowExecutionMessagesOutput(&output, shape) 2586 if err != nil { 2587 var snapshot bytes.Buffer 2588 io.Copy(&snapshot, ringBuffer) 2589 err = &smithy.DeserializationError{ 2590 Err: fmt.Errorf("failed to decode response body, %w", err), 2591 Snapshot: snapshot.Bytes(), 2592 } 2593 return out, metadata, err 2594 } 2595 2596 return out, metadata, err 2597} 2598 2599func awsAwsjson11_deserializeOpErrorListFlowExecutionMessages(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2600 var errorBuffer bytes.Buffer 2601 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2602 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2603 } 2604 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2605 2606 errorCode := "UnknownError" 2607 errorMessage := errorCode 2608 2609 code := response.Header.Get("X-Amzn-ErrorType") 2610 if len(code) != 0 { 2611 errorCode = restjson.SanitizeErrorCode(code) 2612 } 2613 2614 var buff [1024]byte 2615 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2616 2617 body := io.TeeReader(errorBody, ringBuffer) 2618 decoder := json.NewDecoder(body) 2619 decoder.UseNumber() 2620 code, message, err := restjson.GetErrorInfo(decoder) 2621 if err != nil { 2622 var snapshot bytes.Buffer 2623 io.Copy(&snapshot, ringBuffer) 2624 err = &smithy.DeserializationError{ 2625 Err: fmt.Errorf("failed to decode response body, %w", err), 2626 Snapshot: snapshot.Bytes(), 2627 } 2628 return err 2629 } 2630 2631 errorBody.Seek(0, io.SeekStart) 2632 if len(code) != 0 { 2633 errorCode = restjson.SanitizeErrorCode(code) 2634 } 2635 if len(message) != 0 { 2636 errorMessage = message 2637 } 2638 2639 switch { 2640 case strings.EqualFold("InternalFailureException", errorCode): 2641 return awsAwsjson11_deserializeErrorInternalFailureException(response, errorBody) 2642 2643 case strings.EqualFold("InvalidRequestException", errorCode): 2644 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 2645 2646 case strings.EqualFold("ResourceNotFoundException", errorCode): 2647 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 2648 2649 case strings.EqualFold("ThrottlingException", errorCode): 2650 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 2651 2652 default: 2653 genericError := &smithy.GenericAPIError{ 2654 Code: errorCode, 2655 Message: errorMessage, 2656 } 2657 return genericError 2658 2659 } 2660} 2661 2662type awsAwsjson11_deserializeOpListTagsForResource struct { 2663} 2664 2665func (*awsAwsjson11_deserializeOpListTagsForResource) ID() string { 2666 return "OperationDeserializer" 2667} 2668 2669func (m *awsAwsjson11_deserializeOpListTagsForResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2670 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2671) { 2672 out, metadata, err = next.HandleDeserialize(ctx, in) 2673 if err != nil { 2674 return out, metadata, err 2675 } 2676 2677 response, ok := out.RawResponse.(*smithyhttp.Response) 2678 if !ok { 2679 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2680 } 2681 2682 if response.StatusCode < 200 || response.StatusCode >= 300 { 2683 return out, metadata, awsAwsjson11_deserializeOpErrorListTagsForResource(response, &metadata) 2684 } 2685 output := &ListTagsForResourceOutput{} 2686 out.Result = output 2687 2688 var buff [1024]byte 2689 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2690 2691 body := io.TeeReader(response.Body, ringBuffer) 2692 decoder := json.NewDecoder(body) 2693 decoder.UseNumber() 2694 var shape interface{} 2695 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2696 var snapshot bytes.Buffer 2697 io.Copy(&snapshot, ringBuffer) 2698 err = &smithy.DeserializationError{ 2699 Err: fmt.Errorf("failed to decode response body, %w", err), 2700 Snapshot: snapshot.Bytes(), 2701 } 2702 return out, metadata, err 2703 } 2704 2705 err = awsAwsjson11_deserializeOpDocumentListTagsForResourceOutput(&output, shape) 2706 if err != nil { 2707 var snapshot bytes.Buffer 2708 io.Copy(&snapshot, ringBuffer) 2709 err = &smithy.DeserializationError{ 2710 Err: fmt.Errorf("failed to decode response body, %w", err), 2711 Snapshot: snapshot.Bytes(), 2712 } 2713 return out, metadata, err 2714 } 2715 2716 return out, metadata, err 2717} 2718 2719func awsAwsjson11_deserializeOpErrorListTagsForResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2720 var errorBuffer bytes.Buffer 2721 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2722 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2723 } 2724 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2725 2726 errorCode := "UnknownError" 2727 errorMessage := errorCode 2728 2729 code := response.Header.Get("X-Amzn-ErrorType") 2730 if len(code) != 0 { 2731 errorCode = restjson.SanitizeErrorCode(code) 2732 } 2733 2734 var buff [1024]byte 2735 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2736 2737 body := io.TeeReader(errorBody, ringBuffer) 2738 decoder := json.NewDecoder(body) 2739 decoder.UseNumber() 2740 code, message, err := restjson.GetErrorInfo(decoder) 2741 if err != nil { 2742 var snapshot bytes.Buffer 2743 io.Copy(&snapshot, ringBuffer) 2744 err = &smithy.DeserializationError{ 2745 Err: fmt.Errorf("failed to decode response body, %w", err), 2746 Snapshot: snapshot.Bytes(), 2747 } 2748 return err 2749 } 2750 2751 errorBody.Seek(0, io.SeekStart) 2752 if len(code) != 0 { 2753 errorCode = restjson.SanitizeErrorCode(code) 2754 } 2755 if len(message) != 0 { 2756 errorMessage = message 2757 } 2758 2759 switch { 2760 case strings.EqualFold("InternalFailureException", errorCode): 2761 return awsAwsjson11_deserializeErrorInternalFailureException(response, errorBody) 2762 2763 case strings.EqualFold("InvalidRequestException", errorCode): 2764 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 2765 2766 case strings.EqualFold("ResourceAlreadyExistsException", errorCode): 2767 return awsAwsjson11_deserializeErrorResourceAlreadyExistsException(response, errorBody) 2768 2769 case strings.EqualFold("ThrottlingException", errorCode): 2770 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 2771 2772 default: 2773 genericError := &smithy.GenericAPIError{ 2774 Code: errorCode, 2775 Message: errorMessage, 2776 } 2777 return genericError 2778 2779 } 2780} 2781 2782type awsAwsjson11_deserializeOpSearchEntities struct { 2783} 2784 2785func (*awsAwsjson11_deserializeOpSearchEntities) ID() string { 2786 return "OperationDeserializer" 2787} 2788 2789func (m *awsAwsjson11_deserializeOpSearchEntities) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2790 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2791) { 2792 out, metadata, err = next.HandleDeserialize(ctx, in) 2793 if err != nil { 2794 return out, metadata, err 2795 } 2796 2797 response, ok := out.RawResponse.(*smithyhttp.Response) 2798 if !ok { 2799 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2800 } 2801 2802 if response.StatusCode < 200 || response.StatusCode >= 300 { 2803 return out, metadata, awsAwsjson11_deserializeOpErrorSearchEntities(response, &metadata) 2804 } 2805 output := &SearchEntitiesOutput{} 2806 out.Result = output 2807 2808 var buff [1024]byte 2809 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2810 2811 body := io.TeeReader(response.Body, ringBuffer) 2812 decoder := json.NewDecoder(body) 2813 decoder.UseNumber() 2814 var shape interface{} 2815 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2816 var snapshot bytes.Buffer 2817 io.Copy(&snapshot, ringBuffer) 2818 err = &smithy.DeserializationError{ 2819 Err: fmt.Errorf("failed to decode response body, %w", err), 2820 Snapshot: snapshot.Bytes(), 2821 } 2822 return out, metadata, err 2823 } 2824 2825 err = awsAwsjson11_deserializeOpDocumentSearchEntitiesOutput(&output, shape) 2826 if err != nil { 2827 var snapshot bytes.Buffer 2828 io.Copy(&snapshot, ringBuffer) 2829 err = &smithy.DeserializationError{ 2830 Err: fmt.Errorf("failed to decode response body, %w", err), 2831 Snapshot: snapshot.Bytes(), 2832 } 2833 return out, metadata, err 2834 } 2835 2836 return out, metadata, err 2837} 2838 2839func awsAwsjson11_deserializeOpErrorSearchEntities(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2840 var errorBuffer bytes.Buffer 2841 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2842 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2843 } 2844 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2845 2846 errorCode := "UnknownError" 2847 errorMessage := errorCode 2848 2849 code := response.Header.Get("X-Amzn-ErrorType") 2850 if len(code) != 0 { 2851 errorCode = restjson.SanitizeErrorCode(code) 2852 } 2853 2854 var buff [1024]byte 2855 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2856 2857 body := io.TeeReader(errorBody, ringBuffer) 2858 decoder := json.NewDecoder(body) 2859 decoder.UseNumber() 2860 code, message, err := restjson.GetErrorInfo(decoder) 2861 if err != nil { 2862 var snapshot bytes.Buffer 2863 io.Copy(&snapshot, ringBuffer) 2864 err = &smithy.DeserializationError{ 2865 Err: fmt.Errorf("failed to decode response body, %w", err), 2866 Snapshot: snapshot.Bytes(), 2867 } 2868 return err 2869 } 2870 2871 errorBody.Seek(0, io.SeekStart) 2872 if len(code) != 0 { 2873 errorCode = restjson.SanitizeErrorCode(code) 2874 } 2875 if len(message) != 0 { 2876 errorMessage = message 2877 } 2878 2879 switch { 2880 case strings.EqualFold("InternalFailureException", errorCode): 2881 return awsAwsjson11_deserializeErrorInternalFailureException(response, errorBody) 2882 2883 case strings.EqualFold("InvalidRequestException", errorCode): 2884 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 2885 2886 case strings.EqualFold("ThrottlingException", errorCode): 2887 return awsAwsjson11_deserializeErrorThrottlingException(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_deserializeOpSearchFlowExecutions struct { 2900} 2901 2902func (*awsAwsjson11_deserializeOpSearchFlowExecutions) ID() string { 2903 return "OperationDeserializer" 2904} 2905 2906func (m *awsAwsjson11_deserializeOpSearchFlowExecutions) 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_deserializeOpErrorSearchFlowExecutions(response, &metadata) 2921 } 2922 output := &SearchFlowExecutionsOutput{} 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_deserializeOpDocumentSearchFlowExecutionsOutput(&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_deserializeOpErrorSearchFlowExecutions(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("InternalFailureException", errorCode): 2998 return awsAwsjson11_deserializeErrorInternalFailureException(response, errorBody) 2999 3000 case strings.EqualFold("InvalidRequestException", errorCode): 3001 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 3002 3003 case strings.EqualFold("ResourceNotFoundException", errorCode): 3004 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 3005 3006 case strings.EqualFold("ThrottlingException", errorCode): 3007 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 3008 3009 default: 3010 genericError := &smithy.GenericAPIError{ 3011 Code: errorCode, 3012 Message: errorMessage, 3013 } 3014 return genericError 3015 3016 } 3017} 3018 3019type awsAwsjson11_deserializeOpSearchFlowTemplates struct { 3020} 3021 3022func (*awsAwsjson11_deserializeOpSearchFlowTemplates) ID() string { 3023 return "OperationDeserializer" 3024} 3025 3026func (m *awsAwsjson11_deserializeOpSearchFlowTemplates) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3027 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3028) { 3029 out, metadata, err = next.HandleDeserialize(ctx, in) 3030 if err != nil { 3031 return out, metadata, err 3032 } 3033 3034 response, ok := out.RawResponse.(*smithyhttp.Response) 3035 if !ok { 3036 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3037 } 3038 3039 if response.StatusCode < 200 || response.StatusCode >= 300 { 3040 return out, metadata, awsAwsjson11_deserializeOpErrorSearchFlowTemplates(response, &metadata) 3041 } 3042 output := &SearchFlowTemplatesOutput{} 3043 out.Result = output 3044 3045 var buff [1024]byte 3046 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3047 3048 body := io.TeeReader(response.Body, ringBuffer) 3049 decoder := json.NewDecoder(body) 3050 decoder.UseNumber() 3051 var shape interface{} 3052 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3053 var snapshot bytes.Buffer 3054 io.Copy(&snapshot, ringBuffer) 3055 err = &smithy.DeserializationError{ 3056 Err: fmt.Errorf("failed to decode response body, %w", err), 3057 Snapshot: snapshot.Bytes(), 3058 } 3059 return out, metadata, err 3060 } 3061 3062 err = awsAwsjson11_deserializeOpDocumentSearchFlowTemplatesOutput(&output, shape) 3063 if err != nil { 3064 var snapshot bytes.Buffer 3065 io.Copy(&snapshot, ringBuffer) 3066 err = &smithy.DeserializationError{ 3067 Err: fmt.Errorf("failed to decode response body, %w", err), 3068 Snapshot: snapshot.Bytes(), 3069 } 3070 return out, metadata, err 3071 } 3072 3073 return out, metadata, err 3074} 3075 3076func awsAwsjson11_deserializeOpErrorSearchFlowTemplates(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3077 var errorBuffer bytes.Buffer 3078 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3079 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3080 } 3081 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3082 3083 errorCode := "UnknownError" 3084 errorMessage := errorCode 3085 3086 code := response.Header.Get("X-Amzn-ErrorType") 3087 if len(code) != 0 { 3088 errorCode = restjson.SanitizeErrorCode(code) 3089 } 3090 3091 var buff [1024]byte 3092 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3093 3094 body := io.TeeReader(errorBody, ringBuffer) 3095 decoder := json.NewDecoder(body) 3096 decoder.UseNumber() 3097 code, message, err := restjson.GetErrorInfo(decoder) 3098 if err != nil { 3099 var snapshot bytes.Buffer 3100 io.Copy(&snapshot, ringBuffer) 3101 err = &smithy.DeserializationError{ 3102 Err: fmt.Errorf("failed to decode response body, %w", err), 3103 Snapshot: snapshot.Bytes(), 3104 } 3105 return err 3106 } 3107 3108 errorBody.Seek(0, io.SeekStart) 3109 if len(code) != 0 { 3110 errorCode = restjson.SanitizeErrorCode(code) 3111 } 3112 if len(message) != 0 { 3113 errorMessage = message 3114 } 3115 3116 switch { 3117 case strings.EqualFold("InternalFailureException", errorCode): 3118 return awsAwsjson11_deserializeErrorInternalFailureException(response, errorBody) 3119 3120 case strings.EqualFold("InvalidRequestException", errorCode): 3121 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 3122 3123 case strings.EqualFold("ThrottlingException", errorCode): 3124 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 3125 3126 default: 3127 genericError := &smithy.GenericAPIError{ 3128 Code: errorCode, 3129 Message: errorMessage, 3130 } 3131 return genericError 3132 3133 } 3134} 3135 3136type awsAwsjson11_deserializeOpSearchSystemInstances struct { 3137} 3138 3139func (*awsAwsjson11_deserializeOpSearchSystemInstances) ID() string { 3140 return "OperationDeserializer" 3141} 3142 3143func (m *awsAwsjson11_deserializeOpSearchSystemInstances) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3144 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3145) { 3146 out, metadata, err = next.HandleDeserialize(ctx, in) 3147 if err != nil { 3148 return out, metadata, err 3149 } 3150 3151 response, ok := out.RawResponse.(*smithyhttp.Response) 3152 if !ok { 3153 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3154 } 3155 3156 if response.StatusCode < 200 || response.StatusCode >= 300 { 3157 return out, metadata, awsAwsjson11_deserializeOpErrorSearchSystemInstances(response, &metadata) 3158 } 3159 output := &SearchSystemInstancesOutput{} 3160 out.Result = output 3161 3162 var buff [1024]byte 3163 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3164 3165 body := io.TeeReader(response.Body, ringBuffer) 3166 decoder := json.NewDecoder(body) 3167 decoder.UseNumber() 3168 var shape interface{} 3169 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3170 var snapshot bytes.Buffer 3171 io.Copy(&snapshot, ringBuffer) 3172 err = &smithy.DeserializationError{ 3173 Err: fmt.Errorf("failed to decode response body, %w", err), 3174 Snapshot: snapshot.Bytes(), 3175 } 3176 return out, metadata, err 3177 } 3178 3179 err = awsAwsjson11_deserializeOpDocumentSearchSystemInstancesOutput(&output, shape) 3180 if err != nil { 3181 var snapshot bytes.Buffer 3182 io.Copy(&snapshot, ringBuffer) 3183 err = &smithy.DeserializationError{ 3184 Err: fmt.Errorf("failed to decode response body, %w", err), 3185 Snapshot: snapshot.Bytes(), 3186 } 3187 return out, metadata, err 3188 } 3189 3190 return out, metadata, err 3191} 3192 3193func awsAwsjson11_deserializeOpErrorSearchSystemInstances(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3194 var errorBuffer bytes.Buffer 3195 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3196 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3197 } 3198 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3199 3200 errorCode := "UnknownError" 3201 errorMessage := errorCode 3202 3203 code := response.Header.Get("X-Amzn-ErrorType") 3204 if len(code) != 0 { 3205 errorCode = restjson.SanitizeErrorCode(code) 3206 } 3207 3208 var buff [1024]byte 3209 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3210 3211 body := io.TeeReader(errorBody, ringBuffer) 3212 decoder := json.NewDecoder(body) 3213 decoder.UseNumber() 3214 code, message, err := restjson.GetErrorInfo(decoder) 3215 if err != nil { 3216 var snapshot bytes.Buffer 3217 io.Copy(&snapshot, ringBuffer) 3218 err = &smithy.DeserializationError{ 3219 Err: fmt.Errorf("failed to decode response body, %w", err), 3220 Snapshot: snapshot.Bytes(), 3221 } 3222 return err 3223 } 3224 3225 errorBody.Seek(0, io.SeekStart) 3226 if len(code) != 0 { 3227 errorCode = restjson.SanitizeErrorCode(code) 3228 } 3229 if len(message) != 0 { 3230 errorMessage = message 3231 } 3232 3233 switch { 3234 case strings.EqualFold("InternalFailureException", errorCode): 3235 return awsAwsjson11_deserializeErrorInternalFailureException(response, errorBody) 3236 3237 case strings.EqualFold("InvalidRequestException", errorCode): 3238 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 3239 3240 case strings.EqualFold("ThrottlingException", errorCode): 3241 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 3242 3243 default: 3244 genericError := &smithy.GenericAPIError{ 3245 Code: errorCode, 3246 Message: errorMessage, 3247 } 3248 return genericError 3249 3250 } 3251} 3252 3253type awsAwsjson11_deserializeOpSearchSystemTemplates struct { 3254} 3255 3256func (*awsAwsjson11_deserializeOpSearchSystemTemplates) ID() string { 3257 return "OperationDeserializer" 3258} 3259 3260func (m *awsAwsjson11_deserializeOpSearchSystemTemplates) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3261 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3262) { 3263 out, metadata, err = next.HandleDeserialize(ctx, in) 3264 if err != nil { 3265 return out, metadata, err 3266 } 3267 3268 response, ok := out.RawResponse.(*smithyhttp.Response) 3269 if !ok { 3270 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3271 } 3272 3273 if response.StatusCode < 200 || response.StatusCode >= 300 { 3274 return out, metadata, awsAwsjson11_deserializeOpErrorSearchSystemTemplates(response, &metadata) 3275 } 3276 output := &SearchSystemTemplatesOutput{} 3277 out.Result = output 3278 3279 var buff [1024]byte 3280 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3281 3282 body := io.TeeReader(response.Body, ringBuffer) 3283 decoder := json.NewDecoder(body) 3284 decoder.UseNumber() 3285 var shape interface{} 3286 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3287 var snapshot bytes.Buffer 3288 io.Copy(&snapshot, ringBuffer) 3289 err = &smithy.DeserializationError{ 3290 Err: fmt.Errorf("failed to decode response body, %w", err), 3291 Snapshot: snapshot.Bytes(), 3292 } 3293 return out, metadata, err 3294 } 3295 3296 err = awsAwsjson11_deserializeOpDocumentSearchSystemTemplatesOutput(&output, shape) 3297 if err != nil { 3298 var snapshot bytes.Buffer 3299 io.Copy(&snapshot, ringBuffer) 3300 err = &smithy.DeserializationError{ 3301 Err: fmt.Errorf("failed to decode response body, %w", err), 3302 Snapshot: snapshot.Bytes(), 3303 } 3304 return out, metadata, err 3305 } 3306 3307 return out, metadata, err 3308} 3309 3310func awsAwsjson11_deserializeOpErrorSearchSystemTemplates(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3311 var errorBuffer bytes.Buffer 3312 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3313 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3314 } 3315 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3316 3317 errorCode := "UnknownError" 3318 errorMessage := errorCode 3319 3320 code := response.Header.Get("X-Amzn-ErrorType") 3321 if len(code) != 0 { 3322 errorCode = restjson.SanitizeErrorCode(code) 3323 } 3324 3325 var buff [1024]byte 3326 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3327 3328 body := io.TeeReader(errorBody, ringBuffer) 3329 decoder := json.NewDecoder(body) 3330 decoder.UseNumber() 3331 code, message, err := restjson.GetErrorInfo(decoder) 3332 if err != nil { 3333 var snapshot bytes.Buffer 3334 io.Copy(&snapshot, ringBuffer) 3335 err = &smithy.DeserializationError{ 3336 Err: fmt.Errorf("failed to decode response body, %w", err), 3337 Snapshot: snapshot.Bytes(), 3338 } 3339 return err 3340 } 3341 3342 errorBody.Seek(0, io.SeekStart) 3343 if len(code) != 0 { 3344 errorCode = restjson.SanitizeErrorCode(code) 3345 } 3346 if len(message) != 0 { 3347 errorMessage = message 3348 } 3349 3350 switch { 3351 case strings.EqualFold("InternalFailureException", errorCode): 3352 return awsAwsjson11_deserializeErrorInternalFailureException(response, errorBody) 3353 3354 case strings.EqualFold("InvalidRequestException", errorCode): 3355 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 3356 3357 case strings.EqualFold("ThrottlingException", errorCode): 3358 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 3359 3360 default: 3361 genericError := &smithy.GenericAPIError{ 3362 Code: errorCode, 3363 Message: errorMessage, 3364 } 3365 return genericError 3366 3367 } 3368} 3369 3370type awsAwsjson11_deserializeOpSearchThings struct { 3371} 3372 3373func (*awsAwsjson11_deserializeOpSearchThings) ID() string { 3374 return "OperationDeserializer" 3375} 3376 3377func (m *awsAwsjson11_deserializeOpSearchThings) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3378 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3379) { 3380 out, metadata, err = next.HandleDeserialize(ctx, in) 3381 if err != nil { 3382 return out, metadata, err 3383 } 3384 3385 response, ok := out.RawResponse.(*smithyhttp.Response) 3386 if !ok { 3387 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3388 } 3389 3390 if response.StatusCode < 200 || response.StatusCode >= 300 { 3391 return out, metadata, awsAwsjson11_deserializeOpErrorSearchThings(response, &metadata) 3392 } 3393 output := &SearchThingsOutput{} 3394 out.Result = output 3395 3396 var buff [1024]byte 3397 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3398 3399 body := io.TeeReader(response.Body, ringBuffer) 3400 decoder := json.NewDecoder(body) 3401 decoder.UseNumber() 3402 var shape interface{} 3403 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3404 var snapshot bytes.Buffer 3405 io.Copy(&snapshot, ringBuffer) 3406 err = &smithy.DeserializationError{ 3407 Err: fmt.Errorf("failed to decode response body, %w", err), 3408 Snapshot: snapshot.Bytes(), 3409 } 3410 return out, metadata, err 3411 } 3412 3413 err = awsAwsjson11_deserializeOpDocumentSearchThingsOutput(&output, shape) 3414 if err != nil { 3415 var snapshot bytes.Buffer 3416 io.Copy(&snapshot, ringBuffer) 3417 err = &smithy.DeserializationError{ 3418 Err: fmt.Errorf("failed to decode response body, %w", err), 3419 Snapshot: snapshot.Bytes(), 3420 } 3421 return out, metadata, err 3422 } 3423 3424 return out, metadata, err 3425} 3426 3427func awsAwsjson11_deserializeOpErrorSearchThings(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3428 var errorBuffer bytes.Buffer 3429 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3430 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3431 } 3432 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3433 3434 errorCode := "UnknownError" 3435 errorMessage := errorCode 3436 3437 code := response.Header.Get("X-Amzn-ErrorType") 3438 if len(code) != 0 { 3439 errorCode = restjson.SanitizeErrorCode(code) 3440 } 3441 3442 var buff [1024]byte 3443 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3444 3445 body := io.TeeReader(errorBody, ringBuffer) 3446 decoder := json.NewDecoder(body) 3447 decoder.UseNumber() 3448 code, message, err := restjson.GetErrorInfo(decoder) 3449 if err != nil { 3450 var snapshot bytes.Buffer 3451 io.Copy(&snapshot, ringBuffer) 3452 err = &smithy.DeserializationError{ 3453 Err: fmt.Errorf("failed to decode response body, %w", err), 3454 Snapshot: snapshot.Bytes(), 3455 } 3456 return err 3457 } 3458 3459 errorBody.Seek(0, io.SeekStart) 3460 if len(code) != 0 { 3461 errorCode = restjson.SanitizeErrorCode(code) 3462 } 3463 if len(message) != 0 { 3464 errorMessage = message 3465 } 3466 3467 switch { 3468 case strings.EqualFold("InternalFailureException", errorCode): 3469 return awsAwsjson11_deserializeErrorInternalFailureException(response, errorBody) 3470 3471 case strings.EqualFold("InvalidRequestException", errorCode): 3472 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 3473 3474 case strings.EqualFold("ResourceNotFoundException", errorCode): 3475 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 3476 3477 case strings.EqualFold("ThrottlingException", errorCode): 3478 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 3479 3480 default: 3481 genericError := &smithy.GenericAPIError{ 3482 Code: errorCode, 3483 Message: errorMessage, 3484 } 3485 return genericError 3486 3487 } 3488} 3489 3490type awsAwsjson11_deserializeOpTagResource struct { 3491} 3492 3493func (*awsAwsjson11_deserializeOpTagResource) ID() string { 3494 return "OperationDeserializer" 3495} 3496 3497func (m *awsAwsjson11_deserializeOpTagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3498 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3499) { 3500 out, metadata, err = next.HandleDeserialize(ctx, in) 3501 if err != nil { 3502 return out, metadata, err 3503 } 3504 3505 response, ok := out.RawResponse.(*smithyhttp.Response) 3506 if !ok { 3507 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3508 } 3509 3510 if response.StatusCode < 200 || response.StatusCode >= 300 { 3511 return out, metadata, awsAwsjson11_deserializeOpErrorTagResource(response, &metadata) 3512 } 3513 output := &TagResourceOutput{} 3514 out.Result = output 3515 3516 var buff [1024]byte 3517 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3518 3519 body := io.TeeReader(response.Body, ringBuffer) 3520 decoder := json.NewDecoder(body) 3521 decoder.UseNumber() 3522 var shape interface{} 3523 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3524 var snapshot bytes.Buffer 3525 io.Copy(&snapshot, ringBuffer) 3526 err = &smithy.DeserializationError{ 3527 Err: fmt.Errorf("failed to decode response body, %w", err), 3528 Snapshot: snapshot.Bytes(), 3529 } 3530 return out, metadata, err 3531 } 3532 3533 err = awsAwsjson11_deserializeOpDocumentTagResourceOutput(&output, shape) 3534 if err != nil { 3535 var snapshot bytes.Buffer 3536 io.Copy(&snapshot, ringBuffer) 3537 err = &smithy.DeserializationError{ 3538 Err: fmt.Errorf("failed to decode response body, %w", err), 3539 Snapshot: snapshot.Bytes(), 3540 } 3541 return out, metadata, err 3542 } 3543 3544 return out, metadata, err 3545} 3546 3547func awsAwsjson11_deserializeOpErrorTagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3548 var errorBuffer bytes.Buffer 3549 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3550 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3551 } 3552 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3553 3554 errorCode := "UnknownError" 3555 errorMessage := errorCode 3556 3557 code := response.Header.Get("X-Amzn-ErrorType") 3558 if len(code) != 0 { 3559 errorCode = restjson.SanitizeErrorCode(code) 3560 } 3561 3562 var buff [1024]byte 3563 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3564 3565 body := io.TeeReader(errorBody, ringBuffer) 3566 decoder := json.NewDecoder(body) 3567 decoder.UseNumber() 3568 code, message, err := restjson.GetErrorInfo(decoder) 3569 if err != nil { 3570 var snapshot bytes.Buffer 3571 io.Copy(&snapshot, ringBuffer) 3572 err = &smithy.DeserializationError{ 3573 Err: fmt.Errorf("failed to decode response body, %w", err), 3574 Snapshot: snapshot.Bytes(), 3575 } 3576 return err 3577 } 3578 3579 errorBody.Seek(0, io.SeekStart) 3580 if len(code) != 0 { 3581 errorCode = restjson.SanitizeErrorCode(code) 3582 } 3583 if len(message) != 0 { 3584 errorMessage = message 3585 } 3586 3587 switch { 3588 case strings.EqualFold("InternalFailureException", errorCode): 3589 return awsAwsjson11_deserializeErrorInternalFailureException(response, errorBody) 3590 3591 case strings.EqualFold("InvalidRequestException", errorCode): 3592 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 3593 3594 case strings.EqualFold("ResourceAlreadyExistsException", errorCode): 3595 return awsAwsjson11_deserializeErrorResourceAlreadyExistsException(response, errorBody) 3596 3597 case strings.EqualFold("ThrottlingException", errorCode): 3598 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 3599 3600 default: 3601 genericError := &smithy.GenericAPIError{ 3602 Code: errorCode, 3603 Message: errorMessage, 3604 } 3605 return genericError 3606 3607 } 3608} 3609 3610type awsAwsjson11_deserializeOpUndeploySystemInstance struct { 3611} 3612 3613func (*awsAwsjson11_deserializeOpUndeploySystemInstance) ID() string { 3614 return "OperationDeserializer" 3615} 3616 3617func (m *awsAwsjson11_deserializeOpUndeploySystemInstance) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3618 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3619) { 3620 out, metadata, err = next.HandleDeserialize(ctx, in) 3621 if err != nil { 3622 return out, metadata, err 3623 } 3624 3625 response, ok := out.RawResponse.(*smithyhttp.Response) 3626 if !ok { 3627 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3628 } 3629 3630 if response.StatusCode < 200 || response.StatusCode >= 300 { 3631 return out, metadata, awsAwsjson11_deserializeOpErrorUndeploySystemInstance(response, &metadata) 3632 } 3633 output := &UndeploySystemInstanceOutput{} 3634 out.Result = output 3635 3636 var buff [1024]byte 3637 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3638 3639 body := io.TeeReader(response.Body, ringBuffer) 3640 decoder := json.NewDecoder(body) 3641 decoder.UseNumber() 3642 var shape interface{} 3643 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3644 var snapshot bytes.Buffer 3645 io.Copy(&snapshot, ringBuffer) 3646 err = &smithy.DeserializationError{ 3647 Err: fmt.Errorf("failed to decode response body, %w", err), 3648 Snapshot: snapshot.Bytes(), 3649 } 3650 return out, metadata, err 3651 } 3652 3653 err = awsAwsjson11_deserializeOpDocumentUndeploySystemInstanceOutput(&output, shape) 3654 if err != nil { 3655 var snapshot bytes.Buffer 3656 io.Copy(&snapshot, ringBuffer) 3657 err = &smithy.DeserializationError{ 3658 Err: fmt.Errorf("failed to decode response body, %w", err), 3659 Snapshot: snapshot.Bytes(), 3660 } 3661 return out, metadata, err 3662 } 3663 3664 return out, metadata, err 3665} 3666 3667func awsAwsjson11_deserializeOpErrorUndeploySystemInstance(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3668 var errorBuffer bytes.Buffer 3669 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3670 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3671 } 3672 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3673 3674 errorCode := "UnknownError" 3675 errorMessage := errorCode 3676 3677 code := response.Header.Get("X-Amzn-ErrorType") 3678 if len(code) != 0 { 3679 errorCode = restjson.SanitizeErrorCode(code) 3680 } 3681 3682 var buff [1024]byte 3683 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3684 3685 body := io.TeeReader(errorBody, ringBuffer) 3686 decoder := json.NewDecoder(body) 3687 decoder.UseNumber() 3688 code, message, err := restjson.GetErrorInfo(decoder) 3689 if err != nil { 3690 var snapshot bytes.Buffer 3691 io.Copy(&snapshot, ringBuffer) 3692 err = &smithy.DeserializationError{ 3693 Err: fmt.Errorf("failed to decode response body, %w", err), 3694 Snapshot: snapshot.Bytes(), 3695 } 3696 return err 3697 } 3698 3699 errorBody.Seek(0, io.SeekStart) 3700 if len(code) != 0 { 3701 errorCode = restjson.SanitizeErrorCode(code) 3702 } 3703 if len(message) != 0 { 3704 errorMessage = message 3705 } 3706 3707 switch { 3708 case strings.EqualFold("InternalFailureException", errorCode): 3709 return awsAwsjson11_deserializeErrorInternalFailureException(response, errorBody) 3710 3711 case strings.EqualFold("InvalidRequestException", errorCode): 3712 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 3713 3714 case strings.EqualFold("ResourceInUseException", errorCode): 3715 return awsAwsjson11_deserializeErrorResourceInUseException(response, errorBody) 3716 3717 case strings.EqualFold("ResourceNotFoundException", errorCode): 3718 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 3719 3720 case strings.EqualFold("ThrottlingException", errorCode): 3721 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 3722 3723 default: 3724 genericError := &smithy.GenericAPIError{ 3725 Code: errorCode, 3726 Message: errorMessage, 3727 } 3728 return genericError 3729 3730 } 3731} 3732 3733type awsAwsjson11_deserializeOpUntagResource struct { 3734} 3735 3736func (*awsAwsjson11_deserializeOpUntagResource) ID() string { 3737 return "OperationDeserializer" 3738} 3739 3740func (m *awsAwsjson11_deserializeOpUntagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3741 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3742) { 3743 out, metadata, err = next.HandleDeserialize(ctx, in) 3744 if err != nil { 3745 return out, metadata, err 3746 } 3747 3748 response, ok := out.RawResponse.(*smithyhttp.Response) 3749 if !ok { 3750 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3751 } 3752 3753 if response.StatusCode < 200 || response.StatusCode >= 300 { 3754 return out, metadata, awsAwsjson11_deserializeOpErrorUntagResource(response, &metadata) 3755 } 3756 output := &UntagResourceOutput{} 3757 out.Result = output 3758 3759 var buff [1024]byte 3760 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3761 3762 body := io.TeeReader(response.Body, ringBuffer) 3763 decoder := json.NewDecoder(body) 3764 decoder.UseNumber() 3765 var shape interface{} 3766 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3767 var snapshot bytes.Buffer 3768 io.Copy(&snapshot, ringBuffer) 3769 err = &smithy.DeserializationError{ 3770 Err: fmt.Errorf("failed to decode response body, %w", err), 3771 Snapshot: snapshot.Bytes(), 3772 } 3773 return out, metadata, err 3774 } 3775 3776 err = awsAwsjson11_deserializeOpDocumentUntagResourceOutput(&output, shape) 3777 if err != nil { 3778 var snapshot bytes.Buffer 3779 io.Copy(&snapshot, ringBuffer) 3780 err = &smithy.DeserializationError{ 3781 Err: fmt.Errorf("failed to decode response body, %w", err), 3782 Snapshot: snapshot.Bytes(), 3783 } 3784 return out, metadata, err 3785 } 3786 3787 return out, metadata, err 3788} 3789 3790func awsAwsjson11_deserializeOpErrorUntagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3791 var errorBuffer bytes.Buffer 3792 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3793 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3794 } 3795 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3796 3797 errorCode := "UnknownError" 3798 errorMessage := errorCode 3799 3800 code := response.Header.Get("X-Amzn-ErrorType") 3801 if len(code) != 0 { 3802 errorCode = restjson.SanitizeErrorCode(code) 3803 } 3804 3805 var buff [1024]byte 3806 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3807 3808 body := io.TeeReader(errorBody, ringBuffer) 3809 decoder := json.NewDecoder(body) 3810 decoder.UseNumber() 3811 code, message, err := restjson.GetErrorInfo(decoder) 3812 if err != nil { 3813 var snapshot bytes.Buffer 3814 io.Copy(&snapshot, ringBuffer) 3815 err = &smithy.DeserializationError{ 3816 Err: fmt.Errorf("failed to decode response body, %w", err), 3817 Snapshot: snapshot.Bytes(), 3818 } 3819 return err 3820 } 3821 3822 errorBody.Seek(0, io.SeekStart) 3823 if len(code) != 0 { 3824 errorCode = restjson.SanitizeErrorCode(code) 3825 } 3826 if len(message) != 0 { 3827 errorMessage = message 3828 } 3829 3830 switch { 3831 case strings.EqualFold("InternalFailureException", errorCode): 3832 return awsAwsjson11_deserializeErrorInternalFailureException(response, errorBody) 3833 3834 case strings.EqualFold("InvalidRequestException", errorCode): 3835 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 3836 3837 case strings.EqualFold("ResourceAlreadyExistsException", errorCode): 3838 return awsAwsjson11_deserializeErrorResourceAlreadyExistsException(response, errorBody) 3839 3840 case strings.EqualFold("ThrottlingException", errorCode): 3841 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 3842 3843 default: 3844 genericError := &smithy.GenericAPIError{ 3845 Code: errorCode, 3846 Message: errorMessage, 3847 } 3848 return genericError 3849 3850 } 3851} 3852 3853type awsAwsjson11_deserializeOpUpdateFlowTemplate struct { 3854} 3855 3856func (*awsAwsjson11_deserializeOpUpdateFlowTemplate) ID() string { 3857 return "OperationDeserializer" 3858} 3859 3860func (m *awsAwsjson11_deserializeOpUpdateFlowTemplate) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3861 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3862) { 3863 out, metadata, err = next.HandleDeserialize(ctx, in) 3864 if err != nil { 3865 return out, metadata, err 3866 } 3867 3868 response, ok := out.RawResponse.(*smithyhttp.Response) 3869 if !ok { 3870 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3871 } 3872 3873 if response.StatusCode < 200 || response.StatusCode >= 300 { 3874 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateFlowTemplate(response, &metadata) 3875 } 3876 output := &UpdateFlowTemplateOutput{} 3877 out.Result = output 3878 3879 var buff [1024]byte 3880 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3881 3882 body := io.TeeReader(response.Body, ringBuffer) 3883 decoder := json.NewDecoder(body) 3884 decoder.UseNumber() 3885 var shape interface{} 3886 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3887 var snapshot bytes.Buffer 3888 io.Copy(&snapshot, ringBuffer) 3889 err = &smithy.DeserializationError{ 3890 Err: fmt.Errorf("failed to decode response body, %w", err), 3891 Snapshot: snapshot.Bytes(), 3892 } 3893 return out, metadata, err 3894 } 3895 3896 err = awsAwsjson11_deserializeOpDocumentUpdateFlowTemplateOutput(&output, shape) 3897 if err != nil { 3898 var snapshot bytes.Buffer 3899 io.Copy(&snapshot, ringBuffer) 3900 err = &smithy.DeserializationError{ 3901 Err: fmt.Errorf("failed to decode response body, %w", err), 3902 Snapshot: snapshot.Bytes(), 3903 } 3904 return out, metadata, err 3905 } 3906 3907 return out, metadata, err 3908} 3909 3910func awsAwsjson11_deserializeOpErrorUpdateFlowTemplate(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3911 var errorBuffer bytes.Buffer 3912 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3913 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3914 } 3915 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3916 3917 errorCode := "UnknownError" 3918 errorMessage := errorCode 3919 3920 code := response.Header.Get("X-Amzn-ErrorType") 3921 if len(code) != 0 { 3922 errorCode = restjson.SanitizeErrorCode(code) 3923 } 3924 3925 var buff [1024]byte 3926 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3927 3928 body := io.TeeReader(errorBody, ringBuffer) 3929 decoder := json.NewDecoder(body) 3930 decoder.UseNumber() 3931 code, message, err := restjson.GetErrorInfo(decoder) 3932 if err != nil { 3933 var snapshot bytes.Buffer 3934 io.Copy(&snapshot, ringBuffer) 3935 err = &smithy.DeserializationError{ 3936 Err: fmt.Errorf("failed to decode response body, %w", err), 3937 Snapshot: snapshot.Bytes(), 3938 } 3939 return err 3940 } 3941 3942 errorBody.Seek(0, io.SeekStart) 3943 if len(code) != 0 { 3944 errorCode = restjson.SanitizeErrorCode(code) 3945 } 3946 if len(message) != 0 { 3947 errorMessage = message 3948 } 3949 3950 switch { 3951 case strings.EqualFold("InternalFailureException", errorCode): 3952 return awsAwsjson11_deserializeErrorInternalFailureException(response, errorBody) 3953 3954 case strings.EqualFold("InvalidRequestException", errorCode): 3955 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 3956 3957 case strings.EqualFold("ResourceNotFoundException", errorCode): 3958 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 3959 3960 case strings.EqualFold("ThrottlingException", errorCode): 3961 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 3962 3963 default: 3964 genericError := &smithy.GenericAPIError{ 3965 Code: errorCode, 3966 Message: errorMessage, 3967 } 3968 return genericError 3969 3970 } 3971} 3972 3973type awsAwsjson11_deserializeOpUpdateSystemTemplate struct { 3974} 3975 3976func (*awsAwsjson11_deserializeOpUpdateSystemTemplate) ID() string { 3977 return "OperationDeserializer" 3978} 3979 3980func (m *awsAwsjson11_deserializeOpUpdateSystemTemplate) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3981 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3982) { 3983 out, metadata, err = next.HandleDeserialize(ctx, in) 3984 if err != nil { 3985 return out, metadata, err 3986 } 3987 3988 response, ok := out.RawResponse.(*smithyhttp.Response) 3989 if !ok { 3990 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3991 } 3992 3993 if response.StatusCode < 200 || response.StatusCode >= 300 { 3994 return out, metadata, awsAwsjson11_deserializeOpErrorUpdateSystemTemplate(response, &metadata) 3995 } 3996 output := &UpdateSystemTemplateOutput{} 3997 out.Result = output 3998 3999 var buff [1024]byte 4000 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4001 4002 body := io.TeeReader(response.Body, ringBuffer) 4003 decoder := json.NewDecoder(body) 4004 decoder.UseNumber() 4005 var shape interface{} 4006 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4007 var snapshot bytes.Buffer 4008 io.Copy(&snapshot, ringBuffer) 4009 err = &smithy.DeserializationError{ 4010 Err: fmt.Errorf("failed to decode response body, %w", err), 4011 Snapshot: snapshot.Bytes(), 4012 } 4013 return out, metadata, err 4014 } 4015 4016 err = awsAwsjson11_deserializeOpDocumentUpdateSystemTemplateOutput(&output, shape) 4017 if err != nil { 4018 var snapshot bytes.Buffer 4019 io.Copy(&snapshot, ringBuffer) 4020 err = &smithy.DeserializationError{ 4021 Err: fmt.Errorf("failed to decode response body, %w", err), 4022 Snapshot: snapshot.Bytes(), 4023 } 4024 return out, metadata, err 4025 } 4026 4027 return out, metadata, err 4028} 4029 4030func awsAwsjson11_deserializeOpErrorUpdateSystemTemplate(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4031 var errorBuffer bytes.Buffer 4032 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4033 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4034 } 4035 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4036 4037 errorCode := "UnknownError" 4038 errorMessage := errorCode 4039 4040 code := response.Header.Get("X-Amzn-ErrorType") 4041 if len(code) != 0 { 4042 errorCode = restjson.SanitizeErrorCode(code) 4043 } 4044 4045 var buff [1024]byte 4046 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4047 4048 body := io.TeeReader(errorBody, ringBuffer) 4049 decoder := json.NewDecoder(body) 4050 decoder.UseNumber() 4051 code, message, err := restjson.GetErrorInfo(decoder) 4052 if err != nil { 4053 var snapshot bytes.Buffer 4054 io.Copy(&snapshot, ringBuffer) 4055 err = &smithy.DeserializationError{ 4056 Err: fmt.Errorf("failed to decode response body, %w", err), 4057 Snapshot: snapshot.Bytes(), 4058 } 4059 return err 4060 } 4061 4062 errorBody.Seek(0, io.SeekStart) 4063 if len(code) != 0 { 4064 errorCode = restjson.SanitizeErrorCode(code) 4065 } 4066 if len(message) != 0 { 4067 errorMessage = message 4068 } 4069 4070 switch { 4071 case strings.EqualFold("InternalFailureException", errorCode): 4072 return awsAwsjson11_deserializeErrorInternalFailureException(response, errorBody) 4073 4074 case strings.EqualFold("InvalidRequestException", errorCode): 4075 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 4076 4077 case strings.EqualFold("ResourceNotFoundException", errorCode): 4078 return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody) 4079 4080 case strings.EqualFold("ThrottlingException", errorCode): 4081 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 4082 4083 default: 4084 genericError := &smithy.GenericAPIError{ 4085 Code: errorCode, 4086 Message: errorMessage, 4087 } 4088 return genericError 4089 4090 } 4091} 4092 4093type awsAwsjson11_deserializeOpUploadEntityDefinitions struct { 4094} 4095 4096func (*awsAwsjson11_deserializeOpUploadEntityDefinitions) ID() string { 4097 return "OperationDeserializer" 4098} 4099 4100func (m *awsAwsjson11_deserializeOpUploadEntityDefinitions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4101 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4102) { 4103 out, metadata, err = next.HandleDeserialize(ctx, in) 4104 if err != nil { 4105 return out, metadata, err 4106 } 4107 4108 response, ok := out.RawResponse.(*smithyhttp.Response) 4109 if !ok { 4110 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4111 } 4112 4113 if response.StatusCode < 200 || response.StatusCode >= 300 { 4114 return out, metadata, awsAwsjson11_deserializeOpErrorUploadEntityDefinitions(response, &metadata) 4115 } 4116 output := &UploadEntityDefinitionsOutput{} 4117 out.Result = output 4118 4119 var buff [1024]byte 4120 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4121 4122 body := io.TeeReader(response.Body, ringBuffer) 4123 decoder := json.NewDecoder(body) 4124 decoder.UseNumber() 4125 var shape interface{} 4126 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4127 var snapshot bytes.Buffer 4128 io.Copy(&snapshot, ringBuffer) 4129 err = &smithy.DeserializationError{ 4130 Err: fmt.Errorf("failed to decode response body, %w", err), 4131 Snapshot: snapshot.Bytes(), 4132 } 4133 return out, metadata, err 4134 } 4135 4136 err = awsAwsjson11_deserializeOpDocumentUploadEntityDefinitionsOutput(&output, shape) 4137 if err != nil { 4138 var snapshot bytes.Buffer 4139 io.Copy(&snapshot, ringBuffer) 4140 err = &smithy.DeserializationError{ 4141 Err: fmt.Errorf("failed to decode response body, %w", err), 4142 Snapshot: snapshot.Bytes(), 4143 } 4144 return out, metadata, err 4145 } 4146 4147 return out, metadata, err 4148} 4149 4150func awsAwsjson11_deserializeOpErrorUploadEntityDefinitions(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4151 var errorBuffer bytes.Buffer 4152 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4153 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4154 } 4155 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4156 4157 errorCode := "UnknownError" 4158 errorMessage := errorCode 4159 4160 code := response.Header.Get("X-Amzn-ErrorType") 4161 if len(code) != 0 { 4162 errorCode = restjson.SanitizeErrorCode(code) 4163 } 4164 4165 var buff [1024]byte 4166 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4167 4168 body := io.TeeReader(errorBody, ringBuffer) 4169 decoder := json.NewDecoder(body) 4170 decoder.UseNumber() 4171 code, message, err := restjson.GetErrorInfo(decoder) 4172 if err != nil { 4173 var snapshot bytes.Buffer 4174 io.Copy(&snapshot, ringBuffer) 4175 err = &smithy.DeserializationError{ 4176 Err: fmt.Errorf("failed to decode response body, %w", err), 4177 Snapshot: snapshot.Bytes(), 4178 } 4179 return err 4180 } 4181 4182 errorBody.Seek(0, io.SeekStart) 4183 if len(code) != 0 { 4184 errorCode = restjson.SanitizeErrorCode(code) 4185 } 4186 if len(message) != 0 { 4187 errorMessage = message 4188 } 4189 4190 switch { 4191 case strings.EqualFold("InternalFailureException", errorCode): 4192 return awsAwsjson11_deserializeErrorInternalFailureException(response, errorBody) 4193 4194 case strings.EqualFold("InvalidRequestException", errorCode): 4195 return awsAwsjson11_deserializeErrorInvalidRequestException(response, errorBody) 4196 4197 case strings.EqualFold("ThrottlingException", errorCode): 4198 return awsAwsjson11_deserializeErrorThrottlingException(response, errorBody) 4199 4200 default: 4201 genericError := &smithy.GenericAPIError{ 4202 Code: errorCode, 4203 Message: errorMessage, 4204 } 4205 return genericError 4206 4207 } 4208} 4209 4210func awsAwsjson11_deserializeErrorInternalFailureException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4211 var buff [1024]byte 4212 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4213 4214 body := io.TeeReader(errorBody, ringBuffer) 4215 decoder := json.NewDecoder(body) 4216 decoder.UseNumber() 4217 var shape interface{} 4218 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4219 var snapshot bytes.Buffer 4220 io.Copy(&snapshot, ringBuffer) 4221 err = &smithy.DeserializationError{ 4222 Err: fmt.Errorf("failed to decode response body, %w", err), 4223 Snapshot: snapshot.Bytes(), 4224 } 4225 return err 4226 } 4227 4228 output := &types.InternalFailureException{} 4229 err := awsAwsjson11_deserializeDocumentInternalFailureException(&output, shape) 4230 4231 if err != nil { 4232 var snapshot bytes.Buffer 4233 io.Copy(&snapshot, ringBuffer) 4234 err = &smithy.DeserializationError{ 4235 Err: fmt.Errorf("failed to decode response body, %w", err), 4236 Snapshot: snapshot.Bytes(), 4237 } 4238 return err 4239 } 4240 4241 errorBody.Seek(0, io.SeekStart) 4242 return output 4243} 4244 4245func awsAwsjson11_deserializeErrorInvalidRequestException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4246 var buff [1024]byte 4247 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4248 4249 body := io.TeeReader(errorBody, ringBuffer) 4250 decoder := json.NewDecoder(body) 4251 decoder.UseNumber() 4252 var shape interface{} 4253 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4254 var snapshot bytes.Buffer 4255 io.Copy(&snapshot, ringBuffer) 4256 err = &smithy.DeserializationError{ 4257 Err: fmt.Errorf("failed to decode response body, %w", err), 4258 Snapshot: snapshot.Bytes(), 4259 } 4260 return err 4261 } 4262 4263 output := &types.InvalidRequestException{} 4264 err := awsAwsjson11_deserializeDocumentInvalidRequestException(&output, shape) 4265 4266 if err != nil { 4267 var snapshot bytes.Buffer 4268 io.Copy(&snapshot, ringBuffer) 4269 err = &smithy.DeserializationError{ 4270 Err: fmt.Errorf("failed to decode response body, %w", err), 4271 Snapshot: snapshot.Bytes(), 4272 } 4273 return err 4274 } 4275 4276 errorBody.Seek(0, io.SeekStart) 4277 return output 4278} 4279 4280func awsAwsjson11_deserializeErrorLimitExceededException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4281 var buff [1024]byte 4282 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4283 4284 body := io.TeeReader(errorBody, ringBuffer) 4285 decoder := json.NewDecoder(body) 4286 decoder.UseNumber() 4287 var shape interface{} 4288 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4289 var snapshot bytes.Buffer 4290 io.Copy(&snapshot, ringBuffer) 4291 err = &smithy.DeserializationError{ 4292 Err: fmt.Errorf("failed to decode response body, %w", err), 4293 Snapshot: snapshot.Bytes(), 4294 } 4295 return err 4296 } 4297 4298 output := &types.LimitExceededException{} 4299 err := awsAwsjson11_deserializeDocumentLimitExceededException(&output, shape) 4300 4301 if err != nil { 4302 var snapshot bytes.Buffer 4303 io.Copy(&snapshot, ringBuffer) 4304 err = &smithy.DeserializationError{ 4305 Err: fmt.Errorf("failed to decode response body, %w", err), 4306 Snapshot: snapshot.Bytes(), 4307 } 4308 return err 4309 } 4310 4311 errorBody.Seek(0, io.SeekStart) 4312 return output 4313} 4314 4315func awsAwsjson11_deserializeErrorResourceAlreadyExistsException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4316 var buff [1024]byte 4317 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4318 4319 body := io.TeeReader(errorBody, ringBuffer) 4320 decoder := json.NewDecoder(body) 4321 decoder.UseNumber() 4322 var shape interface{} 4323 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4324 var snapshot bytes.Buffer 4325 io.Copy(&snapshot, ringBuffer) 4326 err = &smithy.DeserializationError{ 4327 Err: fmt.Errorf("failed to decode response body, %w", err), 4328 Snapshot: snapshot.Bytes(), 4329 } 4330 return err 4331 } 4332 4333 output := &types.ResourceAlreadyExistsException{} 4334 err := awsAwsjson11_deserializeDocumentResourceAlreadyExistsException(&output, shape) 4335 4336 if err != nil { 4337 var snapshot bytes.Buffer 4338 io.Copy(&snapshot, ringBuffer) 4339 err = &smithy.DeserializationError{ 4340 Err: fmt.Errorf("failed to decode response body, %w", err), 4341 Snapshot: snapshot.Bytes(), 4342 } 4343 return err 4344 } 4345 4346 errorBody.Seek(0, io.SeekStart) 4347 return output 4348} 4349 4350func awsAwsjson11_deserializeErrorResourceInUseException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4351 var buff [1024]byte 4352 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4353 4354 body := io.TeeReader(errorBody, ringBuffer) 4355 decoder := json.NewDecoder(body) 4356 decoder.UseNumber() 4357 var shape interface{} 4358 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4359 var snapshot bytes.Buffer 4360 io.Copy(&snapshot, ringBuffer) 4361 err = &smithy.DeserializationError{ 4362 Err: fmt.Errorf("failed to decode response body, %w", err), 4363 Snapshot: snapshot.Bytes(), 4364 } 4365 return err 4366 } 4367 4368 output := &types.ResourceInUseException{} 4369 err := awsAwsjson11_deserializeDocumentResourceInUseException(&output, shape) 4370 4371 if err != nil { 4372 var snapshot bytes.Buffer 4373 io.Copy(&snapshot, ringBuffer) 4374 err = &smithy.DeserializationError{ 4375 Err: fmt.Errorf("failed to decode response body, %w", err), 4376 Snapshot: snapshot.Bytes(), 4377 } 4378 return err 4379 } 4380 4381 errorBody.Seek(0, io.SeekStart) 4382 return output 4383} 4384 4385func awsAwsjson11_deserializeErrorResourceNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4386 var buff [1024]byte 4387 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4388 4389 body := io.TeeReader(errorBody, ringBuffer) 4390 decoder := json.NewDecoder(body) 4391 decoder.UseNumber() 4392 var shape interface{} 4393 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4394 var snapshot bytes.Buffer 4395 io.Copy(&snapshot, ringBuffer) 4396 err = &smithy.DeserializationError{ 4397 Err: fmt.Errorf("failed to decode response body, %w", err), 4398 Snapshot: snapshot.Bytes(), 4399 } 4400 return err 4401 } 4402 4403 output := &types.ResourceNotFoundException{} 4404 err := awsAwsjson11_deserializeDocumentResourceNotFoundException(&output, shape) 4405 4406 if err != nil { 4407 var snapshot bytes.Buffer 4408 io.Copy(&snapshot, ringBuffer) 4409 err = &smithy.DeserializationError{ 4410 Err: fmt.Errorf("failed to decode response body, %w", err), 4411 Snapshot: snapshot.Bytes(), 4412 } 4413 return err 4414 } 4415 4416 errorBody.Seek(0, io.SeekStart) 4417 return output 4418} 4419 4420func awsAwsjson11_deserializeErrorThrottlingException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 4421 var buff [1024]byte 4422 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4423 4424 body := io.TeeReader(errorBody, ringBuffer) 4425 decoder := json.NewDecoder(body) 4426 decoder.UseNumber() 4427 var shape interface{} 4428 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4429 var snapshot bytes.Buffer 4430 io.Copy(&snapshot, ringBuffer) 4431 err = &smithy.DeserializationError{ 4432 Err: fmt.Errorf("failed to decode response body, %w", err), 4433 Snapshot: snapshot.Bytes(), 4434 } 4435 return err 4436 } 4437 4438 output := &types.ThrottlingException{} 4439 err := awsAwsjson11_deserializeDocumentThrottlingException(&output, shape) 4440 4441 if err != nil { 4442 var snapshot bytes.Buffer 4443 io.Copy(&snapshot, ringBuffer) 4444 err = &smithy.DeserializationError{ 4445 Err: fmt.Errorf("failed to decode response body, %w", err), 4446 Snapshot: snapshot.Bytes(), 4447 } 4448 return err 4449 } 4450 4451 errorBody.Seek(0, io.SeekStart) 4452 return output 4453} 4454 4455func awsAwsjson11_deserializeDocumentDefinitionDocument(v **types.DefinitionDocument, value interface{}) error { 4456 if v == nil { 4457 return fmt.Errorf("unexpected nil of type %T", v) 4458 } 4459 if value == nil { 4460 return nil 4461 } 4462 4463 shape, ok := value.(map[string]interface{}) 4464 if !ok { 4465 return fmt.Errorf("unexpected JSON type %v", value) 4466 } 4467 4468 var sv *types.DefinitionDocument 4469 if *v == nil { 4470 sv = &types.DefinitionDocument{} 4471 } else { 4472 sv = *v 4473 } 4474 4475 for key, value := range shape { 4476 switch key { 4477 case "language": 4478 if value != nil { 4479 jtv, ok := value.(string) 4480 if !ok { 4481 return fmt.Errorf("expected DefinitionLanguage to be of type string, got %T instead", value) 4482 } 4483 sv.Language = types.DefinitionLanguage(jtv) 4484 } 4485 4486 case "text": 4487 if value != nil { 4488 jtv, ok := value.(string) 4489 if !ok { 4490 return fmt.Errorf("expected DefinitionText to be of type string, got %T instead", value) 4491 } 4492 sv.Text = ptr.String(jtv) 4493 } 4494 4495 default: 4496 _, _ = key, value 4497 4498 } 4499 } 4500 *v = sv 4501 return nil 4502} 4503 4504func awsAwsjson11_deserializeDocumentDependencyRevision(v **types.DependencyRevision, value interface{}) error { 4505 if v == nil { 4506 return fmt.Errorf("unexpected nil of type %T", v) 4507 } 4508 if value == nil { 4509 return nil 4510 } 4511 4512 shape, ok := value.(map[string]interface{}) 4513 if !ok { 4514 return fmt.Errorf("unexpected JSON type %v", value) 4515 } 4516 4517 var sv *types.DependencyRevision 4518 if *v == nil { 4519 sv = &types.DependencyRevision{} 4520 } else { 4521 sv = *v 4522 } 4523 4524 for key, value := range shape { 4525 switch key { 4526 case "id": 4527 if value != nil { 4528 jtv, ok := value.(string) 4529 if !ok { 4530 return fmt.Errorf("expected Urn to be of type string, got %T instead", value) 4531 } 4532 sv.Id = ptr.String(jtv) 4533 } 4534 4535 case "revisionNumber": 4536 if value != nil { 4537 jtv, ok := value.(json.Number) 4538 if !ok { 4539 return fmt.Errorf("expected Version to be json.Number, got %T instead", value) 4540 } 4541 i64, err := jtv.Int64() 4542 if err != nil { 4543 return err 4544 } 4545 sv.RevisionNumber = ptr.Int64(i64) 4546 } 4547 4548 default: 4549 _, _ = key, value 4550 4551 } 4552 } 4553 *v = sv 4554 return nil 4555} 4556 4557func awsAwsjson11_deserializeDocumentDependencyRevisions(v *[]types.DependencyRevision, value interface{}) error { 4558 if v == nil { 4559 return fmt.Errorf("unexpected nil of type %T", v) 4560 } 4561 if value == nil { 4562 return nil 4563 } 4564 4565 shape, ok := value.([]interface{}) 4566 if !ok { 4567 return fmt.Errorf("unexpected JSON type %v", value) 4568 } 4569 4570 var cv []types.DependencyRevision 4571 if *v == nil { 4572 cv = []types.DependencyRevision{} 4573 } else { 4574 cv = *v 4575 } 4576 4577 for _, value := range shape { 4578 var col types.DependencyRevision 4579 destAddr := &col 4580 if err := awsAwsjson11_deserializeDocumentDependencyRevision(&destAddr, value); err != nil { 4581 return err 4582 } 4583 col = *destAddr 4584 cv = append(cv, col) 4585 4586 } 4587 *v = cv 4588 return nil 4589} 4590 4591func awsAwsjson11_deserializeDocumentEntityDescription(v **types.EntityDescription, value interface{}) error { 4592 if v == nil { 4593 return fmt.Errorf("unexpected nil of type %T", v) 4594 } 4595 if value == nil { 4596 return nil 4597 } 4598 4599 shape, ok := value.(map[string]interface{}) 4600 if !ok { 4601 return fmt.Errorf("unexpected JSON type %v", value) 4602 } 4603 4604 var sv *types.EntityDescription 4605 if *v == nil { 4606 sv = &types.EntityDescription{} 4607 } else { 4608 sv = *v 4609 } 4610 4611 for key, value := range shape { 4612 switch key { 4613 case "arn": 4614 if value != nil { 4615 jtv, ok := value.(string) 4616 if !ok { 4617 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 4618 } 4619 sv.Arn = ptr.String(jtv) 4620 } 4621 4622 case "createdAt": 4623 if value != nil { 4624 jtv, ok := value.(json.Number) 4625 if !ok { 4626 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 4627 } 4628 f64, err := jtv.Float64() 4629 if err != nil { 4630 return err 4631 } 4632 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 4633 } 4634 4635 case "definition": 4636 if err := awsAwsjson11_deserializeDocumentDefinitionDocument(&sv.Definition, value); err != nil { 4637 return err 4638 } 4639 4640 case "id": 4641 if value != nil { 4642 jtv, ok := value.(string) 4643 if !ok { 4644 return fmt.Errorf("expected Urn to be of type string, got %T instead", value) 4645 } 4646 sv.Id = ptr.String(jtv) 4647 } 4648 4649 case "type": 4650 if value != nil { 4651 jtv, ok := value.(string) 4652 if !ok { 4653 return fmt.Errorf("expected EntityType to be of type string, got %T instead", value) 4654 } 4655 sv.Type = types.EntityType(jtv) 4656 } 4657 4658 default: 4659 _, _ = key, value 4660 4661 } 4662 } 4663 *v = sv 4664 return nil 4665} 4666 4667func awsAwsjson11_deserializeDocumentEntityDescriptions(v *[]types.EntityDescription, value interface{}) error { 4668 if v == nil { 4669 return fmt.Errorf("unexpected nil of type %T", v) 4670 } 4671 if value == nil { 4672 return nil 4673 } 4674 4675 shape, ok := value.([]interface{}) 4676 if !ok { 4677 return fmt.Errorf("unexpected JSON type %v", value) 4678 } 4679 4680 var cv []types.EntityDescription 4681 if *v == nil { 4682 cv = []types.EntityDescription{} 4683 } else { 4684 cv = *v 4685 } 4686 4687 for _, value := range shape { 4688 var col types.EntityDescription 4689 destAddr := &col 4690 if err := awsAwsjson11_deserializeDocumentEntityDescription(&destAddr, value); err != nil { 4691 return err 4692 } 4693 col = *destAddr 4694 cv = append(cv, col) 4695 4696 } 4697 *v = cv 4698 return nil 4699} 4700 4701func awsAwsjson11_deserializeDocumentFlowExecutionMessage(v **types.FlowExecutionMessage, value interface{}) error { 4702 if v == nil { 4703 return fmt.Errorf("unexpected nil of type %T", v) 4704 } 4705 if value == nil { 4706 return nil 4707 } 4708 4709 shape, ok := value.(map[string]interface{}) 4710 if !ok { 4711 return fmt.Errorf("unexpected JSON type %v", value) 4712 } 4713 4714 var sv *types.FlowExecutionMessage 4715 if *v == nil { 4716 sv = &types.FlowExecutionMessage{} 4717 } else { 4718 sv = *v 4719 } 4720 4721 for key, value := range shape { 4722 switch key { 4723 case "eventType": 4724 if value != nil { 4725 jtv, ok := value.(string) 4726 if !ok { 4727 return fmt.Errorf("expected FlowExecutionEventType to be of type string, got %T instead", value) 4728 } 4729 sv.EventType = types.FlowExecutionEventType(jtv) 4730 } 4731 4732 case "messageId": 4733 if value != nil { 4734 jtv, ok := value.(string) 4735 if !ok { 4736 return fmt.Errorf("expected FlowExecutionMessageId to be of type string, got %T instead", value) 4737 } 4738 sv.MessageId = ptr.String(jtv) 4739 } 4740 4741 case "payload": 4742 if value != nil { 4743 jtv, ok := value.(string) 4744 if !ok { 4745 return fmt.Errorf("expected FlowExecutionMessagePayload to be of type string, got %T instead", value) 4746 } 4747 sv.Payload = ptr.String(jtv) 4748 } 4749 4750 case "timestamp": 4751 if value != nil { 4752 jtv, ok := value.(json.Number) 4753 if !ok { 4754 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 4755 } 4756 f64, err := jtv.Float64() 4757 if err != nil { 4758 return err 4759 } 4760 sv.Timestamp = ptr.Time(smithytime.ParseEpochSeconds(f64)) 4761 } 4762 4763 default: 4764 _, _ = key, value 4765 4766 } 4767 } 4768 *v = sv 4769 return nil 4770} 4771 4772func awsAwsjson11_deserializeDocumentFlowExecutionMessages(v *[]types.FlowExecutionMessage, value interface{}) error { 4773 if v == nil { 4774 return fmt.Errorf("unexpected nil of type %T", v) 4775 } 4776 if value == nil { 4777 return nil 4778 } 4779 4780 shape, ok := value.([]interface{}) 4781 if !ok { 4782 return fmt.Errorf("unexpected JSON type %v", value) 4783 } 4784 4785 var cv []types.FlowExecutionMessage 4786 if *v == nil { 4787 cv = []types.FlowExecutionMessage{} 4788 } else { 4789 cv = *v 4790 } 4791 4792 for _, value := range shape { 4793 var col types.FlowExecutionMessage 4794 destAddr := &col 4795 if err := awsAwsjson11_deserializeDocumentFlowExecutionMessage(&destAddr, value); err != nil { 4796 return err 4797 } 4798 col = *destAddr 4799 cv = append(cv, col) 4800 4801 } 4802 *v = cv 4803 return nil 4804} 4805 4806func awsAwsjson11_deserializeDocumentFlowExecutionSummaries(v *[]types.FlowExecutionSummary, value interface{}) error { 4807 if v == nil { 4808 return fmt.Errorf("unexpected nil of type %T", v) 4809 } 4810 if value == nil { 4811 return nil 4812 } 4813 4814 shape, ok := value.([]interface{}) 4815 if !ok { 4816 return fmt.Errorf("unexpected JSON type %v", value) 4817 } 4818 4819 var cv []types.FlowExecutionSummary 4820 if *v == nil { 4821 cv = []types.FlowExecutionSummary{} 4822 } else { 4823 cv = *v 4824 } 4825 4826 for _, value := range shape { 4827 var col types.FlowExecutionSummary 4828 destAddr := &col 4829 if err := awsAwsjson11_deserializeDocumentFlowExecutionSummary(&destAddr, value); err != nil { 4830 return err 4831 } 4832 col = *destAddr 4833 cv = append(cv, col) 4834 4835 } 4836 *v = cv 4837 return nil 4838} 4839 4840func awsAwsjson11_deserializeDocumentFlowExecutionSummary(v **types.FlowExecutionSummary, value interface{}) error { 4841 if v == nil { 4842 return fmt.Errorf("unexpected nil of type %T", v) 4843 } 4844 if value == nil { 4845 return nil 4846 } 4847 4848 shape, ok := value.(map[string]interface{}) 4849 if !ok { 4850 return fmt.Errorf("unexpected JSON type %v", value) 4851 } 4852 4853 var sv *types.FlowExecutionSummary 4854 if *v == nil { 4855 sv = &types.FlowExecutionSummary{} 4856 } else { 4857 sv = *v 4858 } 4859 4860 for key, value := range shape { 4861 switch key { 4862 case "createdAt": 4863 if value != nil { 4864 jtv, ok := value.(json.Number) 4865 if !ok { 4866 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 4867 } 4868 f64, err := jtv.Float64() 4869 if err != nil { 4870 return err 4871 } 4872 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 4873 } 4874 4875 case "flowExecutionId": 4876 if value != nil { 4877 jtv, ok := value.(string) 4878 if !ok { 4879 return fmt.Errorf("expected FlowExecutionId to be of type string, got %T instead", value) 4880 } 4881 sv.FlowExecutionId = ptr.String(jtv) 4882 } 4883 4884 case "flowTemplateId": 4885 if value != nil { 4886 jtv, ok := value.(string) 4887 if !ok { 4888 return fmt.Errorf("expected Urn to be of type string, got %T instead", value) 4889 } 4890 sv.FlowTemplateId = ptr.String(jtv) 4891 } 4892 4893 case "status": 4894 if value != nil { 4895 jtv, ok := value.(string) 4896 if !ok { 4897 return fmt.Errorf("expected FlowExecutionStatus to be of type string, got %T instead", value) 4898 } 4899 sv.Status = types.FlowExecutionStatus(jtv) 4900 } 4901 4902 case "systemInstanceId": 4903 if value != nil { 4904 jtv, ok := value.(string) 4905 if !ok { 4906 return fmt.Errorf("expected Urn to be of type string, got %T instead", value) 4907 } 4908 sv.SystemInstanceId = ptr.String(jtv) 4909 } 4910 4911 case "updatedAt": 4912 if value != nil { 4913 jtv, ok := value.(json.Number) 4914 if !ok { 4915 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 4916 } 4917 f64, err := jtv.Float64() 4918 if err != nil { 4919 return err 4920 } 4921 sv.UpdatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 4922 } 4923 4924 default: 4925 _, _ = key, value 4926 4927 } 4928 } 4929 *v = sv 4930 return nil 4931} 4932 4933func awsAwsjson11_deserializeDocumentFlowTemplateDescription(v **types.FlowTemplateDescription, value interface{}) error { 4934 if v == nil { 4935 return fmt.Errorf("unexpected nil of type %T", v) 4936 } 4937 if value == nil { 4938 return nil 4939 } 4940 4941 shape, ok := value.(map[string]interface{}) 4942 if !ok { 4943 return fmt.Errorf("unexpected JSON type %v", value) 4944 } 4945 4946 var sv *types.FlowTemplateDescription 4947 if *v == nil { 4948 sv = &types.FlowTemplateDescription{} 4949 } else { 4950 sv = *v 4951 } 4952 4953 for key, value := range shape { 4954 switch key { 4955 case "definition": 4956 if err := awsAwsjson11_deserializeDocumentDefinitionDocument(&sv.Definition, value); err != nil { 4957 return err 4958 } 4959 4960 case "summary": 4961 if err := awsAwsjson11_deserializeDocumentFlowTemplateSummary(&sv.Summary, value); err != nil { 4962 return err 4963 } 4964 4965 case "validatedNamespaceVersion": 4966 if value != nil { 4967 jtv, ok := value.(json.Number) 4968 if !ok { 4969 return fmt.Errorf("expected Version to be json.Number, got %T instead", value) 4970 } 4971 i64, err := jtv.Int64() 4972 if err != nil { 4973 return err 4974 } 4975 sv.ValidatedNamespaceVersion = ptr.Int64(i64) 4976 } 4977 4978 default: 4979 _, _ = key, value 4980 4981 } 4982 } 4983 *v = sv 4984 return nil 4985} 4986 4987func awsAwsjson11_deserializeDocumentFlowTemplateSummaries(v *[]types.FlowTemplateSummary, value interface{}) error { 4988 if v == nil { 4989 return fmt.Errorf("unexpected nil of type %T", v) 4990 } 4991 if value == nil { 4992 return nil 4993 } 4994 4995 shape, ok := value.([]interface{}) 4996 if !ok { 4997 return fmt.Errorf("unexpected JSON type %v", value) 4998 } 4999 5000 var cv []types.FlowTemplateSummary 5001 if *v == nil { 5002 cv = []types.FlowTemplateSummary{} 5003 } else { 5004 cv = *v 5005 } 5006 5007 for _, value := range shape { 5008 var col types.FlowTemplateSummary 5009 destAddr := &col 5010 if err := awsAwsjson11_deserializeDocumentFlowTemplateSummary(&destAddr, value); err != nil { 5011 return err 5012 } 5013 col = *destAddr 5014 cv = append(cv, col) 5015 5016 } 5017 *v = cv 5018 return nil 5019} 5020 5021func awsAwsjson11_deserializeDocumentFlowTemplateSummary(v **types.FlowTemplateSummary, value interface{}) error { 5022 if v == nil { 5023 return fmt.Errorf("unexpected nil of type %T", v) 5024 } 5025 if value == nil { 5026 return nil 5027 } 5028 5029 shape, ok := value.(map[string]interface{}) 5030 if !ok { 5031 return fmt.Errorf("unexpected JSON type %v", value) 5032 } 5033 5034 var sv *types.FlowTemplateSummary 5035 if *v == nil { 5036 sv = &types.FlowTemplateSummary{} 5037 } else { 5038 sv = *v 5039 } 5040 5041 for key, value := range shape { 5042 switch key { 5043 case "arn": 5044 if value != nil { 5045 jtv, ok := value.(string) 5046 if !ok { 5047 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 5048 } 5049 sv.Arn = ptr.String(jtv) 5050 } 5051 5052 case "createdAt": 5053 if value != nil { 5054 jtv, ok := value.(json.Number) 5055 if !ok { 5056 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 5057 } 5058 f64, err := jtv.Float64() 5059 if err != nil { 5060 return err 5061 } 5062 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 5063 } 5064 5065 case "id": 5066 if value != nil { 5067 jtv, ok := value.(string) 5068 if !ok { 5069 return fmt.Errorf("expected Urn to be of type string, got %T instead", value) 5070 } 5071 sv.Id = ptr.String(jtv) 5072 } 5073 5074 case "revisionNumber": 5075 if value != nil { 5076 jtv, ok := value.(json.Number) 5077 if !ok { 5078 return fmt.Errorf("expected Version to be json.Number, got %T instead", value) 5079 } 5080 i64, err := jtv.Int64() 5081 if err != nil { 5082 return err 5083 } 5084 sv.RevisionNumber = ptr.Int64(i64) 5085 } 5086 5087 default: 5088 _, _ = key, value 5089 5090 } 5091 } 5092 *v = sv 5093 return nil 5094} 5095 5096func awsAwsjson11_deserializeDocumentInternalFailureException(v **types.InternalFailureException, value interface{}) error { 5097 if v == nil { 5098 return fmt.Errorf("unexpected nil of type %T", v) 5099 } 5100 if value == nil { 5101 return nil 5102 } 5103 5104 shape, ok := value.(map[string]interface{}) 5105 if !ok { 5106 return fmt.Errorf("unexpected JSON type %v", value) 5107 } 5108 5109 var sv *types.InternalFailureException 5110 if *v == nil { 5111 sv = &types.InternalFailureException{} 5112 } else { 5113 sv = *v 5114 } 5115 5116 for key, value := range shape { 5117 switch key { 5118 case "message": 5119 if value != nil { 5120 jtv, ok := value.(string) 5121 if !ok { 5122 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 5123 } 5124 sv.Message = ptr.String(jtv) 5125 } 5126 5127 default: 5128 _, _ = key, value 5129 5130 } 5131 } 5132 *v = sv 5133 return nil 5134} 5135 5136func awsAwsjson11_deserializeDocumentInvalidRequestException(v **types.InvalidRequestException, value interface{}) error { 5137 if v == nil { 5138 return fmt.Errorf("unexpected nil of type %T", v) 5139 } 5140 if value == nil { 5141 return nil 5142 } 5143 5144 shape, ok := value.(map[string]interface{}) 5145 if !ok { 5146 return fmt.Errorf("unexpected JSON type %v", value) 5147 } 5148 5149 var sv *types.InvalidRequestException 5150 if *v == nil { 5151 sv = &types.InvalidRequestException{} 5152 } else { 5153 sv = *v 5154 } 5155 5156 for key, value := range shape { 5157 switch key { 5158 case "message": 5159 if value != nil { 5160 jtv, ok := value.(string) 5161 if !ok { 5162 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 5163 } 5164 sv.Message = ptr.String(jtv) 5165 } 5166 5167 default: 5168 _, _ = key, value 5169 5170 } 5171 } 5172 *v = sv 5173 return nil 5174} 5175 5176func awsAwsjson11_deserializeDocumentLimitExceededException(v **types.LimitExceededException, value interface{}) error { 5177 if v == nil { 5178 return fmt.Errorf("unexpected nil of type %T", v) 5179 } 5180 if value == nil { 5181 return nil 5182 } 5183 5184 shape, ok := value.(map[string]interface{}) 5185 if !ok { 5186 return fmt.Errorf("unexpected JSON type %v", value) 5187 } 5188 5189 var sv *types.LimitExceededException 5190 if *v == nil { 5191 sv = &types.LimitExceededException{} 5192 } else { 5193 sv = *v 5194 } 5195 5196 for key, value := range shape { 5197 switch key { 5198 case "message": 5199 if value != nil { 5200 jtv, ok := value.(string) 5201 if !ok { 5202 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 5203 } 5204 sv.Message = ptr.String(jtv) 5205 } 5206 5207 default: 5208 _, _ = key, value 5209 5210 } 5211 } 5212 *v = sv 5213 return nil 5214} 5215 5216func awsAwsjson11_deserializeDocumentMetricsConfiguration(v **types.MetricsConfiguration, value interface{}) error { 5217 if v == nil { 5218 return fmt.Errorf("unexpected nil of type %T", v) 5219 } 5220 if value == nil { 5221 return nil 5222 } 5223 5224 shape, ok := value.(map[string]interface{}) 5225 if !ok { 5226 return fmt.Errorf("unexpected JSON type %v", value) 5227 } 5228 5229 var sv *types.MetricsConfiguration 5230 if *v == nil { 5231 sv = &types.MetricsConfiguration{} 5232 } else { 5233 sv = *v 5234 } 5235 5236 for key, value := range shape { 5237 switch key { 5238 case "cloudMetricEnabled": 5239 if value != nil { 5240 jtv, ok := value.(bool) 5241 if !ok { 5242 return fmt.Errorf("expected Enabled to be of type *bool, got %T instead", value) 5243 } 5244 sv.CloudMetricEnabled = jtv 5245 } 5246 5247 case "metricRuleRoleArn": 5248 if value != nil { 5249 jtv, ok := value.(string) 5250 if !ok { 5251 return fmt.Errorf("expected RoleArn to be of type string, got %T instead", value) 5252 } 5253 sv.MetricRuleRoleArn = ptr.String(jtv) 5254 } 5255 5256 default: 5257 _, _ = key, value 5258 5259 } 5260 } 5261 *v = sv 5262 return nil 5263} 5264 5265func awsAwsjson11_deserializeDocumentResourceAlreadyExistsException(v **types.ResourceAlreadyExistsException, value interface{}) error { 5266 if v == nil { 5267 return fmt.Errorf("unexpected nil of type %T", v) 5268 } 5269 if value == nil { 5270 return nil 5271 } 5272 5273 shape, ok := value.(map[string]interface{}) 5274 if !ok { 5275 return fmt.Errorf("unexpected JSON type %v", value) 5276 } 5277 5278 var sv *types.ResourceAlreadyExistsException 5279 if *v == nil { 5280 sv = &types.ResourceAlreadyExistsException{} 5281 } else { 5282 sv = *v 5283 } 5284 5285 for key, value := range shape { 5286 switch key { 5287 case "message": 5288 if value != nil { 5289 jtv, ok := value.(string) 5290 if !ok { 5291 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 5292 } 5293 sv.Message = ptr.String(jtv) 5294 } 5295 5296 default: 5297 _, _ = key, value 5298 5299 } 5300 } 5301 *v = sv 5302 return nil 5303} 5304 5305func awsAwsjson11_deserializeDocumentResourceInUseException(v **types.ResourceInUseException, value interface{}) error { 5306 if v == nil { 5307 return fmt.Errorf("unexpected nil of type %T", v) 5308 } 5309 if value == nil { 5310 return nil 5311 } 5312 5313 shape, ok := value.(map[string]interface{}) 5314 if !ok { 5315 return fmt.Errorf("unexpected JSON type %v", value) 5316 } 5317 5318 var sv *types.ResourceInUseException 5319 if *v == nil { 5320 sv = &types.ResourceInUseException{} 5321 } else { 5322 sv = *v 5323 } 5324 5325 for key, value := range shape { 5326 switch key { 5327 case "message": 5328 if value != nil { 5329 jtv, ok := value.(string) 5330 if !ok { 5331 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 5332 } 5333 sv.Message = ptr.String(jtv) 5334 } 5335 5336 default: 5337 _, _ = key, value 5338 5339 } 5340 } 5341 *v = sv 5342 return nil 5343} 5344 5345func awsAwsjson11_deserializeDocumentResourceNotFoundException(v **types.ResourceNotFoundException, value interface{}) error { 5346 if v == nil { 5347 return fmt.Errorf("unexpected nil of type %T", v) 5348 } 5349 if value == nil { 5350 return nil 5351 } 5352 5353 shape, ok := value.(map[string]interface{}) 5354 if !ok { 5355 return fmt.Errorf("unexpected JSON type %v", value) 5356 } 5357 5358 var sv *types.ResourceNotFoundException 5359 if *v == nil { 5360 sv = &types.ResourceNotFoundException{} 5361 } else { 5362 sv = *v 5363 } 5364 5365 for key, value := range shape { 5366 switch key { 5367 case "message": 5368 if value != nil { 5369 jtv, ok := value.(string) 5370 if !ok { 5371 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 5372 } 5373 sv.Message = ptr.String(jtv) 5374 } 5375 5376 default: 5377 _, _ = key, value 5378 5379 } 5380 } 5381 *v = sv 5382 return nil 5383} 5384 5385func awsAwsjson11_deserializeDocumentStringList(v *[]string, value interface{}) error { 5386 if v == nil { 5387 return fmt.Errorf("unexpected nil of type %T", v) 5388 } 5389 if value == nil { 5390 return nil 5391 } 5392 5393 shape, ok := value.([]interface{}) 5394 if !ok { 5395 return fmt.Errorf("unexpected JSON type %v", value) 5396 } 5397 5398 var cv []string 5399 if *v == nil { 5400 cv = []string{} 5401 } else { 5402 cv = *v 5403 } 5404 5405 for _, value := range shape { 5406 var col string 5407 if value != nil { 5408 jtv, ok := value.(string) 5409 if !ok { 5410 return fmt.Errorf("expected String to be of type string, got %T instead", value) 5411 } 5412 col = jtv 5413 } 5414 cv = append(cv, col) 5415 5416 } 5417 *v = cv 5418 return nil 5419} 5420 5421func awsAwsjson11_deserializeDocumentSystemInstanceDescription(v **types.SystemInstanceDescription, value interface{}) error { 5422 if v == nil { 5423 return fmt.Errorf("unexpected nil of type %T", v) 5424 } 5425 if value == nil { 5426 return nil 5427 } 5428 5429 shape, ok := value.(map[string]interface{}) 5430 if !ok { 5431 return fmt.Errorf("unexpected JSON type %v", value) 5432 } 5433 5434 var sv *types.SystemInstanceDescription 5435 if *v == nil { 5436 sv = &types.SystemInstanceDescription{} 5437 } else { 5438 sv = *v 5439 } 5440 5441 for key, value := range shape { 5442 switch key { 5443 case "definition": 5444 if err := awsAwsjson11_deserializeDocumentDefinitionDocument(&sv.Definition, value); err != nil { 5445 return err 5446 } 5447 5448 case "flowActionsRoleArn": 5449 if value != nil { 5450 jtv, ok := value.(string) 5451 if !ok { 5452 return fmt.Errorf("expected RoleArn to be of type string, got %T instead", value) 5453 } 5454 sv.FlowActionsRoleArn = ptr.String(jtv) 5455 } 5456 5457 case "metricsConfiguration": 5458 if err := awsAwsjson11_deserializeDocumentMetricsConfiguration(&sv.MetricsConfiguration, value); err != nil { 5459 return err 5460 } 5461 5462 case "s3BucketName": 5463 if value != nil { 5464 jtv, ok := value.(string) 5465 if !ok { 5466 return fmt.Errorf("expected S3BucketName to be of type string, got %T instead", value) 5467 } 5468 sv.S3BucketName = ptr.String(jtv) 5469 } 5470 5471 case "summary": 5472 if err := awsAwsjson11_deserializeDocumentSystemInstanceSummary(&sv.Summary, value); err != nil { 5473 return err 5474 } 5475 5476 case "validatedDependencyRevisions": 5477 if err := awsAwsjson11_deserializeDocumentDependencyRevisions(&sv.ValidatedDependencyRevisions, value); err != nil { 5478 return err 5479 } 5480 5481 case "validatedNamespaceVersion": 5482 if value != nil { 5483 jtv, ok := value.(json.Number) 5484 if !ok { 5485 return fmt.Errorf("expected Version to be json.Number, got %T instead", value) 5486 } 5487 i64, err := jtv.Int64() 5488 if err != nil { 5489 return err 5490 } 5491 sv.ValidatedNamespaceVersion = ptr.Int64(i64) 5492 } 5493 5494 default: 5495 _, _ = key, value 5496 5497 } 5498 } 5499 *v = sv 5500 return nil 5501} 5502 5503func awsAwsjson11_deserializeDocumentSystemInstanceSummaries(v *[]types.SystemInstanceSummary, value interface{}) error { 5504 if v == nil { 5505 return fmt.Errorf("unexpected nil of type %T", v) 5506 } 5507 if value == nil { 5508 return nil 5509 } 5510 5511 shape, ok := value.([]interface{}) 5512 if !ok { 5513 return fmt.Errorf("unexpected JSON type %v", value) 5514 } 5515 5516 var cv []types.SystemInstanceSummary 5517 if *v == nil { 5518 cv = []types.SystemInstanceSummary{} 5519 } else { 5520 cv = *v 5521 } 5522 5523 for _, value := range shape { 5524 var col types.SystemInstanceSummary 5525 destAddr := &col 5526 if err := awsAwsjson11_deserializeDocumentSystemInstanceSummary(&destAddr, value); err != nil { 5527 return err 5528 } 5529 col = *destAddr 5530 cv = append(cv, col) 5531 5532 } 5533 *v = cv 5534 return nil 5535} 5536 5537func awsAwsjson11_deserializeDocumentSystemInstanceSummary(v **types.SystemInstanceSummary, value interface{}) error { 5538 if v == nil { 5539 return fmt.Errorf("unexpected nil of type %T", v) 5540 } 5541 if value == nil { 5542 return nil 5543 } 5544 5545 shape, ok := value.(map[string]interface{}) 5546 if !ok { 5547 return fmt.Errorf("unexpected JSON type %v", value) 5548 } 5549 5550 var sv *types.SystemInstanceSummary 5551 if *v == nil { 5552 sv = &types.SystemInstanceSummary{} 5553 } else { 5554 sv = *v 5555 } 5556 5557 for key, value := range shape { 5558 switch key { 5559 case "arn": 5560 if value != nil { 5561 jtv, ok := value.(string) 5562 if !ok { 5563 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 5564 } 5565 sv.Arn = ptr.String(jtv) 5566 } 5567 5568 case "createdAt": 5569 if value != nil { 5570 jtv, ok := value.(json.Number) 5571 if !ok { 5572 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 5573 } 5574 f64, err := jtv.Float64() 5575 if err != nil { 5576 return err 5577 } 5578 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 5579 } 5580 5581 case "greengrassGroupId": 5582 if value != nil { 5583 jtv, ok := value.(string) 5584 if !ok { 5585 return fmt.Errorf("expected GreengrassGroupId to be of type string, got %T instead", value) 5586 } 5587 sv.GreengrassGroupId = ptr.String(jtv) 5588 } 5589 5590 case "greengrassGroupName": 5591 if value != nil { 5592 jtv, ok := value.(string) 5593 if !ok { 5594 return fmt.Errorf("expected GroupName to be of type string, got %T instead", value) 5595 } 5596 sv.GreengrassGroupName = ptr.String(jtv) 5597 } 5598 5599 case "greengrassGroupVersionId": 5600 if value != nil { 5601 jtv, ok := value.(string) 5602 if !ok { 5603 return fmt.Errorf("expected GreengrassGroupVersionId to be of type string, got %T instead", value) 5604 } 5605 sv.GreengrassGroupVersionId = ptr.String(jtv) 5606 } 5607 5608 case "id": 5609 if value != nil { 5610 jtv, ok := value.(string) 5611 if !ok { 5612 return fmt.Errorf("expected Urn to be of type string, got %T instead", value) 5613 } 5614 sv.Id = ptr.String(jtv) 5615 } 5616 5617 case "status": 5618 if value != nil { 5619 jtv, ok := value.(string) 5620 if !ok { 5621 return fmt.Errorf("expected SystemInstanceDeploymentStatus to be of type string, got %T instead", value) 5622 } 5623 sv.Status = types.SystemInstanceDeploymentStatus(jtv) 5624 } 5625 5626 case "target": 5627 if value != nil { 5628 jtv, ok := value.(string) 5629 if !ok { 5630 return fmt.Errorf("expected DeploymentTarget to be of type string, got %T instead", value) 5631 } 5632 sv.Target = types.DeploymentTarget(jtv) 5633 } 5634 5635 case "updatedAt": 5636 if value != nil { 5637 jtv, ok := value.(json.Number) 5638 if !ok { 5639 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 5640 } 5641 f64, err := jtv.Float64() 5642 if err != nil { 5643 return err 5644 } 5645 sv.UpdatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 5646 } 5647 5648 default: 5649 _, _ = key, value 5650 5651 } 5652 } 5653 *v = sv 5654 return nil 5655} 5656 5657func awsAwsjson11_deserializeDocumentSystemTemplateDescription(v **types.SystemTemplateDescription, value interface{}) error { 5658 if v == nil { 5659 return fmt.Errorf("unexpected nil of type %T", v) 5660 } 5661 if value == nil { 5662 return nil 5663 } 5664 5665 shape, ok := value.(map[string]interface{}) 5666 if !ok { 5667 return fmt.Errorf("unexpected JSON type %v", value) 5668 } 5669 5670 var sv *types.SystemTemplateDescription 5671 if *v == nil { 5672 sv = &types.SystemTemplateDescription{} 5673 } else { 5674 sv = *v 5675 } 5676 5677 for key, value := range shape { 5678 switch key { 5679 case "definition": 5680 if err := awsAwsjson11_deserializeDocumentDefinitionDocument(&sv.Definition, value); err != nil { 5681 return err 5682 } 5683 5684 case "summary": 5685 if err := awsAwsjson11_deserializeDocumentSystemTemplateSummary(&sv.Summary, value); err != nil { 5686 return err 5687 } 5688 5689 case "validatedNamespaceVersion": 5690 if value != nil { 5691 jtv, ok := value.(json.Number) 5692 if !ok { 5693 return fmt.Errorf("expected Version to be json.Number, got %T instead", value) 5694 } 5695 i64, err := jtv.Int64() 5696 if err != nil { 5697 return err 5698 } 5699 sv.ValidatedNamespaceVersion = ptr.Int64(i64) 5700 } 5701 5702 default: 5703 _, _ = key, value 5704 5705 } 5706 } 5707 *v = sv 5708 return nil 5709} 5710 5711func awsAwsjson11_deserializeDocumentSystemTemplateSummaries(v *[]types.SystemTemplateSummary, value interface{}) error { 5712 if v == nil { 5713 return fmt.Errorf("unexpected nil of type %T", v) 5714 } 5715 if value == nil { 5716 return nil 5717 } 5718 5719 shape, ok := value.([]interface{}) 5720 if !ok { 5721 return fmt.Errorf("unexpected JSON type %v", value) 5722 } 5723 5724 var cv []types.SystemTemplateSummary 5725 if *v == nil { 5726 cv = []types.SystemTemplateSummary{} 5727 } else { 5728 cv = *v 5729 } 5730 5731 for _, value := range shape { 5732 var col types.SystemTemplateSummary 5733 destAddr := &col 5734 if err := awsAwsjson11_deserializeDocumentSystemTemplateSummary(&destAddr, value); err != nil { 5735 return err 5736 } 5737 col = *destAddr 5738 cv = append(cv, col) 5739 5740 } 5741 *v = cv 5742 return nil 5743} 5744 5745func awsAwsjson11_deserializeDocumentSystemTemplateSummary(v **types.SystemTemplateSummary, value interface{}) error { 5746 if v == nil { 5747 return fmt.Errorf("unexpected nil of type %T", v) 5748 } 5749 if value == nil { 5750 return nil 5751 } 5752 5753 shape, ok := value.(map[string]interface{}) 5754 if !ok { 5755 return fmt.Errorf("unexpected JSON type %v", value) 5756 } 5757 5758 var sv *types.SystemTemplateSummary 5759 if *v == nil { 5760 sv = &types.SystemTemplateSummary{} 5761 } else { 5762 sv = *v 5763 } 5764 5765 for key, value := range shape { 5766 switch key { 5767 case "arn": 5768 if value != nil { 5769 jtv, ok := value.(string) 5770 if !ok { 5771 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 5772 } 5773 sv.Arn = ptr.String(jtv) 5774 } 5775 5776 case "createdAt": 5777 if value != nil { 5778 jtv, ok := value.(json.Number) 5779 if !ok { 5780 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 5781 } 5782 f64, err := jtv.Float64() 5783 if err != nil { 5784 return err 5785 } 5786 sv.CreatedAt = ptr.Time(smithytime.ParseEpochSeconds(f64)) 5787 } 5788 5789 case "id": 5790 if value != nil { 5791 jtv, ok := value.(string) 5792 if !ok { 5793 return fmt.Errorf("expected Urn to be of type string, got %T instead", value) 5794 } 5795 sv.Id = ptr.String(jtv) 5796 } 5797 5798 case "revisionNumber": 5799 if value != nil { 5800 jtv, ok := value.(json.Number) 5801 if !ok { 5802 return fmt.Errorf("expected Version to be json.Number, got %T instead", value) 5803 } 5804 i64, err := jtv.Int64() 5805 if err != nil { 5806 return err 5807 } 5808 sv.RevisionNumber = ptr.Int64(i64) 5809 } 5810 5811 default: 5812 _, _ = key, value 5813 5814 } 5815 } 5816 *v = sv 5817 return nil 5818} 5819 5820func awsAwsjson11_deserializeDocumentTag(v **types.Tag, value interface{}) error { 5821 if v == nil { 5822 return fmt.Errorf("unexpected nil of type %T", v) 5823 } 5824 if value == nil { 5825 return nil 5826 } 5827 5828 shape, ok := value.(map[string]interface{}) 5829 if !ok { 5830 return fmt.Errorf("unexpected JSON type %v", value) 5831 } 5832 5833 var sv *types.Tag 5834 if *v == nil { 5835 sv = &types.Tag{} 5836 } else { 5837 sv = *v 5838 } 5839 5840 for key, value := range shape { 5841 switch key { 5842 case "key": 5843 if value != nil { 5844 jtv, ok := value.(string) 5845 if !ok { 5846 return fmt.Errorf("expected TagKey to be of type string, got %T instead", value) 5847 } 5848 sv.Key = ptr.String(jtv) 5849 } 5850 5851 case "value": 5852 if value != nil { 5853 jtv, ok := value.(string) 5854 if !ok { 5855 return fmt.Errorf("expected TagValue to be of type string, got %T instead", value) 5856 } 5857 sv.Value = ptr.String(jtv) 5858 } 5859 5860 default: 5861 _, _ = key, value 5862 5863 } 5864 } 5865 *v = sv 5866 return nil 5867} 5868 5869func awsAwsjson11_deserializeDocumentTagList(v *[]types.Tag, value interface{}) error { 5870 if v == nil { 5871 return fmt.Errorf("unexpected nil of type %T", v) 5872 } 5873 if value == nil { 5874 return nil 5875 } 5876 5877 shape, ok := value.([]interface{}) 5878 if !ok { 5879 return fmt.Errorf("unexpected JSON type %v", value) 5880 } 5881 5882 var cv []types.Tag 5883 if *v == nil { 5884 cv = []types.Tag{} 5885 } else { 5886 cv = *v 5887 } 5888 5889 for _, value := range shape { 5890 var col types.Tag 5891 destAddr := &col 5892 if err := awsAwsjson11_deserializeDocumentTag(&destAddr, value); err != nil { 5893 return err 5894 } 5895 col = *destAddr 5896 cv = append(cv, col) 5897 5898 } 5899 *v = cv 5900 return nil 5901} 5902 5903func awsAwsjson11_deserializeDocumentThing(v **types.Thing, value interface{}) error { 5904 if v == nil { 5905 return fmt.Errorf("unexpected nil of type %T", v) 5906 } 5907 if value == nil { 5908 return nil 5909 } 5910 5911 shape, ok := value.(map[string]interface{}) 5912 if !ok { 5913 return fmt.Errorf("unexpected JSON type %v", value) 5914 } 5915 5916 var sv *types.Thing 5917 if *v == nil { 5918 sv = &types.Thing{} 5919 } else { 5920 sv = *v 5921 } 5922 5923 for key, value := range shape { 5924 switch key { 5925 case "thingArn": 5926 if value != nil { 5927 jtv, ok := value.(string) 5928 if !ok { 5929 return fmt.Errorf("expected ThingArn to be of type string, got %T instead", value) 5930 } 5931 sv.ThingArn = ptr.String(jtv) 5932 } 5933 5934 case "thingName": 5935 if value != nil { 5936 jtv, ok := value.(string) 5937 if !ok { 5938 return fmt.Errorf("expected ThingName to be of type string, got %T instead", value) 5939 } 5940 sv.ThingName = ptr.String(jtv) 5941 } 5942 5943 default: 5944 _, _ = key, value 5945 5946 } 5947 } 5948 *v = sv 5949 return nil 5950} 5951 5952func awsAwsjson11_deserializeDocumentThings(v *[]types.Thing, value interface{}) error { 5953 if v == nil { 5954 return fmt.Errorf("unexpected nil of type %T", v) 5955 } 5956 if value == nil { 5957 return nil 5958 } 5959 5960 shape, ok := value.([]interface{}) 5961 if !ok { 5962 return fmt.Errorf("unexpected JSON type %v", value) 5963 } 5964 5965 var cv []types.Thing 5966 if *v == nil { 5967 cv = []types.Thing{} 5968 } else { 5969 cv = *v 5970 } 5971 5972 for _, value := range shape { 5973 var col types.Thing 5974 destAddr := &col 5975 if err := awsAwsjson11_deserializeDocumentThing(&destAddr, value); err != nil { 5976 return err 5977 } 5978 col = *destAddr 5979 cv = append(cv, col) 5980 5981 } 5982 *v = cv 5983 return nil 5984} 5985 5986func awsAwsjson11_deserializeDocumentThrottlingException(v **types.ThrottlingException, value interface{}) error { 5987 if v == nil { 5988 return fmt.Errorf("unexpected nil of type %T", v) 5989 } 5990 if value == nil { 5991 return nil 5992 } 5993 5994 shape, ok := value.(map[string]interface{}) 5995 if !ok { 5996 return fmt.Errorf("unexpected JSON type %v", value) 5997 } 5998 5999 var sv *types.ThrottlingException 6000 if *v == nil { 6001 sv = &types.ThrottlingException{} 6002 } else { 6003 sv = *v 6004 } 6005 6006 for key, value := range shape { 6007 switch key { 6008 case "message": 6009 if value != nil { 6010 jtv, ok := value.(string) 6011 if !ok { 6012 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 6013 } 6014 sv.Message = ptr.String(jtv) 6015 } 6016 6017 default: 6018 _, _ = key, value 6019 6020 } 6021 } 6022 *v = sv 6023 return nil 6024} 6025 6026func awsAwsjson11_deserializeOpDocumentAssociateEntityToThingOutput(v **AssociateEntityToThingOutput, value interface{}) error { 6027 if v == nil { 6028 return fmt.Errorf("unexpected nil of type %T", v) 6029 } 6030 if value == nil { 6031 return nil 6032 } 6033 6034 shape, ok := value.(map[string]interface{}) 6035 if !ok { 6036 return fmt.Errorf("unexpected JSON type %v", value) 6037 } 6038 6039 var sv *AssociateEntityToThingOutput 6040 if *v == nil { 6041 sv = &AssociateEntityToThingOutput{} 6042 } else { 6043 sv = *v 6044 } 6045 6046 for key, value := range shape { 6047 switch key { 6048 default: 6049 _, _ = key, value 6050 6051 } 6052 } 6053 *v = sv 6054 return nil 6055} 6056 6057func awsAwsjson11_deserializeOpDocumentCreateFlowTemplateOutput(v **CreateFlowTemplateOutput, value interface{}) error { 6058 if v == nil { 6059 return fmt.Errorf("unexpected nil of type %T", v) 6060 } 6061 if value == nil { 6062 return nil 6063 } 6064 6065 shape, ok := value.(map[string]interface{}) 6066 if !ok { 6067 return fmt.Errorf("unexpected JSON type %v", value) 6068 } 6069 6070 var sv *CreateFlowTemplateOutput 6071 if *v == nil { 6072 sv = &CreateFlowTemplateOutput{} 6073 } else { 6074 sv = *v 6075 } 6076 6077 for key, value := range shape { 6078 switch key { 6079 case "summary": 6080 if err := awsAwsjson11_deserializeDocumentFlowTemplateSummary(&sv.Summary, value); err != nil { 6081 return err 6082 } 6083 6084 default: 6085 _, _ = key, value 6086 6087 } 6088 } 6089 *v = sv 6090 return nil 6091} 6092 6093func awsAwsjson11_deserializeOpDocumentCreateSystemInstanceOutput(v **CreateSystemInstanceOutput, value interface{}) error { 6094 if v == nil { 6095 return fmt.Errorf("unexpected nil of type %T", v) 6096 } 6097 if value == nil { 6098 return nil 6099 } 6100 6101 shape, ok := value.(map[string]interface{}) 6102 if !ok { 6103 return fmt.Errorf("unexpected JSON type %v", value) 6104 } 6105 6106 var sv *CreateSystemInstanceOutput 6107 if *v == nil { 6108 sv = &CreateSystemInstanceOutput{} 6109 } else { 6110 sv = *v 6111 } 6112 6113 for key, value := range shape { 6114 switch key { 6115 case "summary": 6116 if err := awsAwsjson11_deserializeDocumentSystemInstanceSummary(&sv.Summary, value); err != nil { 6117 return err 6118 } 6119 6120 default: 6121 _, _ = key, value 6122 6123 } 6124 } 6125 *v = sv 6126 return nil 6127} 6128 6129func awsAwsjson11_deserializeOpDocumentCreateSystemTemplateOutput(v **CreateSystemTemplateOutput, value interface{}) error { 6130 if v == nil { 6131 return fmt.Errorf("unexpected nil of type %T", v) 6132 } 6133 if value == nil { 6134 return nil 6135 } 6136 6137 shape, ok := value.(map[string]interface{}) 6138 if !ok { 6139 return fmt.Errorf("unexpected JSON type %v", value) 6140 } 6141 6142 var sv *CreateSystemTemplateOutput 6143 if *v == nil { 6144 sv = &CreateSystemTemplateOutput{} 6145 } else { 6146 sv = *v 6147 } 6148 6149 for key, value := range shape { 6150 switch key { 6151 case "summary": 6152 if err := awsAwsjson11_deserializeDocumentSystemTemplateSummary(&sv.Summary, value); err != nil { 6153 return err 6154 } 6155 6156 default: 6157 _, _ = key, value 6158 6159 } 6160 } 6161 *v = sv 6162 return nil 6163} 6164 6165func awsAwsjson11_deserializeOpDocumentDeleteFlowTemplateOutput(v **DeleteFlowTemplateOutput, value interface{}) error { 6166 if v == nil { 6167 return fmt.Errorf("unexpected nil of type %T", v) 6168 } 6169 if value == nil { 6170 return nil 6171 } 6172 6173 shape, ok := value.(map[string]interface{}) 6174 if !ok { 6175 return fmt.Errorf("unexpected JSON type %v", value) 6176 } 6177 6178 var sv *DeleteFlowTemplateOutput 6179 if *v == nil { 6180 sv = &DeleteFlowTemplateOutput{} 6181 } else { 6182 sv = *v 6183 } 6184 6185 for key, value := range shape { 6186 switch key { 6187 default: 6188 _, _ = key, value 6189 6190 } 6191 } 6192 *v = sv 6193 return nil 6194} 6195 6196func awsAwsjson11_deserializeOpDocumentDeleteNamespaceOutput(v **DeleteNamespaceOutput, value interface{}) error { 6197 if v == nil { 6198 return fmt.Errorf("unexpected nil of type %T", v) 6199 } 6200 if value == nil { 6201 return nil 6202 } 6203 6204 shape, ok := value.(map[string]interface{}) 6205 if !ok { 6206 return fmt.Errorf("unexpected JSON type %v", value) 6207 } 6208 6209 var sv *DeleteNamespaceOutput 6210 if *v == nil { 6211 sv = &DeleteNamespaceOutput{} 6212 } else { 6213 sv = *v 6214 } 6215 6216 for key, value := range shape { 6217 switch key { 6218 case "namespaceArn": 6219 if value != nil { 6220 jtv, ok := value.(string) 6221 if !ok { 6222 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 6223 } 6224 sv.NamespaceArn = ptr.String(jtv) 6225 } 6226 6227 case "namespaceName": 6228 if value != nil { 6229 jtv, ok := value.(string) 6230 if !ok { 6231 return fmt.Errorf("expected NamespaceName to be of type string, got %T instead", value) 6232 } 6233 sv.NamespaceName = ptr.String(jtv) 6234 } 6235 6236 default: 6237 _, _ = key, value 6238 6239 } 6240 } 6241 *v = sv 6242 return nil 6243} 6244 6245func awsAwsjson11_deserializeOpDocumentDeleteSystemInstanceOutput(v **DeleteSystemInstanceOutput, value interface{}) error { 6246 if v == nil { 6247 return fmt.Errorf("unexpected nil of type %T", v) 6248 } 6249 if value == nil { 6250 return nil 6251 } 6252 6253 shape, ok := value.(map[string]interface{}) 6254 if !ok { 6255 return fmt.Errorf("unexpected JSON type %v", value) 6256 } 6257 6258 var sv *DeleteSystemInstanceOutput 6259 if *v == nil { 6260 sv = &DeleteSystemInstanceOutput{} 6261 } else { 6262 sv = *v 6263 } 6264 6265 for key, value := range shape { 6266 switch key { 6267 default: 6268 _, _ = key, value 6269 6270 } 6271 } 6272 *v = sv 6273 return nil 6274} 6275 6276func awsAwsjson11_deserializeOpDocumentDeleteSystemTemplateOutput(v **DeleteSystemTemplateOutput, value interface{}) error { 6277 if v == nil { 6278 return fmt.Errorf("unexpected nil of type %T", v) 6279 } 6280 if value == nil { 6281 return nil 6282 } 6283 6284 shape, ok := value.(map[string]interface{}) 6285 if !ok { 6286 return fmt.Errorf("unexpected JSON type %v", value) 6287 } 6288 6289 var sv *DeleteSystemTemplateOutput 6290 if *v == nil { 6291 sv = &DeleteSystemTemplateOutput{} 6292 } else { 6293 sv = *v 6294 } 6295 6296 for key, value := range shape { 6297 switch key { 6298 default: 6299 _, _ = key, value 6300 6301 } 6302 } 6303 *v = sv 6304 return nil 6305} 6306 6307func awsAwsjson11_deserializeOpDocumentDeploySystemInstanceOutput(v **DeploySystemInstanceOutput, value interface{}) error { 6308 if v == nil { 6309 return fmt.Errorf("unexpected nil of type %T", v) 6310 } 6311 if value == nil { 6312 return nil 6313 } 6314 6315 shape, ok := value.(map[string]interface{}) 6316 if !ok { 6317 return fmt.Errorf("unexpected JSON type %v", value) 6318 } 6319 6320 var sv *DeploySystemInstanceOutput 6321 if *v == nil { 6322 sv = &DeploySystemInstanceOutput{} 6323 } else { 6324 sv = *v 6325 } 6326 6327 for key, value := range shape { 6328 switch key { 6329 case "greengrassDeploymentId": 6330 if value != nil { 6331 jtv, ok := value.(string) 6332 if !ok { 6333 return fmt.Errorf("expected GreengrassDeploymentId to be of type string, got %T instead", value) 6334 } 6335 sv.GreengrassDeploymentId = ptr.String(jtv) 6336 } 6337 6338 case "summary": 6339 if err := awsAwsjson11_deserializeDocumentSystemInstanceSummary(&sv.Summary, value); err != nil { 6340 return err 6341 } 6342 6343 default: 6344 _, _ = key, value 6345 6346 } 6347 } 6348 *v = sv 6349 return nil 6350} 6351 6352func awsAwsjson11_deserializeOpDocumentDeprecateFlowTemplateOutput(v **DeprecateFlowTemplateOutput, value interface{}) error { 6353 if v == nil { 6354 return fmt.Errorf("unexpected nil of type %T", v) 6355 } 6356 if value == nil { 6357 return nil 6358 } 6359 6360 shape, ok := value.(map[string]interface{}) 6361 if !ok { 6362 return fmt.Errorf("unexpected JSON type %v", value) 6363 } 6364 6365 var sv *DeprecateFlowTemplateOutput 6366 if *v == nil { 6367 sv = &DeprecateFlowTemplateOutput{} 6368 } else { 6369 sv = *v 6370 } 6371 6372 for key, value := range shape { 6373 switch key { 6374 default: 6375 _, _ = key, value 6376 6377 } 6378 } 6379 *v = sv 6380 return nil 6381} 6382 6383func awsAwsjson11_deserializeOpDocumentDeprecateSystemTemplateOutput(v **DeprecateSystemTemplateOutput, value interface{}) error { 6384 if v == nil { 6385 return fmt.Errorf("unexpected nil of type %T", v) 6386 } 6387 if value == nil { 6388 return nil 6389 } 6390 6391 shape, ok := value.(map[string]interface{}) 6392 if !ok { 6393 return fmt.Errorf("unexpected JSON type %v", value) 6394 } 6395 6396 var sv *DeprecateSystemTemplateOutput 6397 if *v == nil { 6398 sv = &DeprecateSystemTemplateOutput{} 6399 } else { 6400 sv = *v 6401 } 6402 6403 for key, value := range shape { 6404 switch key { 6405 default: 6406 _, _ = key, value 6407 6408 } 6409 } 6410 *v = sv 6411 return nil 6412} 6413 6414func awsAwsjson11_deserializeOpDocumentDescribeNamespaceOutput(v **DescribeNamespaceOutput, value interface{}) error { 6415 if v == nil { 6416 return fmt.Errorf("unexpected nil of type %T", v) 6417 } 6418 if value == nil { 6419 return nil 6420 } 6421 6422 shape, ok := value.(map[string]interface{}) 6423 if !ok { 6424 return fmt.Errorf("unexpected JSON type %v", value) 6425 } 6426 6427 var sv *DescribeNamespaceOutput 6428 if *v == nil { 6429 sv = &DescribeNamespaceOutput{} 6430 } else { 6431 sv = *v 6432 } 6433 6434 for key, value := range shape { 6435 switch key { 6436 case "namespaceArn": 6437 if value != nil { 6438 jtv, ok := value.(string) 6439 if !ok { 6440 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 6441 } 6442 sv.NamespaceArn = ptr.String(jtv) 6443 } 6444 6445 case "namespaceName": 6446 if value != nil { 6447 jtv, ok := value.(string) 6448 if !ok { 6449 return fmt.Errorf("expected NamespaceName to be of type string, got %T instead", value) 6450 } 6451 sv.NamespaceName = ptr.String(jtv) 6452 } 6453 6454 case "namespaceVersion": 6455 if value != nil { 6456 jtv, ok := value.(json.Number) 6457 if !ok { 6458 return fmt.Errorf("expected Version to be json.Number, got %T instead", value) 6459 } 6460 i64, err := jtv.Int64() 6461 if err != nil { 6462 return err 6463 } 6464 sv.NamespaceVersion = ptr.Int64(i64) 6465 } 6466 6467 case "trackingNamespaceName": 6468 if value != nil { 6469 jtv, ok := value.(string) 6470 if !ok { 6471 return fmt.Errorf("expected NamespaceName to be of type string, got %T instead", value) 6472 } 6473 sv.TrackingNamespaceName = ptr.String(jtv) 6474 } 6475 6476 case "trackingNamespaceVersion": 6477 if value != nil { 6478 jtv, ok := value.(json.Number) 6479 if !ok { 6480 return fmt.Errorf("expected Version to be json.Number, got %T instead", value) 6481 } 6482 i64, err := jtv.Int64() 6483 if err != nil { 6484 return err 6485 } 6486 sv.TrackingNamespaceVersion = ptr.Int64(i64) 6487 } 6488 6489 default: 6490 _, _ = key, value 6491 6492 } 6493 } 6494 *v = sv 6495 return nil 6496} 6497 6498func awsAwsjson11_deserializeOpDocumentDissociateEntityFromThingOutput(v **DissociateEntityFromThingOutput, value interface{}) error { 6499 if v == nil { 6500 return fmt.Errorf("unexpected nil of type %T", v) 6501 } 6502 if value == nil { 6503 return nil 6504 } 6505 6506 shape, ok := value.(map[string]interface{}) 6507 if !ok { 6508 return fmt.Errorf("unexpected JSON type %v", value) 6509 } 6510 6511 var sv *DissociateEntityFromThingOutput 6512 if *v == nil { 6513 sv = &DissociateEntityFromThingOutput{} 6514 } else { 6515 sv = *v 6516 } 6517 6518 for key, value := range shape { 6519 switch key { 6520 default: 6521 _, _ = key, value 6522 6523 } 6524 } 6525 *v = sv 6526 return nil 6527} 6528 6529func awsAwsjson11_deserializeOpDocumentGetEntitiesOutput(v **GetEntitiesOutput, value interface{}) error { 6530 if v == nil { 6531 return fmt.Errorf("unexpected nil of type %T", v) 6532 } 6533 if value == nil { 6534 return nil 6535 } 6536 6537 shape, ok := value.(map[string]interface{}) 6538 if !ok { 6539 return fmt.Errorf("unexpected JSON type %v", value) 6540 } 6541 6542 var sv *GetEntitiesOutput 6543 if *v == nil { 6544 sv = &GetEntitiesOutput{} 6545 } else { 6546 sv = *v 6547 } 6548 6549 for key, value := range shape { 6550 switch key { 6551 case "descriptions": 6552 if err := awsAwsjson11_deserializeDocumentEntityDescriptions(&sv.Descriptions, value); err != nil { 6553 return err 6554 } 6555 6556 default: 6557 _, _ = key, value 6558 6559 } 6560 } 6561 *v = sv 6562 return nil 6563} 6564 6565func awsAwsjson11_deserializeOpDocumentGetFlowTemplateOutput(v **GetFlowTemplateOutput, value interface{}) error { 6566 if v == nil { 6567 return fmt.Errorf("unexpected nil of type %T", v) 6568 } 6569 if value == nil { 6570 return nil 6571 } 6572 6573 shape, ok := value.(map[string]interface{}) 6574 if !ok { 6575 return fmt.Errorf("unexpected JSON type %v", value) 6576 } 6577 6578 var sv *GetFlowTemplateOutput 6579 if *v == nil { 6580 sv = &GetFlowTemplateOutput{} 6581 } else { 6582 sv = *v 6583 } 6584 6585 for key, value := range shape { 6586 switch key { 6587 case "description": 6588 if err := awsAwsjson11_deserializeDocumentFlowTemplateDescription(&sv.Description, value); err != nil { 6589 return err 6590 } 6591 6592 default: 6593 _, _ = key, value 6594 6595 } 6596 } 6597 *v = sv 6598 return nil 6599} 6600 6601func awsAwsjson11_deserializeOpDocumentGetFlowTemplateRevisionsOutput(v **GetFlowTemplateRevisionsOutput, value interface{}) error { 6602 if v == nil { 6603 return fmt.Errorf("unexpected nil of type %T", v) 6604 } 6605 if value == nil { 6606 return nil 6607 } 6608 6609 shape, ok := value.(map[string]interface{}) 6610 if !ok { 6611 return fmt.Errorf("unexpected JSON type %v", value) 6612 } 6613 6614 var sv *GetFlowTemplateRevisionsOutput 6615 if *v == nil { 6616 sv = &GetFlowTemplateRevisionsOutput{} 6617 } else { 6618 sv = *v 6619 } 6620 6621 for key, value := range shape { 6622 switch key { 6623 case "nextToken": 6624 if value != nil { 6625 jtv, ok := value.(string) 6626 if !ok { 6627 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 6628 } 6629 sv.NextToken = ptr.String(jtv) 6630 } 6631 6632 case "summaries": 6633 if err := awsAwsjson11_deserializeDocumentFlowTemplateSummaries(&sv.Summaries, value); err != nil { 6634 return err 6635 } 6636 6637 default: 6638 _, _ = key, value 6639 6640 } 6641 } 6642 *v = sv 6643 return nil 6644} 6645 6646func awsAwsjson11_deserializeOpDocumentGetNamespaceDeletionStatusOutput(v **GetNamespaceDeletionStatusOutput, value interface{}) error { 6647 if v == nil { 6648 return fmt.Errorf("unexpected nil of type %T", v) 6649 } 6650 if value == nil { 6651 return nil 6652 } 6653 6654 shape, ok := value.(map[string]interface{}) 6655 if !ok { 6656 return fmt.Errorf("unexpected JSON type %v", value) 6657 } 6658 6659 var sv *GetNamespaceDeletionStatusOutput 6660 if *v == nil { 6661 sv = &GetNamespaceDeletionStatusOutput{} 6662 } else { 6663 sv = *v 6664 } 6665 6666 for key, value := range shape { 6667 switch key { 6668 case "errorCode": 6669 if value != nil { 6670 jtv, ok := value.(string) 6671 if !ok { 6672 return fmt.Errorf("expected NamespaceDeletionStatusErrorCodes to be of type string, got %T instead", value) 6673 } 6674 sv.ErrorCode = types.NamespaceDeletionStatusErrorCodes(jtv) 6675 } 6676 6677 case "errorMessage": 6678 if value != nil { 6679 jtv, ok := value.(string) 6680 if !ok { 6681 return fmt.Errorf("expected String to be of type string, got %T instead", value) 6682 } 6683 sv.ErrorMessage = ptr.String(jtv) 6684 } 6685 6686 case "namespaceArn": 6687 if value != nil { 6688 jtv, ok := value.(string) 6689 if !ok { 6690 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 6691 } 6692 sv.NamespaceArn = ptr.String(jtv) 6693 } 6694 6695 case "namespaceName": 6696 if value != nil { 6697 jtv, ok := value.(string) 6698 if !ok { 6699 return fmt.Errorf("expected NamespaceName to be of type string, got %T instead", value) 6700 } 6701 sv.NamespaceName = ptr.String(jtv) 6702 } 6703 6704 case "status": 6705 if value != nil { 6706 jtv, ok := value.(string) 6707 if !ok { 6708 return fmt.Errorf("expected NamespaceDeletionStatus to be of type string, got %T instead", value) 6709 } 6710 sv.Status = types.NamespaceDeletionStatus(jtv) 6711 } 6712 6713 default: 6714 _, _ = key, value 6715 6716 } 6717 } 6718 *v = sv 6719 return nil 6720} 6721 6722func awsAwsjson11_deserializeOpDocumentGetSystemInstanceOutput(v **GetSystemInstanceOutput, value interface{}) error { 6723 if v == nil { 6724 return fmt.Errorf("unexpected nil of type %T", v) 6725 } 6726 if value == nil { 6727 return nil 6728 } 6729 6730 shape, ok := value.(map[string]interface{}) 6731 if !ok { 6732 return fmt.Errorf("unexpected JSON type %v", value) 6733 } 6734 6735 var sv *GetSystemInstanceOutput 6736 if *v == nil { 6737 sv = &GetSystemInstanceOutput{} 6738 } else { 6739 sv = *v 6740 } 6741 6742 for key, value := range shape { 6743 switch key { 6744 case "description": 6745 if err := awsAwsjson11_deserializeDocumentSystemInstanceDescription(&sv.Description, value); err != nil { 6746 return err 6747 } 6748 6749 default: 6750 _, _ = key, value 6751 6752 } 6753 } 6754 *v = sv 6755 return nil 6756} 6757 6758func awsAwsjson11_deserializeOpDocumentGetSystemTemplateOutput(v **GetSystemTemplateOutput, value interface{}) error { 6759 if v == nil { 6760 return fmt.Errorf("unexpected nil of type %T", v) 6761 } 6762 if value == nil { 6763 return nil 6764 } 6765 6766 shape, ok := value.(map[string]interface{}) 6767 if !ok { 6768 return fmt.Errorf("unexpected JSON type %v", value) 6769 } 6770 6771 var sv *GetSystemTemplateOutput 6772 if *v == nil { 6773 sv = &GetSystemTemplateOutput{} 6774 } else { 6775 sv = *v 6776 } 6777 6778 for key, value := range shape { 6779 switch key { 6780 case "description": 6781 if err := awsAwsjson11_deserializeDocumentSystemTemplateDescription(&sv.Description, value); err != nil { 6782 return err 6783 } 6784 6785 default: 6786 _, _ = key, value 6787 6788 } 6789 } 6790 *v = sv 6791 return nil 6792} 6793 6794func awsAwsjson11_deserializeOpDocumentGetSystemTemplateRevisionsOutput(v **GetSystemTemplateRevisionsOutput, value interface{}) error { 6795 if v == nil { 6796 return fmt.Errorf("unexpected nil of type %T", v) 6797 } 6798 if value == nil { 6799 return nil 6800 } 6801 6802 shape, ok := value.(map[string]interface{}) 6803 if !ok { 6804 return fmt.Errorf("unexpected JSON type %v", value) 6805 } 6806 6807 var sv *GetSystemTemplateRevisionsOutput 6808 if *v == nil { 6809 sv = &GetSystemTemplateRevisionsOutput{} 6810 } else { 6811 sv = *v 6812 } 6813 6814 for key, value := range shape { 6815 switch key { 6816 case "nextToken": 6817 if value != nil { 6818 jtv, ok := value.(string) 6819 if !ok { 6820 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 6821 } 6822 sv.NextToken = ptr.String(jtv) 6823 } 6824 6825 case "summaries": 6826 if err := awsAwsjson11_deserializeDocumentSystemTemplateSummaries(&sv.Summaries, value); err != nil { 6827 return err 6828 } 6829 6830 default: 6831 _, _ = key, value 6832 6833 } 6834 } 6835 *v = sv 6836 return nil 6837} 6838 6839func awsAwsjson11_deserializeOpDocumentGetUploadStatusOutput(v **GetUploadStatusOutput, value interface{}) error { 6840 if v == nil { 6841 return fmt.Errorf("unexpected nil of type %T", v) 6842 } 6843 if value == nil { 6844 return nil 6845 } 6846 6847 shape, ok := value.(map[string]interface{}) 6848 if !ok { 6849 return fmt.Errorf("unexpected JSON type %v", value) 6850 } 6851 6852 var sv *GetUploadStatusOutput 6853 if *v == nil { 6854 sv = &GetUploadStatusOutput{} 6855 } else { 6856 sv = *v 6857 } 6858 6859 for key, value := range shape { 6860 switch key { 6861 case "createdDate": 6862 if value != nil { 6863 jtv, ok := value.(json.Number) 6864 if !ok { 6865 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 6866 } 6867 f64, err := jtv.Float64() 6868 if err != nil { 6869 return err 6870 } 6871 sv.CreatedDate = ptr.Time(smithytime.ParseEpochSeconds(f64)) 6872 } 6873 6874 case "failureReason": 6875 if err := awsAwsjson11_deserializeDocumentStringList(&sv.FailureReason, value); err != nil { 6876 return err 6877 } 6878 6879 case "namespaceArn": 6880 if value != nil { 6881 jtv, ok := value.(string) 6882 if !ok { 6883 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 6884 } 6885 sv.NamespaceArn = ptr.String(jtv) 6886 } 6887 6888 case "namespaceName": 6889 if value != nil { 6890 jtv, ok := value.(string) 6891 if !ok { 6892 return fmt.Errorf("expected NamespaceName to be of type string, got %T instead", value) 6893 } 6894 sv.NamespaceName = ptr.String(jtv) 6895 } 6896 6897 case "namespaceVersion": 6898 if value != nil { 6899 jtv, ok := value.(json.Number) 6900 if !ok { 6901 return fmt.Errorf("expected Version to be json.Number, got %T instead", value) 6902 } 6903 i64, err := jtv.Int64() 6904 if err != nil { 6905 return err 6906 } 6907 sv.NamespaceVersion = ptr.Int64(i64) 6908 } 6909 6910 case "uploadId": 6911 if value != nil { 6912 jtv, ok := value.(string) 6913 if !ok { 6914 return fmt.Errorf("expected UploadId to be of type string, got %T instead", value) 6915 } 6916 sv.UploadId = ptr.String(jtv) 6917 } 6918 6919 case "uploadStatus": 6920 if value != nil { 6921 jtv, ok := value.(string) 6922 if !ok { 6923 return fmt.Errorf("expected UploadStatus to be of type string, got %T instead", value) 6924 } 6925 sv.UploadStatus = types.UploadStatus(jtv) 6926 } 6927 6928 default: 6929 _, _ = key, value 6930 6931 } 6932 } 6933 *v = sv 6934 return nil 6935} 6936 6937func awsAwsjson11_deserializeOpDocumentListFlowExecutionMessagesOutput(v **ListFlowExecutionMessagesOutput, value interface{}) error { 6938 if v == nil { 6939 return fmt.Errorf("unexpected nil of type %T", v) 6940 } 6941 if value == nil { 6942 return nil 6943 } 6944 6945 shape, ok := value.(map[string]interface{}) 6946 if !ok { 6947 return fmt.Errorf("unexpected JSON type %v", value) 6948 } 6949 6950 var sv *ListFlowExecutionMessagesOutput 6951 if *v == nil { 6952 sv = &ListFlowExecutionMessagesOutput{} 6953 } else { 6954 sv = *v 6955 } 6956 6957 for key, value := range shape { 6958 switch key { 6959 case "messages": 6960 if err := awsAwsjson11_deserializeDocumentFlowExecutionMessages(&sv.Messages, value); err != nil { 6961 return err 6962 } 6963 6964 case "nextToken": 6965 if value != nil { 6966 jtv, ok := value.(string) 6967 if !ok { 6968 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 6969 } 6970 sv.NextToken = ptr.String(jtv) 6971 } 6972 6973 default: 6974 _, _ = key, value 6975 6976 } 6977 } 6978 *v = sv 6979 return nil 6980} 6981 6982func awsAwsjson11_deserializeOpDocumentListTagsForResourceOutput(v **ListTagsForResourceOutput, value interface{}) error { 6983 if v == nil { 6984 return fmt.Errorf("unexpected nil of type %T", v) 6985 } 6986 if value == nil { 6987 return nil 6988 } 6989 6990 shape, ok := value.(map[string]interface{}) 6991 if !ok { 6992 return fmt.Errorf("unexpected JSON type %v", value) 6993 } 6994 6995 var sv *ListTagsForResourceOutput 6996 if *v == nil { 6997 sv = &ListTagsForResourceOutput{} 6998 } else { 6999 sv = *v 7000 } 7001 7002 for key, value := range shape { 7003 switch key { 7004 case "nextToken": 7005 if value != nil { 7006 jtv, ok := value.(string) 7007 if !ok { 7008 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 7009 } 7010 sv.NextToken = ptr.String(jtv) 7011 } 7012 7013 case "tags": 7014 if err := awsAwsjson11_deserializeDocumentTagList(&sv.Tags, value); err != nil { 7015 return err 7016 } 7017 7018 default: 7019 _, _ = key, value 7020 7021 } 7022 } 7023 *v = sv 7024 return nil 7025} 7026 7027func awsAwsjson11_deserializeOpDocumentSearchEntitiesOutput(v **SearchEntitiesOutput, value interface{}) error { 7028 if v == nil { 7029 return fmt.Errorf("unexpected nil of type %T", v) 7030 } 7031 if value == nil { 7032 return nil 7033 } 7034 7035 shape, ok := value.(map[string]interface{}) 7036 if !ok { 7037 return fmt.Errorf("unexpected JSON type %v", value) 7038 } 7039 7040 var sv *SearchEntitiesOutput 7041 if *v == nil { 7042 sv = &SearchEntitiesOutput{} 7043 } else { 7044 sv = *v 7045 } 7046 7047 for key, value := range shape { 7048 switch key { 7049 case "descriptions": 7050 if err := awsAwsjson11_deserializeDocumentEntityDescriptions(&sv.Descriptions, value); err != nil { 7051 return err 7052 } 7053 7054 case "nextToken": 7055 if value != nil { 7056 jtv, ok := value.(string) 7057 if !ok { 7058 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 7059 } 7060 sv.NextToken = ptr.String(jtv) 7061 } 7062 7063 default: 7064 _, _ = key, value 7065 7066 } 7067 } 7068 *v = sv 7069 return nil 7070} 7071 7072func awsAwsjson11_deserializeOpDocumentSearchFlowExecutionsOutput(v **SearchFlowExecutionsOutput, value interface{}) error { 7073 if v == nil { 7074 return fmt.Errorf("unexpected nil of type %T", v) 7075 } 7076 if value == nil { 7077 return nil 7078 } 7079 7080 shape, ok := value.(map[string]interface{}) 7081 if !ok { 7082 return fmt.Errorf("unexpected JSON type %v", value) 7083 } 7084 7085 var sv *SearchFlowExecutionsOutput 7086 if *v == nil { 7087 sv = &SearchFlowExecutionsOutput{} 7088 } else { 7089 sv = *v 7090 } 7091 7092 for key, value := range shape { 7093 switch key { 7094 case "nextToken": 7095 if value != nil { 7096 jtv, ok := value.(string) 7097 if !ok { 7098 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 7099 } 7100 sv.NextToken = ptr.String(jtv) 7101 } 7102 7103 case "summaries": 7104 if err := awsAwsjson11_deserializeDocumentFlowExecutionSummaries(&sv.Summaries, value); err != nil { 7105 return err 7106 } 7107 7108 default: 7109 _, _ = key, value 7110 7111 } 7112 } 7113 *v = sv 7114 return nil 7115} 7116 7117func awsAwsjson11_deserializeOpDocumentSearchFlowTemplatesOutput(v **SearchFlowTemplatesOutput, value interface{}) error { 7118 if v == nil { 7119 return fmt.Errorf("unexpected nil of type %T", v) 7120 } 7121 if value == nil { 7122 return nil 7123 } 7124 7125 shape, ok := value.(map[string]interface{}) 7126 if !ok { 7127 return fmt.Errorf("unexpected JSON type %v", value) 7128 } 7129 7130 var sv *SearchFlowTemplatesOutput 7131 if *v == nil { 7132 sv = &SearchFlowTemplatesOutput{} 7133 } else { 7134 sv = *v 7135 } 7136 7137 for key, value := range shape { 7138 switch key { 7139 case "nextToken": 7140 if value != nil { 7141 jtv, ok := value.(string) 7142 if !ok { 7143 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 7144 } 7145 sv.NextToken = ptr.String(jtv) 7146 } 7147 7148 case "summaries": 7149 if err := awsAwsjson11_deserializeDocumentFlowTemplateSummaries(&sv.Summaries, value); err != nil { 7150 return err 7151 } 7152 7153 default: 7154 _, _ = key, value 7155 7156 } 7157 } 7158 *v = sv 7159 return nil 7160} 7161 7162func awsAwsjson11_deserializeOpDocumentSearchSystemInstancesOutput(v **SearchSystemInstancesOutput, value interface{}) error { 7163 if v == nil { 7164 return fmt.Errorf("unexpected nil of type %T", v) 7165 } 7166 if value == nil { 7167 return nil 7168 } 7169 7170 shape, ok := value.(map[string]interface{}) 7171 if !ok { 7172 return fmt.Errorf("unexpected JSON type %v", value) 7173 } 7174 7175 var sv *SearchSystemInstancesOutput 7176 if *v == nil { 7177 sv = &SearchSystemInstancesOutput{} 7178 } else { 7179 sv = *v 7180 } 7181 7182 for key, value := range shape { 7183 switch key { 7184 case "nextToken": 7185 if value != nil { 7186 jtv, ok := value.(string) 7187 if !ok { 7188 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 7189 } 7190 sv.NextToken = ptr.String(jtv) 7191 } 7192 7193 case "summaries": 7194 if err := awsAwsjson11_deserializeDocumentSystemInstanceSummaries(&sv.Summaries, value); err != nil { 7195 return err 7196 } 7197 7198 default: 7199 _, _ = key, value 7200 7201 } 7202 } 7203 *v = sv 7204 return nil 7205} 7206 7207func awsAwsjson11_deserializeOpDocumentSearchSystemTemplatesOutput(v **SearchSystemTemplatesOutput, value interface{}) error { 7208 if v == nil { 7209 return fmt.Errorf("unexpected nil of type %T", v) 7210 } 7211 if value == nil { 7212 return nil 7213 } 7214 7215 shape, ok := value.(map[string]interface{}) 7216 if !ok { 7217 return fmt.Errorf("unexpected JSON type %v", value) 7218 } 7219 7220 var sv *SearchSystemTemplatesOutput 7221 if *v == nil { 7222 sv = &SearchSystemTemplatesOutput{} 7223 } else { 7224 sv = *v 7225 } 7226 7227 for key, value := range shape { 7228 switch key { 7229 case "nextToken": 7230 if value != nil { 7231 jtv, ok := value.(string) 7232 if !ok { 7233 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 7234 } 7235 sv.NextToken = ptr.String(jtv) 7236 } 7237 7238 case "summaries": 7239 if err := awsAwsjson11_deserializeDocumentSystemTemplateSummaries(&sv.Summaries, value); err != nil { 7240 return err 7241 } 7242 7243 default: 7244 _, _ = key, value 7245 7246 } 7247 } 7248 *v = sv 7249 return nil 7250} 7251 7252func awsAwsjson11_deserializeOpDocumentSearchThingsOutput(v **SearchThingsOutput, value interface{}) error { 7253 if v == nil { 7254 return fmt.Errorf("unexpected nil of type %T", v) 7255 } 7256 if value == nil { 7257 return nil 7258 } 7259 7260 shape, ok := value.(map[string]interface{}) 7261 if !ok { 7262 return fmt.Errorf("unexpected JSON type %v", value) 7263 } 7264 7265 var sv *SearchThingsOutput 7266 if *v == nil { 7267 sv = &SearchThingsOutput{} 7268 } else { 7269 sv = *v 7270 } 7271 7272 for key, value := range shape { 7273 switch key { 7274 case "nextToken": 7275 if value != nil { 7276 jtv, ok := value.(string) 7277 if !ok { 7278 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 7279 } 7280 sv.NextToken = ptr.String(jtv) 7281 } 7282 7283 case "things": 7284 if err := awsAwsjson11_deserializeDocumentThings(&sv.Things, value); err != nil { 7285 return err 7286 } 7287 7288 default: 7289 _, _ = key, value 7290 7291 } 7292 } 7293 *v = sv 7294 return nil 7295} 7296 7297func awsAwsjson11_deserializeOpDocumentTagResourceOutput(v **TagResourceOutput, value interface{}) error { 7298 if v == nil { 7299 return fmt.Errorf("unexpected nil of type %T", v) 7300 } 7301 if value == nil { 7302 return nil 7303 } 7304 7305 shape, ok := value.(map[string]interface{}) 7306 if !ok { 7307 return fmt.Errorf("unexpected JSON type %v", value) 7308 } 7309 7310 var sv *TagResourceOutput 7311 if *v == nil { 7312 sv = &TagResourceOutput{} 7313 } else { 7314 sv = *v 7315 } 7316 7317 for key, value := range shape { 7318 switch key { 7319 default: 7320 _, _ = key, value 7321 7322 } 7323 } 7324 *v = sv 7325 return nil 7326} 7327 7328func awsAwsjson11_deserializeOpDocumentUndeploySystemInstanceOutput(v **UndeploySystemInstanceOutput, value interface{}) error { 7329 if v == nil { 7330 return fmt.Errorf("unexpected nil of type %T", v) 7331 } 7332 if value == nil { 7333 return nil 7334 } 7335 7336 shape, ok := value.(map[string]interface{}) 7337 if !ok { 7338 return fmt.Errorf("unexpected JSON type %v", value) 7339 } 7340 7341 var sv *UndeploySystemInstanceOutput 7342 if *v == nil { 7343 sv = &UndeploySystemInstanceOutput{} 7344 } else { 7345 sv = *v 7346 } 7347 7348 for key, value := range shape { 7349 switch key { 7350 case "summary": 7351 if err := awsAwsjson11_deserializeDocumentSystemInstanceSummary(&sv.Summary, value); err != nil { 7352 return err 7353 } 7354 7355 default: 7356 _, _ = key, value 7357 7358 } 7359 } 7360 *v = sv 7361 return nil 7362} 7363 7364func awsAwsjson11_deserializeOpDocumentUntagResourceOutput(v **UntagResourceOutput, value interface{}) error { 7365 if v == nil { 7366 return fmt.Errorf("unexpected nil of type %T", v) 7367 } 7368 if value == nil { 7369 return nil 7370 } 7371 7372 shape, ok := value.(map[string]interface{}) 7373 if !ok { 7374 return fmt.Errorf("unexpected JSON type %v", value) 7375 } 7376 7377 var sv *UntagResourceOutput 7378 if *v == nil { 7379 sv = &UntagResourceOutput{} 7380 } else { 7381 sv = *v 7382 } 7383 7384 for key, value := range shape { 7385 switch key { 7386 default: 7387 _, _ = key, value 7388 7389 } 7390 } 7391 *v = sv 7392 return nil 7393} 7394 7395func awsAwsjson11_deserializeOpDocumentUpdateFlowTemplateOutput(v **UpdateFlowTemplateOutput, value interface{}) error { 7396 if v == nil { 7397 return fmt.Errorf("unexpected nil of type %T", v) 7398 } 7399 if value == nil { 7400 return nil 7401 } 7402 7403 shape, ok := value.(map[string]interface{}) 7404 if !ok { 7405 return fmt.Errorf("unexpected JSON type %v", value) 7406 } 7407 7408 var sv *UpdateFlowTemplateOutput 7409 if *v == nil { 7410 sv = &UpdateFlowTemplateOutput{} 7411 } else { 7412 sv = *v 7413 } 7414 7415 for key, value := range shape { 7416 switch key { 7417 case "summary": 7418 if err := awsAwsjson11_deserializeDocumentFlowTemplateSummary(&sv.Summary, value); err != nil { 7419 return err 7420 } 7421 7422 default: 7423 _, _ = key, value 7424 7425 } 7426 } 7427 *v = sv 7428 return nil 7429} 7430 7431func awsAwsjson11_deserializeOpDocumentUpdateSystemTemplateOutput(v **UpdateSystemTemplateOutput, value interface{}) error { 7432 if v == nil { 7433 return fmt.Errorf("unexpected nil of type %T", v) 7434 } 7435 if value == nil { 7436 return nil 7437 } 7438 7439 shape, ok := value.(map[string]interface{}) 7440 if !ok { 7441 return fmt.Errorf("unexpected JSON type %v", value) 7442 } 7443 7444 var sv *UpdateSystemTemplateOutput 7445 if *v == nil { 7446 sv = &UpdateSystemTemplateOutput{} 7447 } else { 7448 sv = *v 7449 } 7450 7451 for key, value := range shape { 7452 switch key { 7453 case "summary": 7454 if err := awsAwsjson11_deserializeDocumentSystemTemplateSummary(&sv.Summary, value); err != nil { 7455 return err 7456 } 7457 7458 default: 7459 _, _ = key, value 7460 7461 } 7462 } 7463 *v = sv 7464 return nil 7465} 7466 7467func awsAwsjson11_deserializeOpDocumentUploadEntityDefinitionsOutput(v **UploadEntityDefinitionsOutput, value interface{}) error { 7468 if v == nil { 7469 return fmt.Errorf("unexpected nil of type %T", v) 7470 } 7471 if value == nil { 7472 return nil 7473 } 7474 7475 shape, ok := value.(map[string]interface{}) 7476 if !ok { 7477 return fmt.Errorf("unexpected JSON type %v", value) 7478 } 7479 7480 var sv *UploadEntityDefinitionsOutput 7481 if *v == nil { 7482 sv = &UploadEntityDefinitionsOutput{} 7483 } else { 7484 sv = *v 7485 } 7486 7487 for key, value := range shape { 7488 switch key { 7489 case "uploadId": 7490 if value != nil { 7491 jtv, ok := value.(string) 7492 if !ok { 7493 return fmt.Errorf("expected UploadId to be of type string, got %T instead", value) 7494 } 7495 sv.UploadId = ptr.String(jtv) 7496 } 7497 7498 default: 7499 _, _ = key, value 7500 7501 } 7502 } 7503 *v = sv 7504 return nil 7505} 7506