1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package cloudhsmv2 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/cloudhsmv2/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_deserializeOpCopyBackupToRegion struct { 23} 24 25func (*awsAwsjson11_deserializeOpCopyBackupToRegion) ID() string { 26 return "OperationDeserializer" 27} 28 29func (m *awsAwsjson11_deserializeOpCopyBackupToRegion) 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_deserializeOpErrorCopyBackupToRegion(response, &metadata) 44 } 45 output := &CopyBackupToRegionOutput{} 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_deserializeOpDocumentCopyBackupToRegionOutput(&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_deserializeOpErrorCopyBackupToRegion(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("CloudHsmAccessDeniedException", errorCode): 121 return awsAwsjson11_deserializeErrorCloudHsmAccessDeniedException(response, errorBody) 122 123 case strings.EqualFold("CloudHsmInternalFailureException", errorCode): 124 return awsAwsjson11_deserializeErrorCloudHsmInternalFailureException(response, errorBody) 125 126 case strings.EqualFold("CloudHsmInvalidRequestException", errorCode): 127 return awsAwsjson11_deserializeErrorCloudHsmInvalidRequestException(response, errorBody) 128 129 case strings.EqualFold("CloudHsmResourceNotFoundException", errorCode): 130 return awsAwsjson11_deserializeErrorCloudHsmResourceNotFoundException(response, errorBody) 131 132 case strings.EqualFold("CloudHsmServiceException", errorCode): 133 return awsAwsjson11_deserializeErrorCloudHsmServiceException(response, errorBody) 134 135 case strings.EqualFold("CloudHsmTagException", errorCode): 136 return awsAwsjson11_deserializeErrorCloudHsmTagException(response, errorBody) 137 138 default: 139 genericError := &smithy.GenericAPIError{ 140 Code: errorCode, 141 Message: errorMessage, 142 } 143 return genericError 144 145 } 146} 147 148type awsAwsjson11_deserializeOpCreateCluster struct { 149} 150 151func (*awsAwsjson11_deserializeOpCreateCluster) ID() string { 152 return "OperationDeserializer" 153} 154 155func (m *awsAwsjson11_deserializeOpCreateCluster) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 156 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 157) { 158 out, metadata, err = next.HandleDeserialize(ctx, in) 159 if err != nil { 160 return out, metadata, err 161 } 162 163 response, ok := out.RawResponse.(*smithyhttp.Response) 164 if !ok { 165 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 166 } 167 168 if response.StatusCode < 200 || response.StatusCode >= 300 { 169 return out, metadata, awsAwsjson11_deserializeOpErrorCreateCluster(response, &metadata) 170 } 171 output := &CreateClusterOutput{} 172 out.Result = output 173 174 var buff [1024]byte 175 ringBuffer := smithyio.NewRingBuffer(buff[:]) 176 177 body := io.TeeReader(response.Body, ringBuffer) 178 decoder := json.NewDecoder(body) 179 decoder.UseNumber() 180 var shape interface{} 181 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 182 var snapshot bytes.Buffer 183 io.Copy(&snapshot, ringBuffer) 184 err = &smithy.DeserializationError{ 185 Err: fmt.Errorf("failed to decode response body, %w", err), 186 Snapshot: snapshot.Bytes(), 187 } 188 return out, metadata, err 189 } 190 191 err = awsAwsjson11_deserializeOpDocumentCreateClusterOutput(&output, shape) 192 if err != nil { 193 var snapshot bytes.Buffer 194 io.Copy(&snapshot, ringBuffer) 195 err = &smithy.DeserializationError{ 196 Err: fmt.Errorf("failed to decode response body, %w", err), 197 Snapshot: snapshot.Bytes(), 198 } 199 return out, metadata, err 200 } 201 202 return out, metadata, err 203} 204 205func awsAwsjson11_deserializeOpErrorCreateCluster(response *smithyhttp.Response, metadata *middleware.Metadata) error { 206 var errorBuffer bytes.Buffer 207 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 208 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 209 } 210 errorBody := bytes.NewReader(errorBuffer.Bytes()) 211 212 errorCode := "UnknownError" 213 errorMessage := errorCode 214 215 code := response.Header.Get("X-Amzn-ErrorType") 216 if len(code) != 0 { 217 errorCode = restjson.SanitizeErrorCode(code) 218 } 219 220 var buff [1024]byte 221 ringBuffer := smithyio.NewRingBuffer(buff[:]) 222 223 body := io.TeeReader(errorBody, ringBuffer) 224 decoder := json.NewDecoder(body) 225 decoder.UseNumber() 226 code, message, err := restjson.GetErrorInfo(decoder) 227 if err != nil { 228 var snapshot bytes.Buffer 229 io.Copy(&snapshot, ringBuffer) 230 err = &smithy.DeserializationError{ 231 Err: fmt.Errorf("failed to decode response body, %w", err), 232 Snapshot: snapshot.Bytes(), 233 } 234 return err 235 } 236 237 errorBody.Seek(0, io.SeekStart) 238 if len(code) != 0 { 239 errorCode = restjson.SanitizeErrorCode(code) 240 } 241 if len(message) != 0 { 242 errorMessage = message 243 } 244 245 switch { 246 case strings.EqualFold("CloudHsmAccessDeniedException", errorCode): 247 return awsAwsjson11_deserializeErrorCloudHsmAccessDeniedException(response, errorBody) 248 249 case strings.EqualFold("CloudHsmInternalFailureException", errorCode): 250 return awsAwsjson11_deserializeErrorCloudHsmInternalFailureException(response, errorBody) 251 252 case strings.EqualFold("CloudHsmInvalidRequestException", errorCode): 253 return awsAwsjson11_deserializeErrorCloudHsmInvalidRequestException(response, errorBody) 254 255 case strings.EqualFold("CloudHsmResourceNotFoundException", errorCode): 256 return awsAwsjson11_deserializeErrorCloudHsmResourceNotFoundException(response, errorBody) 257 258 case strings.EqualFold("CloudHsmServiceException", errorCode): 259 return awsAwsjson11_deserializeErrorCloudHsmServiceException(response, errorBody) 260 261 case strings.EqualFold("CloudHsmTagException", errorCode): 262 return awsAwsjson11_deserializeErrorCloudHsmTagException(response, errorBody) 263 264 default: 265 genericError := &smithy.GenericAPIError{ 266 Code: errorCode, 267 Message: errorMessage, 268 } 269 return genericError 270 271 } 272} 273 274type awsAwsjson11_deserializeOpCreateHsm struct { 275} 276 277func (*awsAwsjson11_deserializeOpCreateHsm) ID() string { 278 return "OperationDeserializer" 279} 280 281func (m *awsAwsjson11_deserializeOpCreateHsm) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 282 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 283) { 284 out, metadata, err = next.HandleDeserialize(ctx, in) 285 if err != nil { 286 return out, metadata, err 287 } 288 289 response, ok := out.RawResponse.(*smithyhttp.Response) 290 if !ok { 291 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 292 } 293 294 if response.StatusCode < 200 || response.StatusCode >= 300 { 295 return out, metadata, awsAwsjson11_deserializeOpErrorCreateHsm(response, &metadata) 296 } 297 output := &CreateHsmOutput{} 298 out.Result = output 299 300 var buff [1024]byte 301 ringBuffer := smithyio.NewRingBuffer(buff[:]) 302 303 body := io.TeeReader(response.Body, ringBuffer) 304 decoder := json.NewDecoder(body) 305 decoder.UseNumber() 306 var shape interface{} 307 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 308 var snapshot bytes.Buffer 309 io.Copy(&snapshot, ringBuffer) 310 err = &smithy.DeserializationError{ 311 Err: fmt.Errorf("failed to decode response body, %w", err), 312 Snapshot: snapshot.Bytes(), 313 } 314 return out, metadata, err 315 } 316 317 err = awsAwsjson11_deserializeOpDocumentCreateHsmOutput(&output, shape) 318 if err != nil { 319 var snapshot bytes.Buffer 320 io.Copy(&snapshot, ringBuffer) 321 err = &smithy.DeserializationError{ 322 Err: fmt.Errorf("failed to decode response body, %w", err), 323 Snapshot: snapshot.Bytes(), 324 } 325 return out, metadata, err 326 } 327 328 return out, metadata, err 329} 330 331func awsAwsjson11_deserializeOpErrorCreateHsm(response *smithyhttp.Response, metadata *middleware.Metadata) error { 332 var errorBuffer bytes.Buffer 333 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 334 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 335 } 336 errorBody := bytes.NewReader(errorBuffer.Bytes()) 337 338 errorCode := "UnknownError" 339 errorMessage := errorCode 340 341 code := response.Header.Get("X-Amzn-ErrorType") 342 if len(code) != 0 { 343 errorCode = restjson.SanitizeErrorCode(code) 344 } 345 346 var buff [1024]byte 347 ringBuffer := smithyio.NewRingBuffer(buff[:]) 348 349 body := io.TeeReader(errorBody, ringBuffer) 350 decoder := json.NewDecoder(body) 351 decoder.UseNumber() 352 code, message, err := restjson.GetErrorInfo(decoder) 353 if err != nil { 354 var snapshot bytes.Buffer 355 io.Copy(&snapshot, ringBuffer) 356 err = &smithy.DeserializationError{ 357 Err: fmt.Errorf("failed to decode response body, %w", err), 358 Snapshot: snapshot.Bytes(), 359 } 360 return err 361 } 362 363 errorBody.Seek(0, io.SeekStart) 364 if len(code) != 0 { 365 errorCode = restjson.SanitizeErrorCode(code) 366 } 367 if len(message) != 0 { 368 errorMessage = message 369 } 370 371 switch { 372 case strings.EqualFold("CloudHsmAccessDeniedException", errorCode): 373 return awsAwsjson11_deserializeErrorCloudHsmAccessDeniedException(response, errorBody) 374 375 case strings.EqualFold("CloudHsmInternalFailureException", errorCode): 376 return awsAwsjson11_deserializeErrorCloudHsmInternalFailureException(response, errorBody) 377 378 case strings.EqualFold("CloudHsmInvalidRequestException", errorCode): 379 return awsAwsjson11_deserializeErrorCloudHsmInvalidRequestException(response, errorBody) 380 381 case strings.EqualFold("CloudHsmResourceNotFoundException", errorCode): 382 return awsAwsjson11_deserializeErrorCloudHsmResourceNotFoundException(response, errorBody) 383 384 case strings.EqualFold("CloudHsmServiceException", errorCode): 385 return awsAwsjson11_deserializeErrorCloudHsmServiceException(response, errorBody) 386 387 default: 388 genericError := &smithy.GenericAPIError{ 389 Code: errorCode, 390 Message: errorMessage, 391 } 392 return genericError 393 394 } 395} 396 397type awsAwsjson11_deserializeOpDeleteBackup struct { 398} 399 400func (*awsAwsjson11_deserializeOpDeleteBackup) ID() string { 401 return "OperationDeserializer" 402} 403 404func (m *awsAwsjson11_deserializeOpDeleteBackup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 405 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 406) { 407 out, metadata, err = next.HandleDeserialize(ctx, in) 408 if err != nil { 409 return out, metadata, err 410 } 411 412 response, ok := out.RawResponse.(*smithyhttp.Response) 413 if !ok { 414 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 415 } 416 417 if response.StatusCode < 200 || response.StatusCode >= 300 { 418 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteBackup(response, &metadata) 419 } 420 output := &DeleteBackupOutput{} 421 out.Result = output 422 423 var buff [1024]byte 424 ringBuffer := smithyio.NewRingBuffer(buff[:]) 425 426 body := io.TeeReader(response.Body, ringBuffer) 427 decoder := json.NewDecoder(body) 428 decoder.UseNumber() 429 var shape interface{} 430 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 431 var snapshot bytes.Buffer 432 io.Copy(&snapshot, ringBuffer) 433 err = &smithy.DeserializationError{ 434 Err: fmt.Errorf("failed to decode response body, %w", err), 435 Snapshot: snapshot.Bytes(), 436 } 437 return out, metadata, err 438 } 439 440 err = awsAwsjson11_deserializeOpDocumentDeleteBackupOutput(&output, shape) 441 if err != nil { 442 var snapshot bytes.Buffer 443 io.Copy(&snapshot, ringBuffer) 444 err = &smithy.DeserializationError{ 445 Err: fmt.Errorf("failed to decode response body, %w", err), 446 Snapshot: snapshot.Bytes(), 447 } 448 return out, metadata, err 449 } 450 451 return out, metadata, err 452} 453 454func awsAwsjson11_deserializeOpErrorDeleteBackup(response *smithyhttp.Response, metadata *middleware.Metadata) error { 455 var errorBuffer bytes.Buffer 456 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 457 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 458 } 459 errorBody := bytes.NewReader(errorBuffer.Bytes()) 460 461 errorCode := "UnknownError" 462 errorMessage := errorCode 463 464 code := response.Header.Get("X-Amzn-ErrorType") 465 if len(code) != 0 { 466 errorCode = restjson.SanitizeErrorCode(code) 467 } 468 469 var buff [1024]byte 470 ringBuffer := smithyio.NewRingBuffer(buff[:]) 471 472 body := io.TeeReader(errorBody, ringBuffer) 473 decoder := json.NewDecoder(body) 474 decoder.UseNumber() 475 code, message, err := restjson.GetErrorInfo(decoder) 476 if err != nil { 477 var snapshot bytes.Buffer 478 io.Copy(&snapshot, ringBuffer) 479 err = &smithy.DeserializationError{ 480 Err: fmt.Errorf("failed to decode response body, %w", err), 481 Snapshot: snapshot.Bytes(), 482 } 483 return err 484 } 485 486 errorBody.Seek(0, io.SeekStart) 487 if len(code) != 0 { 488 errorCode = restjson.SanitizeErrorCode(code) 489 } 490 if len(message) != 0 { 491 errorMessage = message 492 } 493 494 switch { 495 case strings.EqualFold("CloudHsmAccessDeniedException", errorCode): 496 return awsAwsjson11_deserializeErrorCloudHsmAccessDeniedException(response, errorBody) 497 498 case strings.EqualFold("CloudHsmInternalFailureException", errorCode): 499 return awsAwsjson11_deserializeErrorCloudHsmInternalFailureException(response, errorBody) 500 501 case strings.EqualFold("CloudHsmInvalidRequestException", errorCode): 502 return awsAwsjson11_deserializeErrorCloudHsmInvalidRequestException(response, errorBody) 503 504 case strings.EqualFold("CloudHsmResourceNotFoundException", errorCode): 505 return awsAwsjson11_deserializeErrorCloudHsmResourceNotFoundException(response, errorBody) 506 507 case strings.EqualFold("CloudHsmServiceException", errorCode): 508 return awsAwsjson11_deserializeErrorCloudHsmServiceException(response, errorBody) 509 510 default: 511 genericError := &smithy.GenericAPIError{ 512 Code: errorCode, 513 Message: errorMessage, 514 } 515 return genericError 516 517 } 518} 519 520type awsAwsjson11_deserializeOpDeleteCluster struct { 521} 522 523func (*awsAwsjson11_deserializeOpDeleteCluster) ID() string { 524 return "OperationDeserializer" 525} 526 527func (m *awsAwsjson11_deserializeOpDeleteCluster) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 528 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 529) { 530 out, metadata, err = next.HandleDeserialize(ctx, in) 531 if err != nil { 532 return out, metadata, err 533 } 534 535 response, ok := out.RawResponse.(*smithyhttp.Response) 536 if !ok { 537 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 538 } 539 540 if response.StatusCode < 200 || response.StatusCode >= 300 { 541 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteCluster(response, &metadata) 542 } 543 output := &DeleteClusterOutput{} 544 out.Result = output 545 546 var buff [1024]byte 547 ringBuffer := smithyio.NewRingBuffer(buff[:]) 548 549 body := io.TeeReader(response.Body, ringBuffer) 550 decoder := json.NewDecoder(body) 551 decoder.UseNumber() 552 var shape interface{} 553 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 554 var snapshot bytes.Buffer 555 io.Copy(&snapshot, ringBuffer) 556 err = &smithy.DeserializationError{ 557 Err: fmt.Errorf("failed to decode response body, %w", err), 558 Snapshot: snapshot.Bytes(), 559 } 560 return out, metadata, err 561 } 562 563 err = awsAwsjson11_deserializeOpDocumentDeleteClusterOutput(&output, shape) 564 if err != nil { 565 var snapshot bytes.Buffer 566 io.Copy(&snapshot, ringBuffer) 567 err = &smithy.DeserializationError{ 568 Err: fmt.Errorf("failed to decode response body, %w", err), 569 Snapshot: snapshot.Bytes(), 570 } 571 return out, metadata, err 572 } 573 574 return out, metadata, err 575} 576 577func awsAwsjson11_deserializeOpErrorDeleteCluster(response *smithyhttp.Response, metadata *middleware.Metadata) error { 578 var errorBuffer bytes.Buffer 579 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 580 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 581 } 582 errorBody := bytes.NewReader(errorBuffer.Bytes()) 583 584 errorCode := "UnknownError" 585 errorMessage := errorCode 586 587 code := response.Header.Get("X-Amzn-ErrorType") 588 if len(code) != 0 { 589 errorCode = restjson.SanitizeErrorCode(code) 590 } 591 592 var buff [1024]byte 593 ringBuffer := smithyio.NewRingBuffer(buff[:]) 594 595 body := io.TeeReader(errorBody, ringBuffer) 596 decoder := json.NewDecoder(body) 597 decoder.UseNumber() 598 code, message, err := restjson.GetErrorInfo(decoder) 599 if err != nil { 600 var snapshot bytes.Buffer 601 io.Copy(&snapshot, ringBuffer) 602 err = &smithy.DeserializationError{ 603 Err: fmt.Errorf("failed to decode response body, %w", err), 604 Snapshot: snapshot.Bytes(), 605 } 606 return err 607 } 608 609 errorBody.Seek(0, io.SeekStart) 610 if len(code) != 0 { 611 errorCode = restjson.SanitizeErrorCode(code) 612 } 613 if len(message) != 0 { 614 errorMessage = message 615 } 616 617 switch { 618 case strings.EqualFold("CloudHsmAccessDeniedException", errorCode): 619 return awsAwsjson11_deserializeErrorCloudHsmAccessDeniedException(response, errorBody) 620 621 case strings.EqualFold("CloudHsmInternalFailureException", errorCode): 622 return awsAwsjson11_deserializeErrorCloudHsmInternalFailureException(response, errorBody) 623 624 case strings.EqualFold("CloudHsmInvalidRequestException", errorCode): 625 return awsAwsjson11_deserializeErrorCloudHsmInvalidRequestException(response, errorBody) 626 627 case strings.EqualFold("CloudHsmResourceNotFoundException", errorCode): 628 return awsAwsjson11_deserializeErrorCloudHsmResourceNotFoundException(response, errorBody) 629 630 case strings.EqualFold("CloudHsmServiceException", errorCode): 631 return awsAwsjson11_deserializeErrorCloudHsmServiceException(response, errorBody) 632 633 case strings.EqualFold("CloudHsmTagException", errorCode): 634 return awsAwsjson11_deserializeErrorCloudHsmTagException(response, errorBody) 635 636 default: 637 genericError := &smithy.GenericAPIError{ 638 Code: errorCode, 639 Message: errorMessage, 640 } 641 return genericError 642 643 } 644} 645 646type awsAwsjson11_deserializeOpDeleteHsm struct { 647} 648 649func (*awsAwsjson11_deserializeOpDeleteHsm) ID() string { 650 return "OperationDeserializer" 651} 652 653func (m *awsAwsjson11_deserializeOpDeleteHsm) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 654 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 655) { 656 out, metadata, err = next.HandleDeserialize(ctx, in) 657 if err != nil { 658 return out, metadata, err 659 } 660 661 response, ok := out.RawResponse.(*smithyhttp.Response) 662 if !ok { 663 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 664 } 665 666 if response.StatusCode < 200 || response.StatusCode >= 300 { 667 return out, metadata, awsAwsjson11_deserializeOpErrorDeleteHsm(response, &metadata) 668 } 669 output := &DeleteHsmOutput{} 670 out.Result = output 671 672 var buff [1024]byte 673 ringBuffer := smithyio.NewRingBuffer(buff[:]) 674 675 body := io.TeeReader(response.Body, ringBuffer) 676 decoder := json.NewDecoder(body) 677 decoder.UseNumber() 678 var shape interface{} 679 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 680 var snapshot bytes.Buffer 681 io.Copy(&snapshot, ringBuffer) 682 err = &smithy.DeserializationError{ 683 Err: fmt.Errorf("failed to decode response body, %w", err), 684 Snapshot: snapshot.Bytes(), 685 } 686 return out, metadata, err 687 } 688 689 err = awsAwsjson11_deserializeOpDocumentDeleteHsmOutput(&output, shape) 690 if err != nil { 691 var snapshot bytes.Buffer 692 io.Copy(&snapshot, ringBuffer) 693 err = &smithy.DeserializationError{ 694 Err: fmt.Errorf("failed to decode response body, %w", err), 695 Snapshot: snapshot.Bytes(), 696 } 697 return out, metadata, err 698 } 699 700 return out, metadata, err 701} 702 703func awsAwsjson11_deserializeOpErrorDeleteHsm(response *smithyhttp.Response, metadata *middleware.Metadata) error { 704 var errorBuffer bytes.Buffer 705 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 706 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 707 } 708 errorBody := bytes.NewReader(errorBuffer.Bytes()) 709 710 errorCode := "UnknownError" 711 errorMessage := errorCode 712 713 code := response.Header.Get("X-Amzn-ErrorType") 714 if len(code) != 0 { 715 errorCode = restjson.SanitizeErrorCode(code) 716 } 717 718 var buff [1024]byte 719 ringBuffer := smithyio.NewRingBuffer(buff[:]) 720 721 body := io.TeeReader(errorBody, ringBuffer) 722 decoder := json.NewDecoder(body) 723 decoder.UseNumber() 724 code, message, err := restjson.GetErrorInfo(decoder) 725 if err != nil { 726 var snapshot bytes.Buffer 727 io.Copy(&snapshot, ringBuffer) 728 err = &smithy.DeserializationError{ 729 Err: fmt.Errorf("failed to decode response body, %w", err), 730 Snapshot: snapshot.Bytes(), 731 } 732 return err 733 } 734 735 errorBody.Seek(0, io.SeekStart) 736 if len(code) != 0 { 737 errorCode = restjson.SanitizeErrorCode(code) 738 } 739 if len(message) != 0 { 740 errorMessage = message 741 } 742 743 switch { 744 case strings.EqualFold("CloudHsmAccessDeniedException", errorCode): 745 return awsAwsjson11_deserializeErrorCloudHsmAccessDeniedException(response, errorBody) 746 747 case strings.EqualFold("CloudHsmInternalFailureException", errorCode): 748 return awsAwsjson11_deserializeErrorCloudHsmInternalFailureException(response, errorBody) 749 750 case strings.EqualFold("CloudHsmInvalidRequestException", errorCode): 751 return awsAwsjson11_deserializeErrorCloudHsmInvalidRequestException(response, errorBody) 752 753 case strings.EqualFold("CloudHsmResourceNotFoundException", errorCode): 754 return awsAwsjson11_deserializeErrorCloudHsmResourceNotFoundException(response, errorBody) 755 756 case strings.EqualFold("CloudHsmServiceException", errorCode): 757 return awsAwsjson11_deserializeErrorCloudHsmServiceException(response, errorBody) 758 759 default: 760 genericError := &smithy.GenericAPIError{ 761 Code: errorCode, 762 Message: errorMessage, 763 } 764 return genericError 765 766 } 767} 768 769type awsAwsjson11_deserializeOpDescribeBackups struct { 770} 771 772func (*awsAwsjson11_deserializeOpDescribeBackups) ID() string { 773 return "OperationDeserializer" 774} 775 776func (m *awsAwsjson11_deserializeOpDescribeBackups) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 777 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 778) { 779 out, metadata, err = next.HandleDeserialize(ctx, in) 780 if err != nil { 781 return out, metadata, err 782 } 783 784 response, ok := out.RawResponse.(*smithyhttp.Response) 785 if !ok { 786 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 787 } 788 789 if response.StatusCode < 200 || response.StatusCode >= 300 { 790 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeBackups(response, &metadata) 791 } 792 output := &DescribeBackupsOutput{} 793 out.Result = output 794 795 var buff [1024]byte 796 ringBuffer := smithyio.NewRingBuffer(buff[:]) 797 798 body := io.TeeReader(response.Body, ringBuffer) 799 decoder := json.NewDecoder(body) 800 decoder.UseNumber() 801 var shape interface{} 802 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 803 var snapshot bytes.Buffer 804 io.Copy(&snapshot, ringBuffer) 805 err = &smithy.DeserializationError{ 806 Err: fmt.Errorf("failed to decode response body, %w", err), 807 Snapshot: snapshot.Bytes(), 808 } 809 return out, metadata, err 810 } 811 812 err = awsAwsjson11_deserializeOpDocumentDescribeBackupsOutput(&output, shape) 813 if err != nil { 814 var snapshot bytes.Buffer 815 io.Copy(&snapshot, ringBuffer) 816 err = &smithy.DeserializationError{ 817 Err: fmt.Errorf("failed to decode response body, %w", err), 818 Snapshot: snapshot.Bytes(), 819 } 820 return out, metadata, err 821 } 822 823 return out, metadata, err 824} 825 826func awsAwsjson11_deserializeOpErrorDescribeBackups(response *smithyhttp.Response, metadata *middleware.Metadata) error { 827 var errorBuffer bytes.Buffer 828 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 829 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 830 } 831 errorBody := bytes.NewReader(errorBuffer.Bytes()) 832 833 errorCode := "UnknownError" 834 errorMessage := errorCode 835 836 code := response.Header.Get("X-Amzn-ErrorType") 837 if len(code) != 0 { 838 errorCode = restjson.SanitizeErrorCode(code) 839 } 840 841 var buff [1024]byte 842 ringBuffer := smithyio.NewRingBuffer(buff[:]) 843 844 body := io.TeeReader(errorBody, ringBuffer) 845 decoder := json.NewDecoder(body) 846 decoder.UseNumber() 847 code, message, err := restjson.GetErrorInfo(decoder) 848 if err != nil { 849 var snapshot bytes.Buffer 850 io.Copy(&snapshot, ringBuffer) 851 err = &smithy.DeserializationError{ 852 Err: fmt.Errorf("failed to decode response body, %w", err), 853 Snapshot: snapshot.Bytes(), 854 } 855 return err 856 } 857 858 errorBody.Seek(0, io.SeekStart) 859 if len(code) != 0 { 860 errorCode = restjson.SanitizeErrorCode(code) 861 } 862 if len(message) != 0 { 863 errorMessage = message 864 } 865 866 switch { 867 case strings.EqualFold("CloudHsmAccessDeniedException", errorCode): 868 return awsAwsjson11_deserializeErrorCloudHsmAccessDeniedException(response, errorBody) 869 870 case strings.EqualFold("CloudHsmInternalFailureException", errorCode): 871 return awsAwsjson11_deserializeErrorCloudHsmInternalFailureException(response, errorBody) 872 873 case strings.EqualFold("CloudHsmInvalidRequestException", errorCode): 874 return awsAwsjson11_deserializeErrorCloudHsmInvalidRequestException(response, errorBody) 875 876 case strings.EqualFold("CloudHsmResourceNotFoundException", errorCode): 877 return awsAwsjson11_deserializeErrorCloudHsmResourceNotFoundException(response, errorBody) 878 879 case strings.EqualFold("CloudHsmServiceException", errorCode): 880 return awsAwsjson11_deserializeErrorCloudHsmServiceException(response, errorBody) 881 882 case strings.EqualFold("CloudHsmTagException", errorCode): 883 return awsAwsjson11_deserializeErrorCloudHsmTagException(response, errorBody) 884 885 default: 886 genericError := &smithy.GenericAPIError{ 887 Code: errorCode, 888 Message: errorMessage, 889 } 890 return genericError 891 892 } 893} 894 895type awsAwsjson11_deserializeOpDescribeClusters struct { 896} 897 898func (*awsAwsjson11_deserializeOpDescribeClusters) ID() string { 899 return "OperationDeserializer" 900} 901 902func (m *awsAwsjson11_deserializeOpDescribeClusters) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 903 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 904) { 905 out, metadata, err = next.HandleDeserialize(ctx, in) 906 if err != nil { 907 return out, metadata, err 908 } 909 910 response, ok := out.RawResponse.(*smithyhttp.Response) 911 if !ok { 912 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 913 } 914 915 if response.StatusCode < 200 || response.StatusCode >= 300 { 916 return out, metadata, awsAwsjson11_deserializeOpErrorDescribeClusters(response, &metadata) 917 } 918 output := &DescribeClustersOutput{} 919 out.Result = output 920 921 var buff [1024]byte 922 ringBuffer := smithyio.NewRingBuffer(buff[:]) 923 924 body := io.TeeReader(response.Body, ringBuffer) 925 decoder := json.NewDecoder(body) 926 decoder.UseNumber() 927 var shape interface{} 928 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 929 var snapshot bytes.Buffer 930 io.Copy(&snapshot, ringBuffer) 931 err = &smithy.DeserializationError{ 932 Err: fmt.Errorf("failed to decode response body, %w", err), 933 Snapshot: snapshot.Bytes(), 934 } 935 return out, metadata, err 936 } 937 938 err = awsAwsjson11_deserializeOpDocumentDescribeClustersOutput(&output, shape) 939 if err != nil { 940 var snapshot bytes.Buffer 941 io.Copy(&snapshot, ringBuffer) 942 err = &smithy.DeserializationError{ 943 Err: fmt.Errorf("failed to decode response body, %w", err), 944 Snapshot: snapshot.Bytes(), 945 } 946 return out, metadata, err 947 } 948 949 return out, metadata, err 950} 951 952func awsAwsjson11_deserializeOpErrorDescribeClusters(response *smithyhttp.Response, metadata *middleware.Metadata) error { 953 var errorBuffer bytes.Buffer 954 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 955 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 956 } 957 errorBody := bytes.NewReader(errorBuffer.Bytes()) 958 959 errorCode := "UnknownError" 960 errorMessage := errorCode 961 962 code := response.Header.Get("X-Amzn-ErrorType") 963 if len(code) != 0 { 964 errorCode = restjson.SanitizeErrorCode(code) 965 } 966 967 var buff [1024]byte 968 ringBuffer := smithyio.NewRingBuffer(buff[:]) 969 970 body := io.TeeReader(errorBody, ringBuffer) 971 decoder := json.NewDecoder(body) 972 decoder.UseNumber() 973 code, message, err := restjson.GetErrorInfo(decoder) 974 if err != nil { 975 var snapshot bytes.Buffer 976 io.Copy(&snapshot, ringBuffer) 977 err = &smithy.DeserializationError{ 978 Err: fmt.Errorf("failed to decode response body, %w", err), 979 Snapshot: snapshot.Bytes(), 980 } 981 return err 982 } 983 984 errorBody.Seek(0, io.SeekStart) 985 if len(code) != 0 { 986 errorCode = restjson.SanitizeErrorCode(code) 987 } 988 if len(message) != 0 { 989 errorMessage = message 990 } 991 992 switch { 993 case strings.EqualFold("CloudHsmAccessDeniedException", errorCode): 994 return awsAwsjson11_deserializeErrorCloudHsmAccessDeniedException(response, errorBody) 995 996 case strings.EqualFold("CloudHsmInternalFailureException", errorCode): 997 return awsAwsjson11_deserializeErrorCloudHsmInternalFailureException(response, errorBody) 998 999 case strings.EqualFold("CloudHsmInvalidRequestException", errorCode): 1000 return awsAwsjson11_deserializeErrorCloudHsmInvalidRequestException(response, errorBody) 1001 1002 case strings.EqualFold("CloudHsmServiceException", errorCode): 1003 return awsAwsjson11_deserializeErrorCloudHsmServiceException(response, errorBody) 1004 1005 case strings.EqualFold("CloudHsmTagException", errorCode): 1006 return awsAwsjson11_deserializeErrorCloudHsmTagException(response, errorBody) 1007 1008 default: 1009 genericError := &smithy.GenericAPIError{ 1010 Code: errorCode, 1011 Message: errorMessage, 1012 } 1013 return genericError 1014 1015 } 1016} 1017 1018type awsAwsjson11_deserializeOpInitializeCluster struct { 1019} 1020 1021func (*awsAwsjson11_deserializeOpInitializeCluster) ID() string { 1022 return "OperationDeserializer" 1023} 1024 1025func (m *awsAwsjson11_deserializeOpInitializeCluster) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1026 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1027) { 1028 out, metadata, err = next.HandleDeserialize(ctx, in) 1029 if err != nil { 1030 return out, metadata, err 1031 } 1032 1033 response, ok := out.RawResponse.(*smithyhttp.Response) 1034 if !ok { 1035 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1036 } 1037 1038 if response.StatusCode < 200 || response.StatusCode >= 300 { 1039 return out, metadata, awsAwsjson11_deserializeOpErrorInitializeCluster(response, &metadata) 1040 } 1041 output := &InitializeClusterOutput{} 1042 out.Result = output 1043 1044 var buff [1024]byte 1045 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1046 1047 body := io.TeeReader(response.Body, ringBuffer) 1048 decoder := json.NewDecoder(body) 1049 decoder.UseNumber() 1050 var shape interface{} 1051 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1052 var snapshot bytes.Buffer 1053 io.Copy(&snapshot, ringBuffer) 1054 err = &smithy.DeserializationError{ 1055 Err: fmt.Errorf("failed to decode response body, %w", err), 1056 Snapshot: snapshot.Bytes(), 1057 } 1058 return out, metadata, err 1059 } 1060 1061 err = awsAwsjson11_deserializeOpDocumentInitializeClusterOutput(&output, shape) 1062 if err != nil { 1063 var snapshot bytes.Buffer 1064 io.Copy(&snapshot, ringBuffer) 1065 err = &smithy.DeserializationError{ 1066 Err: fmt.Errorf("failed to decode response body, %w", err), 1067 Snapshot: snapshot.Bytes(), 1068 } 1069 return out, metadata, err 1070 } 1071 1072 return out, metadata, err 1073} 1074 1075func awsAwsjson11_deserializeOpErrorInitializeCluster(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1076 var errorBuffer bytes.Buffer 1077 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1078 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1079 } 1080 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1081 1082 errorCode := "UnknownError" 1083 errorMessage := errorCode 1084 1085 code := response.Header.Get("X-Amzn-ErrorType") 1086 if len(code) != 0 { 1087 errorCode = restjson.SanitizeErrorCode(code) 1088 } 1089 1090 var buff [1024]byte 1091 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1092 1093 body := io.TeeReader(errorBody, ringBuffer) 1094 decoder := json.NewDecoder(body) 1095 decoder.UseNumber() 1096 code, message, err := restjson.GetErrorInfo(decoder) 1097 if err != nil { 1098 var snapshot bytes.Buffer 1099 io.Copy(&snapshot, ringBuffer) 1100 err = &smithy.DeserializationError{ 1101 Err: fmt.Errorf("failed to decode response body, %w", err), 1102 Snapshot: snapshot.Bytes(), 1103 } 1104 return err 1105 } 1106 1107 errorBody.Seek(0, io.SeekStart) 1108 if len(code) != 0 { 1109 errorCode = restjson.SanitizeErrorCode(code) 1110 } 1111 if len(message) != 0 { 1112 errorMessage = message 1113 } 1114 1115 switch { 1116 case strings.EqualFold("CloudHsmAccessDeniedException", errorCode): 1117 return awsAwsjson11_deserializeErrorCloudHsmAccessDeniedException(response, errorBody) 1118 1119 case strings.EqualFold("CloudHsmInternalFailureException", errorCode): 1120 return awsAwsjson11_deserializeErrorCloudHsmInternalFailureException(response, errorBody) 1121 1122 case strings.EqualFold("CloudHsmInvalidRequestException", errorCode): 1123 return awsAwsjson11_deserializeErrorCloudHsmInvalidRequestException(response, errorBody) 1124 1125 case strings.EqualFold("CloudHsmResourceNotFoundException", errorCode): 1126 return awsAwsjson11_deserializeErrorCloudHsmResourceNotFoundException(response, errorBody) 1127 1128 case strings.EqualFold("CloudHsmServiceException", errorCode): 1129 return awsAwsjson11_deserializeErrorCloudHsmServiceException(response, errorBody) 1130 1131 default: 1132 genericError := &smithy.GenericAPIError{ 1133 Code: errorCode, 1134 Message: errorMessage, 1135 } 1136 return genericError 1137 1138 } 1139} 1140 1141type awsAwsjson11_deserializeOpListTags struct { 1142} 1143 1144func (*awsAwsjson11_deserializeOpListTags) ID() string { 1145 return "OperationDeserializer" 1146} 1147 1148func (m *awsAwsjson11_deserializeOpListTags) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1149 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1150) { 1151 out, metadata, err = next.HandleDeserialize(ctx, in) 1152 if err != nil { 1153 return out, metadata, err 1154 } 1155 1156 response, ok := out.RawResponse.(*smithyhttp.Response) 1157 if !ok { 1158 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1159 } 1160 1161 if response.StatusCode < 200 || response.StatusCode >= 300 { 1162 return out, metadata, awsAwsjson11_deserializeOpErrorListTags(response, &metadata) 1163 } 1164 output := &ListTagsOutput{} 1165 out.Result = output 1166 1167 var buff [1024]byte 1168 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1169 1170 body := io.TeeReader(response.Body, ringBuffer) 1171 decoder := json.NewDecoder(body) 1172 decoder.UseNumber() 1173 var shape interface{} 1174 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1175 var snapshot bytes.Buffer 1176 io.Copy(&snapshot, ringBuffer) 1177 err = &smithy.DeserializationError{ 1178 Err: fmt.Errorf("failed to decode response body, %w", err), 1179 Snapshot: snapshot.Bytes(), 1180 } 1181 return out, metadata, err 1182 } 1183 1184 err = awsAwsjson11_deserializeOpDocumentListTagsOutput(&output, shape) 1185 if err != nil { 1186 var snapshot bytes.Buffer 1187 io.Copy(&snapshot, ringBuffer) 1188 err = &smithy.DeserializationError{ 1189 Err: fmt.Errorf("failed to decode response body, %w", err), 1190 Snapshot: snapshot.Bytes(), 1191 } 1192 return out, metadata, err 1193 } 1194 1195 return out, metadata, err 1196} 1197 1198func awsAwsjson11_deserializeOpErrorListTags(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1199 var errorBuffer bytes.Buffer 1200 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1201 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1202 } 1203 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1204 1205 errorCode := "UnknownError" 1206 errorMessage := errorCode 1207 1208 code := response.Header.Get("X-Amzn-ErrorType") 1209 if len(code) != 0 { 1210 errorCode = restjson.SanitizeErrorCode(code) 1211 } 1212 1213 var buff [1024]byte 1214 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1215 1216 body := io.TeeReader(errorBody, ringBuffer) 1217 decoder := json.NewDecoder(body) 1218 decoder.UseNumber() 1219 code, message, err := restjson.GetErrorInfo(decoder) 1220 if err != nil { 1221 var snapshot bytes.Buffer 1222 io.Copy(&snapshot, ringBuffer) 1223 err = &smithy.DeserializationError{ 1224 Err: fmt.Errorf("failed to decode response body, %w", err), 1225 Snapshot: snapshot.Bytes(), 1226 } 1227 return err 1228 } 1229 1230 errorBody.Seek(0, io.SeekStart) 1231 if len(code) != 0 { 1232 errorCode = restjson.SanitizeErrorCode(code) 1233 } 1234 if len(message) != 0 { 1235 errorMessage = message 1236 } 1237 1238 switch { 1239 case strings.EqualFold("CloudHsmAccessDeniedException", errorCode): 1240 return awsAwsjson11_deserializeErrorCloudHsmAccessDeniedException(response, errorBody) 1241 1242 case strings.EqualFold("CloudHsmInternalFailureException", errorCode): 1243 return awsAwsjson11_deserializeErrorCloudHsmInternalFailureException(response, errorBody) 1244 1245 case strings.EqualFold("CloudHsmInvalidRequestException", errorCode): 1246 return awsAwsjson11_deserializeErrorCloudHsmInvalidRequestException(response, errorBody) 1247 1248 case strings.EqualFold("CloudHsmResourceNotFoundException", errorCode): 1249 return awsAwsjson11_deserializeErrorCloudHsmResourceNotFoundException(response, errorBody) 1250 1251 case strings.EqualFold("CloudHsmServiceException", errorCode): 1252 return awsAwsjson11_deserializeErrorCloudHsmServiceException(response, errorBody) 1253 1254 case strings.EqualFold("CloudHsmTagException", errorCode): 1255 return awsAwsjson11_deserializeErrorCloudHsmTagException(response, errorBody) 1256 1257 default: 1258 genericError := &smithy.GenericAPIError{ 1259 Code: errorCode, 1260 Message: errorMessage, 1261 } 1262 return genericError 1263 1264 } 1265} 1266 1267type awsAwsjson11_deserializeOpModifyBackupAttributes struct { 1268} 1269 1270func (*awsAwsjson11_deserializeOpModifyBackupAttributes) ID() string { 1271 return "OperationDeserializer" 1272} 1273 1274func (m *awsAwsjson11_deserializeOpModifyBackupAttributes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1275 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1276) { 1277 out, metadata, err = next.HandleDeserialize(ctx, in) 1278 if err != nil { 1279 return out, metadata, err 1280 } 1281 1282 response, ok := out.RawResponse.(*smithyhttp.Response) 1283 if !ok { 1284 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1285 } 1286 1287 if response.StatusCode < 200 || response.StatusCode >= 300 { 1288 return out, metadata, awsAwsjson11_deserializeOpErrorModifyBackupAttributes(response, &metadata) 1289 } 1290 output := &ModifyBackupAttributesOutput{} 1291 out.Result = output 1292 1293 var buff [1024]byte 1294 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1295 1296 body := io.TeeReader(response.Body, ringBuffer) 1297 decoder := json.NewDecoder(body) 1298 decoder.UseNumber() 1299 var shape interface{} 1300 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1301 var snapshot bytes.Buffer 1302 io.Copy(&snapshot, ringBuffer) 1303 err = &smithy.DeserializationError{ 1304 Err: fmt.Errorf("failed to decode response body, %w", err), 1305 Snapshot: snapshot.Bytes(), 1306 } 1307 return out, metadata, err 1308 } 1309 1310 err = awsAwsjson11_deserializeOpDocumentModifyBackupAttributesOutput(&output, shape) 1311 if err != nil { 1312 var snapshot bytes.Buffer 1313 io.Copy(&snapshot, ringBuffer) 1314 err = &smithy.DeserializationError{ 1315 Err: fmt.Errorf("failed to decode response body, %w", err), 1316 Snapshot: snapshot.Bytes(), 1317 } 1318 return out, metadata, err 1319 } 1320 1321 return out, metadata, err 1322} 1323 1324func awsAwsjson11_deserializeOpErrorModifyBackupAttributes(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1325 var errorBuffer bytes.Buffer 1326 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1327 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1328 } 1329 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1330 1331 errorCode := "UnknownError" 1332 errorMessage := errorCode 1333 1334 code := response.Header.Get("X-Amzn-ErrorType") 1335 if len(code) != 0 { 1336 errorCode = restjson.SanitizeErrorCode(code) 1337 } 1338 1339 var buff [1024]byte 1340 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1341 1342 body := io.TeeReader(errorBody, ringBuffer) 1343 decoder := json.NewDecoder(body) 1344 decoder.UseNumber() 1345 code, message, err := restjson.GetErrorInfo(decoder) 1346 if err != nil { 1347 var snapshot bytes.Buffer 1348 io.Copy(&snapshot, ringBuffer) 1349 err = &smithy.DeserializationError{ 1350 Err: fmt.Errorf("failed to decode response body, %w", err), 1351 Snapshot: snapshot.Bytes(), 1352 } 1353 return err 1354 } 1355 1356 errorBody.Seek(0, io.SeekStart) 1357 if len(code) != 0 { 1358 errorCode = restjson.SanitizeErrorCode(code) 1359 } 1360 if len(message) != 0 { 1361 errorMessage = message 1362 } 1363 1364 switch { 1365 case strings.EqualFold("CloudHsmAccessDeniedException", errorCode): 1366 return awsAwsjson11_deserializeErrorCloudHsmAccessDeniedException(response, errorBody) 1367 1368 case strings.EqualFold("CloudHsmInternalFailureException", errorCode): 1369 return awsAwsjson11_deserializeErrorCloudHsmInternalFailureException(response, errorBody) 1370 1371 case strings.EqualFold("CloudHsmInvalidRequestException", errorCode): 1372 return awsAwsjson11_deserializeErrorCloudHsmInvalidRequestException(response, errorBody) 1373 1374 case strings.EqualFold("CloudHsmResourceNotFoundException", errorCode): 1375 return awsAwsjson11_deserializeErrorCloudHsmResourceNotFoundException(response, errorBody) 1376 1377 case strings.EqualFold("CloudHsmServiceException", errorCode): 1378 return awsAwsjson11_deserializeErrorCloudHsmServiceException(response, errorBody) 1379 1380 default: 1381 genericError := &smithy.GenericAPIError{ 1382 Code: errorCode, 1383 Message: errorMessage, 1384 } 1385 return genericError 1386 1387 } 1388} 1389 1390type awsAwsjson11_deserializeOpModifyCluster struct { 1391} 1392 1393func (*awsAwsjson11_deserializeOpModifyCluster) ID() string { 1394 return "OperationDeserializer" 1395} 1396 1397func (m *awsAwsjson11_deserializeOpModifyCluster) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1398 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1399) { 1400 out, metadata, err = next.HandleDeserialize(ctx, in) 1401 if err != nil { 1402 return out, metadata, err 1403 } 1404 1405 response, ok := out.RawResponse.(*smithyhttp.Response) 1406 if !ok { 1407 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1408 } 1409 1410 if response.StatusCode < 200 || response.StatusCode >= 300 { 1411 return out, metadata, awsAwsjson11_deserializeOpErrorModifyCluster(response, &metadata) 1412 } 1413 output := &ModifyClusterOutput{} 1414 out.Result = output 1415 1416 var buff [1024]byte 1417 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1418 1419 body := io.TeeReader(response.Body, ringBuffer) 1420 decoder := json.NewDecoder(body) 1421 decoder.UseNumber() 1422 var shape interface{} 1423 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1424 var snapshot bytes.Buffer 1425 io.Copy(&snapshot, ringBuffer) 1426 err = &smithy.DeserializationError{ 1427 Err: fmt.Errorf("failed to decode response body, %w", err), 1428 Snapshot: snapshot.Bytes(), 1429 } 1430 return out, metadata, err 1431 } 1432 1433 err = awsAwsjson11_deserializeOpDocumentModifyClusterOutput(&output, shape) 1434 if err != nil { 1435 var snapshot bytes.Buffer 1436 io.Copy(&snapshot, ringBuffer) 1437 err = &smithy.DeserializationError{ 1438 Err: fmt.Errorf("failed to decode response body, %w", err), 1439 Snapshot: snapshot.Bytes(), 1440 } 1441 return out, metadata, err 1442 } 1443 1444 return out, metadata, err 1445} 1446 1447func awsAwsjson11_deserializeOpErrorModifyCluster(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1448 var errorBuffer bytes.Buffer 1449 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1450 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1451 } 1452 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1453 1454 errorCode := "UnknownError" 1455 errorMessage := errorCode 1456 1457 code := response.Header.Get("X-Amzn-ErrorType") 1458 if len(code) != 0 { 1459 errorCode = restjson.SanitizeErrorCode(code) 1460 } 1461 1462 var buff [1024]byte 1463 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1464 1465 body := io.TeeReader(errorBody, ringBuffer) 1466 decoder := json.NewDecoder(body) 1467 decoder.UseNumber() 1468 code, message, err := restjson.GetErrorInfo(decoder) 1469 if err != nil { 1470 var snapshot bytes.Buffer 1471 io.Copy(&snapshot, ringBuffer) 1472 err = &smithy.DeserializationError{ 1473 Err: fmt.Errorf("failed to decode response body, %w", err), 1474 Snapshot: snapshot.Bytes(), 1475 } 1476 return err 1477 } 1478 1479 errorBody.Seek(0, io.SeekStart) 1480 if len(code) != 0 { 1481 errorCode = restjson.SanitizeErrorCode(code) 1482 } 1483 if len(message) != 0 { 1484 errorMessage = message 1485 } 1486 1487 switch { 1488 case strings.EqualFold("CloudHsmAccessDeniedException", errorCode): 1489 return awsAwsjson11_deserializeErrorCloudHsmAccessDeniedException(response, errorBody) 1490 1491 case strings.EqualFold("CloudHsmInternalFailureException", errorCode): 1492 return awsAwsjson11_deserializeErrorCloudHsmInternalFailureException(response, errorBody) 1493 1494 case strings.EqualFold("CloudHsmInvalidRequestException", errorCode): 1495 return awsAwsjson11_deserializeErrorCloudHsmInvalidRequestException(response, errorBody) 1496 1497 case strings.EqualFold("CloudHsmResourceNotFoundException", errorCode): 1498 return awsAwsjson11_deserializeErrorCloudHsmResourceNotFoundException(response, errorBody) 1499 1500 case strings.EqualFold("CloudHsmServiceException", errorCode): 1501 return awsAwsjson11_deserializeErrorCloudHsmServiceException(response, errorBody) 1502 1503 default: 1504 genericError := &smithy.GenericAPIError{ 1505 Code: errorCode, 1506 Message: errorMessage, 1507 } 1508 return genericError 1509 1510 } 1511} 1512 1513type awsAwsjson11_deserializeOpRestoreBackup struct { 1514} 1515 1516func (*awsAwsjson11_deserializeOpRestoreBackup) ID() string { 1517 return "OperationDeserializer" 1518} 1519 1520func (m *awsAwsjson11_deserializeOpRestoreBackup) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1521 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1522) { 1523 out, metadata, err = next.HandleDeserialize(ctx, in) 1524 if err != nil { 1525 return out, metadata, err 1526 } 1527 1528 response, ok := out.RawResponse.(*smithyhttp.Response) 1529 if !ok { 1530 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1531 } 1532 1533 if response.StatusCode < 200 || response.StatusCode >= 300 { 1534 return out, metadata, awsAwsjson11_deserializeOpErrorRestoreBackup(response, &metadata) 1535 } 1536 output := &RestoreBackupOutput{} 1537 out.Result = output 1538 1539 var buff [1024]byte 1540 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1541 1542 body := io.TeeReader(response.Body, ringBuffer) 1543 decoder := json.NewDecoder(body) 1544 decoder.UseNumber() 1545 var shape interface{} 1546 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1547 var snapshot bytes.Buffer 1548 io.Copy(&snapshot, ringBuffer) 1549 err = &smithy.DeserializationError{ 1550 Err: fmt.Errorf("failed to decode response body, %w", err), 1551 Snapshot: snapshot.Bytes(), 1552 } 1553 return out, metadata, err 1554 } 1555 1556 err = awsAwsjson11_deserializeOpDocumentRestoreBackupOutput(&output, shape) 1557 if err != nil { 1558 var snapshot bytes.Buffer 1559 io.Copy(&snapshot, ringBuffer) 1560 err = &smithy.DeserializationError{ 1561 Err: fmt.Errorf("failed to decode response body, %w", err), 1562 Snapshot: snapshot.Bytes(), 1563 } 1564 return out, metadata, err 1565 } 1566 1567 return out, metadata, err 1568} 1569 1570func awsAwsjson11_deserializeOpErrorRestoreBackup(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1571 var errorBuffer bytes.Buffer 1572 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1573 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1574 } 1575 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1576 1577 errorCode := "UnknownError" 1578 errorMessage := errorCode 1579 1580 code := response.Header.Get("X-Amzn-ErrorType") 1581 if len(code) != 0 { 1582 errorCode = restjson.SanitizeErrorCode(code) 1583 } 1584 1585 var buff [1024]byte 1586 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1587 1588 body := io.TeeReader(errorBody, ringBuffer) 1589 decoder := json.NewDecoder(body) 1590 decoder.UseNumber() 1591 code, message, err := restjson.GetErrorInfo(decoder) 1592 if err != nil { 1593 var snapshot bytes.Buffer 1594 io.Copy(&snapshot, ringBuffer) 1595 err = &smithy.DeserializationError{ 1596 Err: fmt.Errorf("failed to decode response body, %w", err), 1597 Snapshot: snapshot.Bytes(), 1598 } 1599 return err 1600 } 1601 1602 errorBody.Seek(0, io.SeekStart) 1603 if len(code) != 0 { 1604 errorCode = restjson.SanitizeErrorCode(code) 1605 } 1606 if len(message) != 0 { 1607 errorMessage = message 1608 } 1609 1610 switch { 1611 case strings.EqualFold("CloudHsmAccessDeniedException", errorCode): 1612 return awsAwsjson11_deserializeErrorCloudHsmAccessDeniedException(response, errorBody) 1613 1614 case strings.EqualFold("CloudHsmInternalFailureException", errorCode): 1615 return awsAwsjson11_deserializeErrorCloudHsmInternalFailureException(response, errorBody) 1616 1617 case strings.EqualFold("CloudHsmInvalidRequestException", errorCode): 1618 return awsAwsjson11_deserializeErrorCloudHsmInvalidRequestException(response, errorBody) 1619 1620 case strings.EqualFold("CloudHsmResourceNotFoundException", errorCode): 1621 return awsAwsjson11_deserializeErrorCloudHsmResourceNotFoundException(response, errorBody) 1622 1623 case strings.EqualFold("CloudHsmServiceException", errorCode): 1624 return awsAwsjson11_deserializeErrorCloudHsmServiceException(response, errorBody) 1625 1626 default: 1627 genericError := &smithy.GenericAPIError{ 1628 Code: errorCode, 1629 Message: errorMessage, 1630 } 1631 return genericError 1632 1633 } 1634} 1635 1636type awsAwsjson11_deserializeOpTagResource struct { 1637} 1638 1639func (*awsAwsjson11_deserializeOpTagResource) ID() string { 1640 return "OperationDeserializer" 1641} 1642 1643func (m *awsAwsjson11_deserializeOpTagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1644 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1645) { 1646 out, metadata, err = next.HandleDeserialize(ctx, in) 1647 if err != nil { 1648 return out, metadata, err 1649 } 1650 1651 response, ok := out.RawResponse.(*smithyhttp.Response) 1652 if !ok { 1653 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1654 } 1655 1656 if response.StatusCode < 200 || response.StatusCode >= 300 { 1657 return out, metadata, awsAwsjson11_deserializeOpErrorTagResource(response, &metadata) 1658 } 1659 output := &TagResourceOutput{} 1660 out.Result = output 1661 1662 var buff [1024]byte 1663 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1664 1665 body := io.TeeReader(response.Body, ringBuffer) 1666 decoder := json.NewDecoder(body) 1667 decoder.UseNumber() 1668 var shape interface{} 1669 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1670 var snapshot bytes.Buffer 1671 io.Copy(&snapshot, ringBuffer) 1672 err = &smithy.DeserializationError{ 1673 Err: fmt.Errorf("failed to decode response body, %w", err), 1674 Snapshot: snapshot.Bytes(), 1675 } 1676 return out, metadata, err 1677 } 1678 1679 err = awsAwsjson11_deserializeOpDocumentTagResourceOutput(&output, shape) 1680 if err != nil { 1681 var snapshot bytes.Buffer 1682 io.Copy(&snapshot, ringBuffer) 1683 err = &smithy.DeserializationError{ 1684 Err: fmt.Errorf("failed to decode response body, %w", err), 1685 Snapshot: snapshot.Bytes(), 1686 } 1687 return out, metadata, err 1688 } 1689 1690 return out, metadata, err 1691} 1692 1693func awsAwsjson11_deserializeOpErrorTagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1694 var errorBuffer bytes.Buffer 1695 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1696 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1697 } 1698 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1699 1700 errorCode := "UnknownError" 1701 errorMessage := errorCode 1702 1703 code := response.Header.Get("X-Amzn-ErrorType") 1704 if len(code) != 0 { 1705 errorCode = restjson.SanitizeErrorCode(code) 1706 } 1707 1708 var buff [1024]byte 1709 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1710 1711 body := io.TeeReader(errorBody, ringBuffer) 1712 decoder := json.NewDecoder(body) 1713 decoder.UseNumber() 1714 code, message, err := restjson.GetErrorInfo(decoder) 1715 if err != nil { 1716 var snapshot bytes.Buffer 1717 io.Copy(&snapshot, ringBuffer) 1718 err = &smithy.DeserializationError{ 1719 Err: fmt.Errorf("failed to decode response body, %w", err), 1720 Snapshot: snapshot.Bytes(), 1721 } 1722 return err 1723 } 1724 1725 errorBody.Seek(0, io.SeekStart) 1726 if len(code) != 0 { 1727 errorCode = restjson.SanitizeErrorCode(code) 1728 } 1729 if len(message) != 0 { 1730 errorMessage = message 1731 } 1732 1733 switch { 1734 case strings.EqualFold("CloudHsmAccessDeniedException", errorCode): 1735 return awsAwsjson11_deserializeErrorCloudHsmAccessDeniedException(response, errorBody) 1736 1737 case strings.EqualFold("CloudHsmInternalFailureException", errorCode): 1738 return awsAwsjson11_deserializeErrorCloudHsmInternalFailureException(response, errorBody) 1739 1740 case strings.EqualFold("CloudHsmInvalidRequestException", errorCode): 1741 return awsAwsjson11_deserializeErrorCloudHsmInvalidRequestException(response, errorBody) 1742 1743 case strings.EqualFold("CloudHsmResourceNotFoundException", errorCode): 1744 return awsAwsjson11_deserializeErrorCloudHsmResourceNotFoundException(response, errorBody) 1745 1746 case strings.EqualFold("CloudHsmServiceException", errorCode): 1747 return awsAwsjson11_deserializeErrorCloudHsmServiceException(response, errorBody) 1748 1749 case strings.EqualFold("CloudHsmTagException", errorCode): 1750 return awsAwsjson11_deserializeErrorCloudHsmTagException(response, errorBody) 1751 1752 default: 1753 genericError := &smithy.GenericAPIError{ 1754 Code: errorCode, 1755 Message: errorMessage, 1756 } 1757 return genericError 1758 1759 } 1760} 1761 1762type awsAwsjson11_deserializeOpUntagResource struct { 1763} 1764 1765func (*awsAwsjson11_deserializeOpUntagResource) ID() string { 1766 return "OperationDeserializer" 1767} 1768 1769func (m *awsAwsjson11_deserializeOpUntagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1770 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1771) { 1772 out, metadata, err = next.HandleDeserialize(ctx, in) 1773 if err != nil { 1774 return out, metadata, err 1775 } 1776 1777 response, ok := out.RawResponse.(*smithyhttp.Response) 1778 if !ok { 1779 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1780 } 1781 1782 if response.StatusCode < 200 || response.StatusCode >= 300 { 1783 return out, metadata, awsAwsjson11_deserializeOpErrorUntagResource(response, &metadata) 1784 } 1785 output := &UntagResourceOutput{} 1786 out.Result = output 1787 1788 var buff [1024]byte 1789 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1790 1791 body := io.TeeReader(response.Body, ringBuffer) 1792 decoder := json.NewDecoder(body) 1793 decoder.UseNumber() 1794 var shape interface{} 1795 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1796 var snapshot bytes.Buffer 1797 io.Copy(&snapshot, ringBuffer) 1798 err = &smithy.DeserializationError{ 1799 Err: fmt.Errorf("failed to decode response body, %w", err), 1800 Snapshot: snapshot.Bytes(), 1801 } 1802 return out, metadata, err 1803 } 1804 1805 err = awsAwsjson11_deserializeOpDocumentUntagResourceOutput(&output, shape) 1806 if err != nil { 1807 var snapshot bytes.Buffer 1808 io.Copy(&snapshot, ringBuffer) 1809 err = &smithy.DeserializationError{ 1810 Err: fmt.Errorf("failed to decode response body, %w", err), 1811 Snapshot: snapshot.Bytes(), 1812 } 1813 return out, metadata, err 1814 } 1815 1816 return out, metadata, err 1817} 1818 1819func awsAwsjson11_deserializeOpErrorUntagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1820 var errorBuffer bytes.Buffer 1821 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1822 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1823 } 1824 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1825 1826 errorCode := "UnknownError" 1827 errorMessage := errorCode 1828 1829 code := response.Header.Get("X-Amzn-ErrorType") 1830 if len(code) != 0 { 1831 errorCode = restjson.SanitizeErrorCode(code) 1832 } 1833 1834 var buff [1024]byte 1835 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1836 1837 body := io.TeeReader(errorBody, ringBuffer) 1838 decoder := json.NewDecoder(body) 1839 decoder.UseNumber() 1840 code, message, err := restjson.GetErrorInfo(decoder) 1841 if err != nil { 1842 var snapshot bytes.Buffer 1843 io.Copy(&snapshot, ringBuffer) 1844 err = &smithy.DeserializationError{ 1845 Err: fmt.Errorf("failed to decode response body, %w", err), 1846 Snapshot: snapshot.Bytes(), 1847 } 1848 return err 1849 } 1850 1851 errorBody.Seek(0, io.SeekStart) 1852 if len(code) != 0 { 1853 errorCode = restjson.SanitizeErrorCode(code) 1854 } 1855 if len(message) != 0 { 1856 errorMessage = message 1857 } 1858 1859 switch { 1860 case strings.EqualFold("CloudHsmAccessDeniedException", errorCode): 1861 return awsAwsjson11_deserializeErrorCloudHsmAccessDeniedException(response, errorBody) 1862 1863 case strings.EqualFold("CloudHsmInternalFailureException", errorCode): 1864 return awsAwsjson11_deserializeErrorCloudHsmInternalFailureException(response, errorBody) 1865 1866 case strings.EqualFold("CloudHsmInvalidRequestException", errorCode): 1867 return awsAwsjson11_deserializeErrorCloudHsmInvalidRequestException(response, errorBody) 1868 1869 case strings.EqualFold("CloudHsmResourceNotFoundException", errorCode): 1870 return awsAwsjson11_deserializeErrorCloudHsmResourceNotFoundException(response, errorBody) 1871 1872 case strings.EqualFold("CloudHsmServiceException", errorCode): 1873 return awsAwsjson11_deserializeErrorCloudHsmServiceException(response, errorBody) 1874 1875 case strings.EqualFold("CloudHsmTagException", errorCode): 1876 return awsAwsjson11_deserializeErrorCloudHsmTagException(response, errorBody) 1877 1878 default: 1879 genericError := &smithy.GenericAPIError{ 1880 Code: errorCode, 1881 Message: errorMessage, 1882 } 1883 return genericError 1884 1885 } 1886} 1887 1888func awsAwsjson11_deserializeErrorCloudHsmAccessDeniedException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 1889 var buff [1024]byte 1890 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1891 1892 body := io.TeeReader(errorBody, ringBuffer) 1893 decoder := json.NewDecoder(body) 1894 decoder.UseNumber() 1895 var shape interface{} 1896 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1897 var snapshot bytes.Buffer 1898 io.Copy(&snapshot, ringBuffer) 1899 err = &smithy.DeserializationError{ 1900 Err: fmt.Errorf("failed to decode response body, %w", err), 1901 Snapshot: snapshot.Bytes(), 1902 } 1903 return err 1904 } 1905 1906 output := &types.CloudHsmAccessDeniedException{} 1907 err := awsAwsjson11_deserializeDocumentCloudHsmAccessDeniedException(&output, shape) 1908 1909 if err != nil { 1910 var snapshot bytes.Buffer 1911 io.Copy(&snapshot, ringBuffer) 1912 err = &smithy.DeserializationError{ 1913 Err: fmt.Errorf("failed to decode response body, %w", err), 1914 Snapshot: snapshot.Bytes(), 1915 } 1916 return err 1917 } 1918 1919 errorBody.Seek(0, io.SeekStart) 1920 return output 1921} 1922 1923func awsAwsjson11_deserializeErrorCloudHsmInternalFailureException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 1924 var buff [1024]byte 1925 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1926 1927 body := io.TeeReader(errorBody, ringBuffer) 1928 decoder := json.NewDecoder(body) 1929 decoder.UseNumber() 1930 var shape interface{} 1931 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1932 var snapshot bytes.Buffer 1933 io.Copy(&snapshot, ringBuffer) 1934 err = &smithy.DeserializationError{ 1935 Err: fmt.Errorf("failed to decode response body, %w", err), 1936 Snapshot: snapshot.Bytes(), 1937 } 1938 return err 1939 } 1940 1941 output := &types.CloudHsmInternalFailureException{} 1942 err := awsAwsjson11_deserializeDocumentCloudHsmInternalFailureException(&output, shape) 1943 1944 if err != nil { 1945 var snapshot bytes.Buffer 1946 io.Copy(&snapshot, ringBuffer) 1947 err = &smithy.DeserializationError{ 1948 Err: fmt.Errorf("failed to decode response body, %w", err), 1949 Snapshot: snapshot.Bytes(), 1950 } 1951 return err 1952 } 1953 1954 errorBody.Seek(0, io.SeekStart) 1955 return output 1956} 1957 1958func awsAwsjson11_deserializeErrorCloudHsmInvalidRequestException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 1959 var buff [1024]byte 1960 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1961 1962 body := io.TeeReader(errorBody, ringBuffer) 1963 decoder := json.NewDecoder(body) 1964 decoder.UseNumber() 1965 var shape interface{} 1966 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1967 var snapshot bytes.Buffer 1968 io.Copy(&snapshot, ringBuffer) 1969 err = &smithy.DeserializationError{ 1970 Err: fmt.Errorf("failed to decode response body, %w", err), 1971 Snapshot: snapshot.Bytes(), 1972 } 1973 return err 1974 } 1975 1976 output := &types.CloudHsmInvalidRequestException{} 1977 err := awsAwsjson11_deserializeDocumentCloudHsmInvalidRequestException(&output, shape) 1978 1979 if err != nil { 1980 var snapshot bytes.Buffer 1981 io.Copy(&snapshot, ringBuffer) 1982 err = &smithy.DeserializationError{ 1983 Err: fmt.Errorf("failed to decode response body, %w", err), 1984 Snapshot: snapshot.Bytes(), 1985 } 1986 return err 1987 } 1988 1989 errorBody.Seek(0, io.SeekStart) 1990 return output 1991} 1992 1993func awsAwsjson11_deserializeErrorCloudHsmResourceNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 1994 var buff [1024]byte 1995 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1996 1997 body := io.TeeReader(errorBody, ringBuffer) 1998 decoder := json.NewDecoder(body) 1999 decoder.UseNumber() 2000 var shape interface{} 2001 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2002 var snapshot bytes.Buffer 2003 io.Copy(&snapshot, ringBuffer) 2004 err = &smithy.DeserializationError{ 2005 Err: fmt.Errorf("failed to decode response body, %w", err), 2006 Snapshot: snapshot.Bytes(), 2007 } 2008 return err 2009 } 2010 2011 output := &types.CloudHsmResourceNotFoundException{} 2012 err := awsAwsjson11_deserializeDocumentCloudHsmResourceNotFoundException(&output, shape) 2013 2014 if err != nil { 2015 var snapshot bytes.Buffer 2016 io.Copy(&snapshot, ringBuffer) 2017 err = &smithy.DeserializationError{ 2018 Err: fmt.Errorf("failed to decode response body, %w", err), 2019 Snapshot: snapshot.Bytes(), 2020 } 2021 return err 2022 } 2023 2024 errorBody.Seek(0, io.SeekStart) 2025 return output 2026} 2027 2028func awsAwsjson11_deserializeErrorCloudHsmServiceException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 2029 var buff [1024]byte 2030 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2031 2032 body := io.TeeReader(errorBody, ringBuffer) 2033 decoder := json.NewDecoder(body) 2034 decoder.UseNumber() 2035 var shape interface{} 2036 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2037 var snapshot bytes.Buffer 2038 io.Copy(&snapshot, ringBuffer) 2039 err = &smithy.DeserializationError{ 2040 Err: fmt.Errorf("failed to decode response body, %w", err), 2041 Snapshot: snapshot.Bytes(), 2042 } 2043 return err 2044 } 2045 2046 output := &types.CloudHsmServiceException{} 2047 err := awsAwsjson11_deserializeDocumentCloudHsmServiceException(&output, shape) 2048 2049 if err != nil { 2050 var snapshot bytes.Buffer 2051 io.Copy(&snapshot, ringBuffer) 2052 err = &smithy.DeserializationError{ 2053 Err: fmt.Errorf("failed to decode response body, %w", err), 2054 Snapshot: snapshot.Bytes(), 2055 } 2056 return err 2057 } 2058 2059 errorBody.Seek(0, io.SeekStart) 2060 return output 2061} 2062 2063func awsAwsjson11_deserializeErrorCloudHsmTagException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 2064 var buff [1024]byte 2065 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2066 2067 body := io.TeeReader(errorBody, ringBuffer) 2068 decoder := json.NewDecoder(body) 2069 decoder.UseNumber() 2070 var shape interface{} 2071 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2072 var snapshot bytes.Buffer 2073 io.Copy(&snapshot, ringBuffer) 2074 err = &smithy.DeserializationError{ 2075 Err: fmt.Errorf("failed to decode response body, %w", err), 2076 Snapshot: snapshot.Bytes(), 2077 } 2078 return err 2079 } 2080 2081 output := &types.CloudHsmTagException{} 2082 err := awsAwsjson11_deserializeDocumentCloudHsmTagException(&output, shape) 2083 2084 if err != nil { 2085 var snapshot bytes.Buffer 2086 io.Copy(&snapshot, ringBuffer) 2087 err = &smithy.DeserializationError{ 2088 Err: fmt.Errorf("failed to decode response body, %w", err), 2089 Snapshot: snapshot.Bytes(), 2090 } 2091 return err 2092 } 2093 2094 errorBody.Seek(0, io.SeekStart) 2095 return output 2096} 2097 2098func awsAwsjson11_deserializeDocumentBackup(v **types.Backup, value interface{}) error { 2099 if v == nil { 2100 return fmt.Errorf("unexpected nil of type %T", v) 2101 } 2102 if value == nil { 2103 return nil 2104 } 2105 2106 shape, ok := value.(map[string]interface{}) 2107 if !ok { 2108 return fmt.Errorf("unexpected JSON type %v", value) 2109 } 2110 2111 var sv *types.Backup 2112 if *v == nil { 2113 sv = &types.Backup{} 2114 } else { 2115 sv = *v 2116 } 2117 2118 for key, value := range shape { 2119 switch key { 2120 case "BackupId": 2121 if value != nil { 2122 jtv, ok := value.(string) 2123 if !ok { 2124 return fmt.Errorf("expected BackupId to be of type string, got %T instead", value) 2125 } 2126 sv.BackupId = ptr.String(jtv) 2127 } 2128 2129 case "BackupState": 2130 if value != nil { 2131 jtv, ok := value.(string) 2132 if !ok { 2133 return fmt.Errorf("expected BackupState to be of type string, got %T instead", value) 2134 } 2135 sv.BackupState = types.BackupState(jtv) 2136 } 2137 2138 case "ClusterId": 2139 if value != nil { 2140 jtv, ok := value.(string) 2141 if !ok { 2142 return fmt.Errorf("expected ClusterId to be of type string, got %T instead", value) 2143 } 2144 sv.ClusterId = ptr.String(jtv) 2145 } 2146 2147 case "CopyTimestamp": 2148 if value != nil { 2149 jtv, ok := value.(json.Number) 2150 if !ok { 2151 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 2152 } 2153 f64, err := jtv.Float64() 2154 if err != nil { 2155 return err 2156 } 2157 sv.CopyTimestamp = ptr.Time(smithytime.ParseEpochSeconds(f64)) 2158 } 2159 2160 case "CreateTimestamp": 2161 if value != nil { 2162 jtv, ok := value.(json.Number) 2163 if !ok { 2164 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 2165 } 2166 f64, err := jtv.Float64() 2167 if err != nil { 2168 return err 2169 } 2170 sv.CreateTimestamp = ptr.Time(smithytime.ParseEpochSeconds(f64)) 2171 } 2172 2173 case "DeleteTimestamp": 2174 if value != nil { 2175 jtv, ok := value.(json.Number) 2176 if !ok { 2177 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 2178 } 2179 f64, err := jtv.Float64() 2180 if err != nil { 2181 return err 2182 } 2183 sv.DeleteTimestamp = ptr.Time(smithytime.ParseEpochSeconds(f64)) 2184 } 2185 2186 case "NeverExpires": 2187 if value != nil { 2188 jtv, ok := value.(bool) 2189 if !ok { 2190 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 2191 } 2192 sv.NeverExpires = ptr.Bool(jtv) 2193 } 2194 2195 case "SourceBackup": 2196 if value != nil { 2197 jtv, ok := value.(string) 2198 if !ok { 2199 return fmt.Errorf("expected BackupId to be of type string, got %T instead", value) 2200 } 2201 sv.SourceBackup = ptr.String(jtv) 2202 } 2203 2204 case "SourceCluster": 2205 if value != nil { 2206 jtv, ok := value.(string) 2207 if !ok { 2208 return fmt.Errorf("expected ClusterId to be of type string, got %T instead", value) 2209 } 2210 sv.SourceCluster = ptr.String(jtv) 2211 } 2212 2213 case "SourceRegion": 2214 if value != nil { 2215 jtv, ok := value.(string) 2216 if !ok { 2217 return fmt.Errorf("expected Region to be of type string, got %T instead", value) 2218 } 2219 sv.SourceRegion = ptr.String(jtv) 2220 } 2221 2222 case "TagList": 2223 if err := awsAwsjson11_deserializeDocumentTagList(&sv.TagList, value); err != nil { 2224 return err 2225 } 2226 2227 default: 2228 _, _ = key, value 2229 2230 } 2231 } 2232 *v = sv 2233 return nil 2234} 2235 2236func awsAwsjson11_deserializeDocumentBackupRetentionPolicy(v **types.BackupRetentionPolicy, value interface{}) error { 2237 if v == nil { 2238 return fmt.Errorf("unexpected nil of type %T", v) 2239 } 2240 if value == nil { 2241 return nil 2242 } 2243 2244 shape, ok := value.(map[string]interface{}) 2245 if !ok { 2246 return fmt.Errorf("unexpected JSON type %v", value) 2247 } 2248 2249 var sv *types.BackupRetentionPolicy 2250 if *v == nil { 2251 sv = &types.BackupRetentionPolicy{} 2252 } else { 2253 sv = *v 2254 } 2255 2256 for key, value := range shape { 2257 switch key { 2258 case "Type": 2259 if value != nil { 2260 jtv, ok := value.(string) 2261 if !ok { 2262 return fmt.Errorf("expected BackupRetentionType to be of type string, got %T instead", value) 2263 } 2264 sv.Type = types.BackupRetentionType(jtv) 2265 } 2266 2267 case "Value": 2268 if value != nil { 2269 jtv, ok := value.(string) 2270 if !ok { 2271 return fmt.Errorf("expected BackupRetentionValue to be of type string, got %T instead", value) 2272 } 2273 sv.Value = ptr.String(jtv) 2274 } 2275 2276 default: 2277 _, _ = key, value 2278 2279 } 2280 } 2281 *v = sv 2282 return nil 2283} 2284 2285func awsAwsjson11_deserializeDocumentBackups(v *[]types.Backup, value interface{}) error { 2286 if v == nil { 2287 return fmt.Errorf("unexpected nil of type %T", v) 2288 } 2289 if value == nil { 2290 return nil 2291 } 2292 2293 shape, ok := value.([]interface{}) 2294 if !ok { 2295 return fmt.Errorf("unexpected JSON type %v", value) 2296 } 2297 2298 var cv []types.Backup 2299 if *v == nil { 2300 cv = []types.Backup{} 2301 } else { 2302 cv = *v 2303 } 2304 2305 for _, value := range shape { 2306 var col types.Backup 2307 destAddr := &col 2308 if err := awsAwsjson11_deserializeDocumentBackup(&destAddr, value); err != nil { 2309 return err 2310 } 2311 col = *destAddr 2312 cv = append(cv, col) 2313 2314 } 2315 *v = cv 2316 return nil 2317} 2318 2319func awsAwsjson11_deserializeDocumentCertificates(v **types.Certificates, value interface{}) error { 2320 if v == nil { 2321 return fmt.Errorf("unexpected nil of type %T", v) 2322 } 2323 if value == nil { 2324 return nil 2325 } 2326 2327 shape, ok := value.(map[string]interface{}) 2328 if !ok { 2329 return fmt.Errorf("unexpected JSON type %v", value) 2330 } 2331 2332 var sv *types.Certificates 2333 if *v == nil { 2334 sv = &types.Certificates{} 2335 } else { 2336 sv = *v 2337 } 2338 2339 for key, value := range shape { 2340 switch key { 2341 case "AwsHardwareCertificate": 2342 if value != nil { 2343 jtv, ok := value.(string) 2344 if !ok { 2345 return fmt.Errorf("expected Cert to be of type string, got %T instead", value) 2346 } 2347 sv.AwsHardwareCertificate = ptr.String(jtv) 2348 } 2349 2350 case "ClusterCertificate": 2351 if value != nil { 2352 jtv, ok := value.(string) 2353 if !ok { 2354 return fmt.Errorf("expected Cert to be of type string, got %T instead", value) 2355 } 2356 sv.ClusterCertificate = ptr.String(jtv) 2357 } 2358 2359 case "ClusterCsr": 2360 if value != nil { 2361 jtv, ok := value.(string) 2362 if !ok { 2363 return fmt.Errorf("expected Cert to be of type string, got %T instead", value) 2364 } 2365 sv.ClusterCsr = ptr.String(jtv) 2366 } 2367 2368 case "HsmCertificate": 2369 if value != nil { 2370 jtv, ok := value.(string) 2371 if !ok { 2372 return fmt.Errorf("expected Cert to be of type string, got %T instead", value) 2373 } 2374 sv.HsmCertificate = ptr.String(jtv) 2375 } 2376 2377 case "ManufacturerHardwareCertificate": 2378 if value != nil { 2379 jtv, ok := value.(string) 2380 if !ok { 2381 return fmt.Errorf("expected Cert to be of type string, got %T instead", value) 2382 } 2383 sv.ManufacturerHardwareCertificate = ptr.String(jtv) 2384 } 2385 2386 default: 2387 _, _ = key, value 2388 2389 } 2390 } 2391 *v = sv 2392 return nil 2393} 2394 2395func awsAwsjson11_deserializeDocumentCloudHsmAccessDeniedException(v **types.CloudHsmAccessDeniedException, value interface{}) error { 2396 if v == nil { 2397 return fmt.Errorf("unexpected nil of type %T", v) 2398 } 2399 if value == nil { 2400 return nil 2401 } 2402 2403 shape, ok := value.(map[string]interface{}) 2404 if !ok { 2405 return fmt.Errorf("unexpected JSON type %v", value) 2406 } 2407 2408 var sv *types.CloudHsmAccessDeniedException 2409 if *v == nil { 2410 sv = &types.CloudHsmAccessDeniedException{} 2411 } else { 2412 sv = *v 2413 } 2414 2415 for key, value := range shape { 2416 switch key { 2417 case "Message": 2418 if value != nil { 2419 jtv, ok := value.(string) 2420 if !ok { 2421 return fmt.Errorf("expected errorMessage to be of type string, got %T instead", value) 2422 } 2423 sv.Message = ptr.String(jtv) 2424 } 2425 2426 default: 2427 _, _ = key, value 2428 2429 } 2430 } 2431 *v = sv 2432 return nil 2433} 2434 2435func awsAwsjson11_deserializeDocumentCloudHsmInternalFailureException(v **types.CloudHsmInternalFailureException, value interface{}) error { 2436 if v == nil { 2437 return fmt.Errorf("unexpected nil of type %T", v) 2438 } 2439 if value == nil { 2440 return nil 2441 } 2442 2443 shape, ok := value.(map[string]interface{}) 2444 if !ok { 2445 return fmt.Errorf("unexpected JSON type %v", value) 2446 } 2447 2448 var sv *types.CloudHsmInternalFailureException 2449 if *v == nil { 2450 sv = &types.CloudHsmInternalFailureException{} 2451 } else { 2452 sv = *v 2453 } 2454 2455 for key, value := range shape { 2456 switch key { 2457 case "Message": 2458 if value != nil { 2459 jtv, ok := value.(string) 2460 if !ok { 2461 return fmt.Errorf("expected errorMessage to be of type string, got %T instead", value) 2462 } 2463 sv.Message = ptr.String(jtv) 2464 } 2465 2466 default: 2467 _, _ = key, value 2468 2469 } 2470 } 2471 *v = sv 2472 return nil 2473} 2474 2475func awsAwsjson11_deserializeDocumentCloudHsmInvalidRequestException(v **types.CloudHsmInvalidRequestException, value interface{}) error { 2476 if v == nil { 2477 return fmt.Errorf("unexpected nil of type %T", v) 2478 } 2479 if value == nil { 2480 return nil 2481 } 2482 2483 shape, ok := value.(map[string]interface{}) 2484 if !ok { 2485 return fmt.Errorf("unexpected JSON type %v", value) 2486 } 2487 2488 var sv *types.CloudHsmInvalidRequestException 2489 if *v == nil { 2490 sv = &types.CloudHsmInvalidRequestException{} 2491 } else { 2492 sv = *v 2493 } 2494 2495 for key, value := range shape { 2496 switch key { 2497 case "Message": 2498 if value != nil { 2499 jtv, ok := value.(string) 2500 if !ok { 2501 return fmt.Errorf("expected errorMessage to be of type string, got %T instead", value) 2502 } 2503 sv.Message = ptr.String(jtv) 2504 } 2505 2506 default: 2507 _, _ = key, value 2508 2509 } 2510 } 2511 *v = sv 2512 return nil 2513} 2514 2515func awsAwsjson11_deserializeDocumentCloudHsmResourceNotFoundException(v **types.CloudHsmResourceNotFoundException, value interface{}) error { 2516 if v == nil { 2517 return fmt.Errorf("unexpected nil of type %T", v) 2518 } 2519 if value == nil { 2520 return nil 2521 } 2522 2523 shape, ok := value.(map[string]interface{}) 2524 if !ok { 2525 return fmt.Errorf("unexpected JSON type %v", value) 2526 } 2527 2528 var sv *types.CloudHsmResourceNotFoundException 2529 if *v == nil { 2530 sv = &types.CloudHsmResourceNotFoundException{} 2531 } else { 2532 sv = *v 2533 } 2534 2535 for key, value := range shape { 2536 switch key { 2537 case "Message": 2538 if value != nil { 2539 jtv, ok := value.(string) 2540 if !ok { 2541 return fmt.Errorf("expected errorMessage to be of type string, got %T instead", value) 2542 } 2543 sv.Message = ptr.String(jtv) 2544 } 2545 2546 default: 2547 _, _ = key, value 2548 2549 } 2550 } 2551 *v = sv 2552 return nil 2553} 2554 2555func awsAwsjson11_deserializeDocumentCloudHsmServiceException(v **types.CloudHsmServiceException, value interface{}) error { 2556 if v == nil { 2557 return fmt.Errorf("unexpected nil of type %T", v) 2558 } 2559 if value == nil { 2560 return nil 2561 } 2562 2563 shape, ok := value.(map[string]interface{}) 2564 if !ok { 2565 return fmt.Errorf("unexpected JSON type %v", value) 2566 } 2567 2568 var sv *types.CloudHsmServiceException 2569 if *v == nil { 2570 sv = &types.CloudHsmServiceException{} 2571 } else { 2572 sv = *v 2573 } 2574 2575 for key, value := range shape { 2576 switch key { 2577 case "Message": 2578 if value != nil { 2579 jtv, ok := value.(string) 2580 if !ok { 2581 return fmt.Errorf("expected errorMessage to be of type string, got %T instead", value) 2582 } 2583 sv.Message = ptr.String(jtv) 2584 } 2585 2586 default: 2587 _, _ = key, value 2588 2589 } 2590 } 2591 *v = sv 2592 return nil 2593} 2594 2595func awsAwsjson11_deserializeDocumentCloudHsmTagException(v **types.CloudHsmTagException, value interface{}) error { 2596 if v == nil { 2597 return fmt.Errorf("unexpected nil of type %T", v) 2598 } 2599 if value == nil { 2600 return nil 2601 } 2602 2603 shape, ok := value.(map[string]interface{}) 2604 if !ok { 2605 return fmt.Errorf("unexpected JSON type %v", value) 2606 } 2607 2608 var sv *types.CloudHsmTagException 2609 if *v == nil { 2610 sv = &types.CloudHsmTagException{} 2611 } else { 2612 sv = *v 2613 } 2614 2615 for key, value := range shape { 2616 switch key { 2617 case "Message": 2618 if value != nil { 2619 jtv, ok := value.(string) 2620 if !ok { 2621 return fmt.Errorf("expected errorMessage to be of type string, got %T instead", value) 2622 } 2623 sv.Message = ptr.String(jtv) 2624 } 2625 2626 default: 2627 _, _ = key, value 2628 2629 } 2630 } 2631 *v = sv 2632 return nil 2633} 2634 2635func awsAwsjson11_deserializeDocumentCluster(v **types.Cluster, value interface{}) error { 2636 if v == nil { 2637 return fmt.Errorf("unexpected nil of type %T", v) 2638 } 2639 if value == nil { 2640 return nil 2641 } 2642 2643 shape, ok := value.(map[string]interface{}) 2644 if !ok { 2645 return fmt.Errorf("unexpected JSON type %v", value) 2646 } 2647 2648 var sv *types.Cluster 2649 if *v == nil { 2650 sv = &types.Cluster{} 2651 } else { 2652 sv = *v 2653 } 2654 2655 for key, value := range shape { 2656 switch key { 2657 case "BackupPolicy": 2658 if value != nil { 2659 jtv, ok := value.(string) 2660 if !ok { 2661 return fmt.Errorf("expected BackupPolicy to be of type string, got %T instead", value) 2662 } 2663 sv.BackupPolicy = types.BackupPolicy(jtv) 2664 } 2665 2666 case "BackupRetentionPolicy": 2667 if err := awsAwsjson11_deserializeDocumentBackupRetentionPolicy(&sv.BackupRetentionPolicy, value); err != nil { 2668 return err 2669 } 2670 2671 case "Certificates": 2672 if err := awsAwsjson11_deserializeDocumentCertificates(&sv.Certificates, value); err != nil { 2673 return err 2674 } 2675 2676 case "ClusterId": 2677 if value != nil { 2678 jtv, ok := value.(string) 2679 if !ok { 2680 return fmt.Errorf("expected ClusterId to be of type string, got %T instead", value) 2681 } 2682 sv.ClusterId = ptr.String(jtv) 2683 } 2684 2685 case "CreateTimestamp": 2686 if value != nil { 2687 jtv, ok := value.(json.Number) 2688 if !ok { 2689 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 2690 } 2691 f64, err := jtv.Float64() 2692 if err != nil { 2693 return err 2694 } 2695 sv.CreateTimestamp = ptr.Time(smithytime.ParseEpochSeconds(f64)) 2696 } 2697 2698 case "Hsms": 2699 if err := awsAwsjson11_deserializeDocumentHsms(&sv.Hsms, value); err != nil { 2700 return err 2701 } 2702 2703 case "HsmType": 2704 if value != nil { 2705 jtv, ok := value.(string) 2706 if !ok { 2707 return fmt.Errorf("expected HsmType to be of type string, got %T instead", value) 2708 } 2709 sv.HsmType = ptr.String(jtv) 2710 } 2711 2712 case "PreCoPassword": 2713 if value != nil { 2714 jtv, ok := value.(string) 2715 if !ok { 2716 return fmt.Errorf("expected PreCoPassword to be of type string, got %T instead", value) 2717 } 2718 sv.PreCoPassword = ptr.String(jtv) 2719 } 2720 2721 case "SecurityGroup": 2722 if value != nil { 2723 jtv, ok := value.(string) 2724 if !ok { 2725 return fmt.Errorf("expected SecurityGroup to be of type string, got %T instead", value) 2726 } 2727 sv.SecurityGroup = ptr.String(jtv) 2728 } 2729 2730 case "SourceBackupId": 2731 if value != nil { 2732 jtv, ok := value.(string) 2733 if !ok { 2734 return fmt.Errorf("expected BackupId to be of type string, got %T instead", value) 2735 } 2736 sv.SourceBackupId = ptr.String(jtv) 2737 } 2738 2739 case "State": 2740 if value != nil { 2741 jtv, ok := value.(string) 2742 if !ok { 2743 return fmt.Errorf("expected ClusterState to be of type string, got %T instead", value) 2744 } 2745 sv.State = types.ClusterState(jtv) 2746 } 2747 2748 case "StateMessage": 2749 if value != nil { 2750 jtv, ok := value.(string) 2751 if !ok { 2752 return fmt.Errorf("expected StateMessage to be of type string, got %T instead", value) 2753 } 2754 sv.StateMessage = ptr.String(jtv) 2755 } 2756 2757 case "SubnetMapping": 2758 if err := awsAwsjson11_deserializeDocumentExternalSubnetMapping(&sv.SubnetMapping, value); err != nil { 2759 return err 2760 } 2761 2762 case "TagList": 2763 if err := awsAwsjson11_deserializeDocumentTagList(&sv.TagList, value); err != nil { 2764 return err 2765 } 2766 2767 case "VpcId": 2768 if value != nil { 2769 jtv, ok := value.(string) 2770 if !ok { 2771 return fmt.Errorf("expected VpcId to be of type string, got %T instead", value) 2772 } 2773 sv.VpcId = ptr.String(jtv) 2774 } 2775 2776 default: 2777 _, _ = key, value 2778 2779 } 2780 } 2781 *v = sv 2782 return nil 2783} 2784 2785func awsAwsjson11_deserializeDocumentClusters(v *[]types.Cluster, value interface{}) error { 2786 if v == nil { 2787 return fmt.Errorf("unexpected nil of type %T", v) 2788 } 2789 if value == nil { 2790 return nil 2791 } 2792 2793 shape, ok := value.([]interface{}) 2794 if !ok { 2795 return fmt.Errorf("unexpected JSON type %v", value) 2796 } 2797 2798 var cv []types.Cluster 2799 if *v == nil { 2800 cv = []types.Cluster{} 2801 } else { 2802 cv = *v 2803 } 2804 2805 for _, value := range shape { 2806 var col types.Cluster 2807 destAddr := &col 2808 if err := awsAwsjson11_deserializeDocumentCluster(&destAddr, value); err != nil { 2809 return err 2810 } 2811 col = *destAddr 2812 cv = append(cv, col) 2813 2814 } 2815 *v = cv 2816 return nil 2817} 2818 2819func awsAwsjson11_deserializeDocumentDestinationBackup(v **types.DestinationBackup, value interface{}) error { 2820 if v == nil { 2821 return fmt.Errorf("unexpected nil of type %T", v) 2822 } 2823 if value == nil { 2824 return nil 2825 } 2826 2827 shape, ok := value.(map[string]interface{}) 2828 if !ok { 2829 return fmt.Errorf("unexpected JSON type %v", value) 2830 } 2831 2832 var sv *types.DestinationBackup 2833 if *v == nil { 2834 sv = &types.DestinationBackup{} 2835 } else { 2836 sv = *v 2837 } 2838 2839 for key, value := range shape { 2840 switch key { 2841 case "CreateTimestamp": 2842 if value != nil { 2843 jtv, ok := value.(json.Number) 2844 if !ok { 2845 return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value) 2846 } 2847 f64, err := jtv.Float64() 2848 if err != nil { 2849 return err 2850 } 2851 sv.CreateTimestamp = ptr.Time(smithytime.ParseEpochSeconds(f64)) 2852 } 2853 2854 case "SourceBackup": 2855 if value != nil { 2856 jtv, ok := value.(string) 2857 if !ok { 2858 return fmt.Errorf("expected BackupId to be of type string, got %T instead", value) 2859 } 2860 sv.SourceBackup = ptr.String(jtv) 2861 } 2862 2863 case "SourceCluster": 2864 if value != nil { 2865 jtv, ok := value.(string) 2866 if !ok { 2867 return fmt.Errorf("expected ClusterId to be of type string, got %T instead", value) 2868 } 2869 sv.SourceCluster = ptr.String(jtv) 2870 } 2871 2872 case "SourceRegion": 2873 if value != nil { 2874 jtv, ok := value.(string) 2875 if !ok { 2876 return fmt.Errorf("expected Region to be of type string, got %T instead", value) 2877 } 2878 sv.SourceRegion = ptr.String(jtv) 2879 } 2880 2881 default: 2882 _, _ = key, value 2883 2884 } 2885 } 2886 *v = sv 2887 return nil 2888} 2889 2890func awsAwsjson11_deserializeDocumentExternalSubnetMapping(v *map[string]string, value interface{}) error { 2891 if v == nil { 2892 return fmt.Errorf("unexpected nil of type %T", v) 2893 } 2894 if value == nil { 2895 return nil 2896 } 2897 2898 shape, ok := value.(map[string]interface{}) 2899 if !ok { 2900 return fmt.Errorf("unexpected JSON type %v", value) 2901 } 2902 2903 var mv map[string]string 2904 if *v == nil { 2905 mv = map[string]string{} 2906 } else { 2907 mv = *v 2908 } 2909 2910 for key, value := range shape { 2911 var parsedVal string 2912 if value != nil { 2913 jtv, ok := value.(string) 2914 if !ok { 2915 return fmt.Errorf("expected SubnetId to be of type string, got %T instead", value) 2916 } 2917 parsedVal = jtv 2918 } 2919 mv[key] = parsedVal 2920 2921 } 2922 *v = mv 2923 return nil 2924} 2925 2926func awsAwsjson11_deserializeDocumentHsm(v **types.Hsm, value interface{}) error { 2927 if v == nil { 2928 return fmt.Errorf("unexpected nil of type %T", v) 2929 } 2930 if value == nil { 2931 return nil 2932 } 2933 2934 shape, ok := value.(map[string]interface{}) 2935 if !ok { 2936 return fmt.Errorf("unexpected JSON type %v", value) 2937 } 2938 2939 var sv *types.Hsm 2940 if *v == nil { 2941 sv = &types.Hsm{} 2942 } else { 2943 sv = *v 2944 } 2945 2946 for key, value := range shape { 2947 switch key { 2948 case "AvailabilityZone": 2949 if value != nil { 2950 jtv, ok := value.(string) 2951 if !ok { 2952 return fmt.Errorf("expected ExternalAz to be of type string, got %T instead", value) 2953 } 2954 sv.AvailabilityZone = ptr.String(jtv) 2955 } 2956 2957 case "ClusterId": 2958 if value != nil { 2959 jtv, ok := value.(string) 2960 if !ok { 2961 return fmt.Errorf("expected ClusterId to be of type string, got %T instead", value) 2962 } 2963 sv.ClusterId = ptr.String(jtv) 2964 } 2965 2966 case "EniId": 2967 if value != nil { 2968 jtv, ok := value.(string) 2969 if !ok { 2970 return fmt.Errorf("expected EniId to be of type string, got %T instead", value) 2971 } 2972 sv.EniId = ptr.String(jtv) 2973 } 2974 2975 case "EniIp": 2976 if value != nil { 2977 jtv, ok := value.(string) 2978 if !ok { 2979 return fmt.Errorf("expected IpAddress to be of type string, got %T instead", value) 2980 } 2981 sv.EniIp = ptr.String(jtv) 2982 } 2983 2984 case "HsmId": 2985 if value != nil { 2986 jtv, ok := value.(string) 2987 if !ok { 2988 return fmt.Errorf("expected HsmId to be of type string, got %T instead", value) 2989 } 2990 sv.HsmId = ptr.String(jtv) 2991 } 2992 2993 case "State": 2994 if value != nil { 2995 jtv, ok := value.(string) 2996 if !ok { 2997 return fmt.Errorf("expected HsmState to be of type string, got %T instead", value) 2998 } 2999 sv.State = types.HsmState(jtv) 3000 } 3001 3002 case "StateMessage": 3003 if value != nil { 3004 jtv, ok := value.(string) 3005 if !ok { 3006 return fmt.Errorf("expected String to be of type string, got %T instead", value) 3007 } 3008 sv.StateMessage = ptr.String(jtv) 3009 } 3010 3011 case "SubnetId": 3012 if value != nil { 3013 jtv, ok := value.(string) 3014 if !ok { 3015 return fmt.Errorf("expected SubnetId to be of type string, got %T instead", value) 3016 } 3017 sv.SubnetId = ptr.String(jtv) 3018 } 3019 3020 default: 3021 _, _ = key, value 3022 3023 } 3024 } 3025 *v = sv 3026 return nil 3027} 3028 3029func awsAwsjson11_deserializeDocumentHsms(v *[]types.Hsm, value interface{}) error { 3030 if v == nil { 3031 return fmt.Errorf("unexpected nil of type %T", v) 3032 } 3033 if value == nil { 3034 return nil 3035 } 3036 3037 shape, ok := value.([]interface{}) 3038 if !ok { 3039 return fmt.Errorf("unexpected JSON type %v", value) 3040 } 3041 3042 var cv []types.Hsm 3043 if *v == nil { 3044 cv = []types.Hsm{} 3045 } else { 3046 cv = *v 3047 } 3048 3049 for _, value := range shape { 3050 var col types.Hsm 3051 destAddr := &col 3052 if err := awsAwsjson11_deserializeDocumentHsm(&destAddr, value); err != nil { 3053 return err 3054 } 3055 col = *destAddr 3056 cv = append(cv, col) 3057 3058 } 3059 *v = cv 3060 return nil 3061} 3062 3063func awsAwsjson11_deserializeDocumentTag(v **types.Tag, value interface{}) error { 3064 if v == nil { 3065 return fmt.Errorf("unexpected nil of type %T", v) 3066 } 3067 if value == nil { 3068 return nil 3069 } 3070 3071 shape, ok := value.(map[string]interface{}) 3072 if !ok { 3073 return fmt.Errorf("unexpected JSON type %v", value) 3074 } 3075 3076 var sv *types.Tag 3077 if *v == nil { 3078 sv = &types.Tag{} 3079 } else { 3080 sv = *v 3081 } 3082 3083 for key, value := range shape { 3084 switch key { 3085 case "Key": 3086 if value != nil { 3087 jtv, ok := value.(string) 3088 if !ok { 3089 return fmt.Errorf("expected TagKey to be of type string, got %T instead", value) 3090 } 3091 sv.Key = ptr.String(jtv) 3092 } 3093 3094 case "Value": 3095 if value != nil { 3096 jtv, ok := value.(string) 3097 if !ok { 3098 return fmt.Errorf("expected TagValue to be of type string, got %T instead", value) 3099 } 3100 sv.Value = ptr.String(jtv) 3101 } 3102 3103 default: 3104 _, _ = key, value 3105 3106 } 3107 } 3108 *v = sv 3109 return nil 3110} 3111 3112func awsAwsjson11_deserializeDocumentTagList(v *[]types.Tag, value interface{}) error { 3113 if v == nil { 3114 return fmt.Errorf("unexpected nil of type %T", v) 3115 } 3116 if value == nil { 3117 return nil 3118 } 3119 3120 shape, ok := value.([]interface{}) 3121 if !ok { 3122 return fmt.Errorf("unexpected JSON type %v", value) 3123 } 3124 3125 var cv []types.Tag 3126 if *v == nil { 3127 cv = []types.Tag{} 3128 } else { 3129 cv = *v 3130 } 3131 3132 for _, value := range shape { 3133 var col types.Tag 3134 destAddr := &col 3135 if err := awsAwsjson11_deserializeDocumentTag(&destAddr, value); err != nil { 3136 return err 3137 } 3138 col = *destAddr 3139 cv = append(cv, col) 3140 3141 } 3142 *v = cv 3143 return nil 3144} 3145 3146func awsAwsjson11_deserializeOpDocumentCopyBackupToRegionOutput(v **CopyBackupToRegionOutput, value interface{}) error { 3147 if v == nil { 3148 return fmt.Errorf("unexpected nil of type %T", v) 3149 } 3150 if value == nil { 3151 return nil 3152 } 3153 3154 shape, ok := value.(map[string]interface{}) 3155 if !ok { 3156 return fmt.Errorf("unexpected JSON type %v", value) 3157 } 3158 3159 var sv *CopyBackupToRegionOutput 3160 if *v == nil { 3161 sv = &CopyBackupToRegionOutput{} 3162 } else { 3163 sv = *v 3164 } 3165 3166 for key, value := range shape { 3167 switch key { 3168 case "DestinationBackup": 3169 if err := awsAwsjson11_deserializeDocumentDestinationBackup(&sv.DestinationBackup, value); err != nil { 3170 return err 3171 } 3172 3173 default: 3174 _, _ = key, value 3175 3176 } 3177 } 3178 *v = sv 3179 return nil 3180} 3181 3182func awsAwsjson11_deserializeOpDocumentCreateClusterOutput(v **CreateClusterOutput, value interface{}) error { 3183 if v == nil { 3184 return fmt.Errorf("unexpected nil of type %T", v) 3185 } 3186 if value == nil { 3187 return nil 3188 } 3189 3190 shape, ok := value.(map[string]interface{}) 3191 if !ok { 3192 return fmt.Errorf("unexpected JSON type %v", value) 3193 } 3194 3195 var sv *CreateClusterOutput 3196 if *v == nil { 3197 sv = &CreateClusterOutput{} 3198 } else { 3199 sv = *v 3200 } 3201 3202 for key, value := range shape { 3203 switch key { 3204 case "Cluster": 3205 if err := awsAwsjson11_deserializeDocumentCluster(&sv.Cluster, value); err != nil { 3206 return err 3207 } 3208 3209 default: 3210 _, _ = key, value 3211 3212 } 3213 } 3214 *v = sv 3215 return nil 3216} 3217 3218func awsAwsjson11_deserializeOpDocumentCreateHsmOutput(v **CreateHsmOutput, value interface{}) error { 3219 if v == nil { 3220 return fmt.Errorf("unexpected nil of type %T", v) 3221 } 3222 if value == nil { 3223 return nil 3224 } 3225 3226 shape, ok := value.(map[string]interface{}) 3227 if !ok { 3228 return fmt.Errorf("unexpected JSON type %v", value) 3229 } 3230 3231 var sv *CreateHsmOutput 3232 if *v == nil { 3233 sv = &CreateHsmOutput{} 3234 } else { 3235 sv = *v 3236 } 3237 3238 for key, value := range shape { 3239 switch key { 3240 case "Hsm": 3241 if err := awsAwsjson11_deserializeDocumentHsm(&sv.Hsm, value); err != nil { 3242 return err 3243 } 3244 3245 default: 3246 _, _ = key, value 3247 3248 } 3249 } 3250 *v = sv 3251 return nil 3252} 3253 3254func awsAwsjson11_deserializeOpDocumentDeleteBackupOutput(v **DeleteBackupOutput, value interface{}) error { 3255 if v == nil { 3256 return fmt.Errorf("unexpected nil of type %T", v) 3257 } 3258 if value == nil { 3259 return nil 3260 } 3261 3262 shape, ok := value.(map[string]interface{}) 3263 if !ok { 3264 return fmt.Errorf("unexpected JSON type %v", value) 3265 } 3266 3267 var sv *DeleteBackupOutput 3268 if *v == nil { 3269 sv = &DeleteBackupOutput{} 3270 } else { 3271 sv = *v 3272 } 3273 3274 for key, value := range shape { 3275 switch key { 3276 case "Backup": 3277 if err := awsAwsjson11_deserializeDocumentBackup(&sv.Backup, value); err != nil { 3278 return err 3279 } 3280 3281 default: 3282 _, _ = key, value 3283 3284 } 3285 } 3286 *v = sv 3287 return nil 3288} 3289 3290func awsAwsjson11_deserializeOpDocumentDeleteClusterOutput(v **DeleteClusterOutput, value interface{}) error { 3291 if v == nil { 3292 return fmt.Errorf("unexpected nil of type %T", v) 3293 } 3294 if value == nil { 3295 return nil 3296 } 3297 3298 shape, ok := value.(map[string]interface{}) 3299 if !ok { 3300 return fmt.Errorf("unexpected JSON type %v", value) 3301 } 3302 3303 var sv *DeleteClusterOutput 3304 if *v == nil { 3305 sv = &DeleteClusterOutput{} 3306 } else { 3307 sv = *v 3308 } 3309 3310 for key, value := range shape { 3311 switch key { 3312 case "Cluster": 3313 if err := awsAwsjson11_deserializeDocumentCluster(&sv.Cluster, value); err != nil { 3314 return err 3315 } 3316 3317 default: 3318 _, _ = key, value 3319 3320 } 3321 } 3322 *v = sv 3323 return nil 3324} 3325 3326func awsAwsjson11_deserializeOpDocumentDeleteHsmOutput(v **DeleteHsmOutput, value interface{}) error { 3327 if v == nil { 3328 return fmt.Errorf("unexpected nil of type %T", v) 3329 } 3330 if value == nil { 3331 return nil 3332 } 3333 3334 shape, ok := value.(map[string]interface{}) 3335 if !ok { 3336 return fmt.Errorf("unexpected JSON type %v", value) 3337 } 3338 3339 var sv *DeleteHsmOutput 3340 if *v == nil { 3341 sv = &DeleteHsmOutput{} 3342 } else { 3343 sv = *v 3344 } 3345 3346 for key, value := range shape { 3347 switch key { 3348 case "HsmId": 3349 if value != nil { 3350 jtv, ok := value.(string) 3351 if !ok { 3352 return fmt.Errorf("expected HsmId to be of type string, got %T instead", value) 3353 } 3354 sv.HsmId = ptr.String(jtv) 3355 } 3356 3357 default: 3358 _, _ = key, value 3359 3360 } 3361 } 3362 *v = sv 3363 return nil 3364} 3365 3366func awsAwsjson11_deserializeOpDocumentDescribeBackupsOutput(v **DescribeBackupsOutput, value interface{}) error { 3367 if v == nil { 3368 return fmt.Errorf("unexpected nil of type %T", v) 3369 } 3370 if value == nil { 3371 return nil 3372 } 3373 3374 shape, ok := value.(map[string]interface{}) 3375 if !ok { 3376 return fmt.Errorf("unexpected JSON type %v", value) 3377 } 3378 3379 var sv *DescribeBackupsOutput 3380 if *v == nil { 3381 sv = &DescribeBackupsOutput{} 3382 } else { 3383 sv = *v 3384 } 3385 3386 for key, value := range shape { 3387 switch key { 3388 case "Backups": 3389 if err := awsAwsjson11_deserializeDocumentBackups(&sv.Backups, value); err != nil { 3390 return err 3391 } 3392 3393 case "NextToken": 3394 if value != nil { 3395 jtv, ok := value.(string) 3396 if !ok { 3397 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 3398 } 3399 sv.NextToken = ptr.String(jtv) 3400 } 3401 3402 default: 3403 _, _ = key, value 3404 3405 } 3406 } 3407 *v = sv 3408 return nil 3409} 3410 3411func awsAwsjson11_deserializeOpDocumentDescribeClustersOutput(v **DescribeClustersOutput, value interface{}) error { 3412 if v == nil { 3413 return fmt.Errorf("unexpected nil of type %T", v) 3414 } 3415 if value == nil { 3416 return nil 3417 } 3418 3419 shape, ok := value.(map[string]interface{}) 3420 if !ok { 3421 return fmt.Errorf("unexpected JSON type %v", value) 3422 } 3423 3424 var sv *DescribeClustersOutput 3425 if *v == nil { 3426 sv = &DescribeClustersOutput{} 3427 } else { 3428 sv = *v 3429 } 3430 3431 for key, value := range shape { 3432 switch key { 3433 case "Clusters": 3434 if err := awsAwsjson11_deserializeDocumentClusters(&sv.Clusters, value); err != nil { 3435 return err 3436 } 3437 3438 case "NextToken": 3439 if value != nil { 3440 jtv, ok := value.(string) 3441 if !ok { 3442 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 3443 } 3444 sv.NextToken = ptr.String(jtv) 3445 } 3446 3447 default: 3448 _, _ = key, value 3449 3450 } 3451 } 3452 *v = sv 3453 return nil 3454} 3455 3456func awsAwsjson11_deserializeOpDocumentInitializeClusterOutput(v **InitializeClusterOutput, value interface{}) error { 3457 if v == nil { 3458 return fmt.Errorf("unexpected nil of type %T", v) 3459 } 3460 if value == nil { 3461 return nil 3462 } 3463 3464 shape, ok := value.(map[string]interface{}) 3465 if !ok { 3466 return fmt.Errorf("unexpected JSON type %v", value) 3467 } 3468 3469 var sv *InitializeClusterOutput 3470 if *v == nil { 3471 sv = &InitializeClusterOutput{} 3472 } else { 3473 sv = *v 3474 } 3475 3476 for key, value := range shape { 3477 switch key { 3478 case "State": 3479 if value != nil { 3480 jtv, ok := value.(string) 3481 if !ok { 3482 return fmt.Errorf("expected ClusterState to be of type string, got %T instead", value) 3483 } 3484 sv.State = types.ClusterState(jtv) 3485 } 3486 3487 case "StateMessage": 3488 if value != nil { 3489 jtv, ok := value.(string) 3490 if !ok { 3491 return fmt.Errorf("expected StateMessage to be of type string, got %T instead", value) 3492 } 3493 sv.StateMessage = ptr.String(jtv) 3494 } 3495 3496 default: 3497 _, _ = key, value 3498 3499 } 3500 } 3501 *v = sv 3502 return nil 3503} 3504 3505func awsAwsjson11_deserializeOpDocumentListTagsOutput(v **ListTagsOutput, value interface{}) error { 3506 if v == nil { 3507 return fmt.Errorf("unexpected nil of type %T", v) 3508 } 3509 if value == nil { 3510 return nil 3511 } 3512 3513 shape, ok := value.(map[string]interface{}) 3514 if !ok { 3515 return fmt.Errorf("unexpected JSON type %v", value) 3516 } 3517 3518 var sv *ListTagsOutput 3519 if *v == nil { 3520 sv = &ListTagsOutput{} 3521 } else { 3522 sv = *v 3523 } 3524 3525 for key, value := range shape { 3526 switch key { 3527 case "NextToken": 3528 if value != nil { 3529 jtv, ok := value.(string) 3530 if !ok { 3531 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 3532 } 3533 sv.NextToken = ptr.String(jtv) 3534 } 3535 3536 case "TagList": 3537 if err := awsAwsjson11_deserializeDocumentTagList(&sv.TagList, value); err != nil { 3538 return err 3539 } 3540 3541 default: 3542 _, _ = key, value 3543 3544 } 3545 } 3546 *v = sv 3547 return nil 3548} 3549 3550func awsAwsjson11_deserializeOpDocumentModifyBackupAttributesOutput(v **ModifyBackupAttributesOutput, value interface{}) error { 3551 if v == nil { 3552 return fmt.Errorf("unexpected nil of type %T", v) 3553 } 3554 if value == nil { 3555 return nil 3556 } 3557 3558 shape, ok := value.(map[string]interface{}) 3559 if !ok { 3560 return fmt.Errorf("unexpected JSON type %v", value) 3561 } 3562 3563 var sv *ModifyBackupAttributesOutput 3564 if *v == nil { 3565 sv = &ModifyBackupAttributesOutput{} 3566 } else { 3567 sv = *v 3568 } 3569 3570 for key, value := range shape { 3571 switch key { 3572 case "Backup": 3573 if err := awsAwsjson11_deserializeDocumentBackup(&sv.Backup, value); err != nil { 3574 return err 3575 } 3576 3577 default: 3578 _, _ = key, value 3579 3580 } 3581 } 3582 *v = sv 3583 return nil 3584} 3585 3586func awsAwsjson11_deserializeOpDocumentModifyClusterOutput(v **ModifyClusterOutput, value interface{}) error { 3587 if v == nil { 3588 return fmt.Errorf("unexpected nil of type %T", v) 3589 } 3590 if value == nil { 3591 return nil 3592 } 3593 3594 shape, ok := value.(map[string]interface{}) 3595 if !ok { 3596 return fmt.Errorf("unexpected JSON type %v", value) 3597 } 3598 3599 var sv *ModifyClusterOutput 3600 if *v == nil { 3601 sv = &ModifyClusterOutput{} 3602 } else { 3603 sv = *v 3604 } 3605 3606 for key, value := range shape { 3607 switch key { 3608 case "Cluster": 3609 if err := awsAwsjson11_deserializeDocumentCluster(&sv.Cluster, value); err != nil { 3610 return err 3611 } 3612 3613 default: 3614 _, _ = key, value 3615 3616 } 3617 } 3618 *v = sv 3619 return nil 3620} 3621 3622func awsAwsjson11_deserializeOpDocumentRestoreBackupOutput(v **RestoreBackupOutput, value interface{}) error { 3623 if v == nil { 3624 return fmt.Errorf("unexpected nil of type %T", v) 3625 } 3626 if value == nil { 3627 return nil 3628 } 3629 3630 shape, ok := value.(map[string]interface{}) 3631 if !ok { 3632 return fmt.Errorf("unexpected JSON type %v", value) 3633 } 3634 3635 var sv *RestoreBackupOutput 3636 if *v == nil { 3637 sv = &RestoreBackupOutput{} 3638 } else { 3639 sv = *v 3640 } 3641 3642 for key, value := range shape { 3643 switch key { 3644 case "Backup": 3645 if err := awsAwsjson11_deserializeDocumentBackup(&sv.Backup, value); err != nil { 3646 return err 3647 } 3648 3649 default: 3650 _, _ = key, value 3651 3652 } 3653 } 3654 *v = sv 3655 return nil 3656} 3657 3658func awsAwsjson11_deserializeOpDocumentTagResourceOutput(v **TagResourceOutput, value interface{}) error { 3659 if v == nil { 3660 return fmt.Errorf("unexpected nil of type %T", v) 3661 } 3662 if value == nil { 3663 return nil 3664 } 3665 3666 shape, ok := value.(map[string]interface{}) 3667 if !ok { 3668 return fmt.Errorf("unexpected JSON type %v", value) 3669 } 3670 3671 var sv *TagResourceOutput 3672 if *v == nil { 3673 sv = &TagResourceOutput{} 3674 } else { 3675 sv = *v 3676 } 3677 3678 for key, value := range shape { 3679 switch key { 3680 default: 3681 _, _ = key, value 3682 3683 } 3684 } 3685 *v = sv 3686 return nil 3687} 3688 3689func awsAwsjson11_deserializeOpDocumentUntagResourceOutput(v **UntagResourceOutput, value interface{}) error { 3690 if v == nil { 3691 return fmt.Errorf("unexpected nil of type %T", v) 3692 } 3693 if value == nil { 3694 return nil 3695 } 3696 3697 shape, ok := value.(map[string]interface{}) 3698 if !ok { 3699 return fmt.Errorf("unexpected JSON type %v", value) 3700 } 3701 3702 var sv *UntagResourceOutput 3703 if *v == nil { 3704 sv = &UntagResourceOutput{} 3705 } else { 3706 sv = *v 3707 } 3708 3709 for key, value := range shape { 3710 switch key { 3711 default: 3712 _, _ = key, value 3713 3714 } 3715 } 3716 *v = sv 3717 return nil 3718} 3719