1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package clouddirectory 4 5import ( 6 "bytes" 7 "context" 8 "encoding/base64" 9 "encoding/json" 10 "fmt" 11 "github.com/aws/aws-sdk-go-v2/aws/protocol/restjson" 12 "github.com/aws/aws-sdk-go-v2/service/clouddirectory/types" 13 smithy "github.com/aws/smithy-go" 14 smithyio "github.com/aws/smithy-go/io" 15 "github.com/aws/smithy-go/middleware" 16 "github.com/aws/smithy-go/ptr" 17 smithytime "github.com/aws/smithy-go/time" 18 smithyhttp "github.com/aws/smithy-go/transport/http" 19 "io" 20 "io/ioutil" 21 "strings" 22 "time" 23) 24 25type awsRestjson1_deserializeOpAddFacetToObject struct { 26} 27 28func (*awsRestjson1_deserializeOpAddFacetToObject) ID() string { 29 return "OperationDeserializer" 30} 31 32func (m *awsRestjson1_deserializeOpAddFacetToObject) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 33 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 34) { 35 out, metadata, err = next.HandleDeserialize(ctx, in) 36 if err != nil { 37 return out, metadata, err 38 } 39 40 response, ok := out.RawResponse.(*smithyhttp.Response) 41 if !ok { 42 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 43 } 44 45 if response.StatusCode < 200 || response.StatusCode >= 300 { 46 return out, metadata, awsRestjson1_deserializeOpErrorAddFacetToObject(response, &metadata) 47 } 48 output := &AddFacetToObjectOutput{} 49 out.Result = output 50 51 return out, metadata, err 52} 53 54func awsRestjson1_deserializeOpErrorAddFacetToObject(response *smithyhttp.Response, metadata *middleware.Metadata) error { 55 var errorBuffer bytes.Buffer 56 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 57 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 58 } 59 errorBody := bytes.NewReader(errorBuffer.Bytes()) 60 61 errorCode := "UnknownError" 62 errorMessage := errorCode 63 64 code := response.Header.Get("X-Amzn-ErrorType") 65 if len(code) != 0 { 66 errorCode = restjson.SanitizeErrorCode(code) 67 } 68 69 var buff [1024]byte 70 ringBuffer := smithyio.NewRingBuffer(buff[:]) 71 72 body := io.TeeReader(errorBody, ringBuffer) 73 decoder := json.NewDecoder(body) 74 decoder.UseNumber() 75 code, message, err := restjson.GetErrorInfo(decoder) 76 if err != nil { 77 var snapshot bytes.Buffer 78 io.Copy(&snapshot, ringBuffer) 79 err = &smithy.DeserializationError{ 80 Err: fmt.Errorf("failed to decode response body, %w", err), 81 Snapshot: snapshot.Bytes(), 82 } 83 return err 84 } 85 86 errorBody.Seek(0, io.SeekStart) 87 if len(code) != 0 { 88 errorCode = restjson.SanitizeErrorCode(code) 89 } 90 if len(message) != 0 { 91 errorMessage = message 92 } 93 94 switch { 95 case strings.EqualFold("AccessDeniedException", errorCode): 96 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 97 98 case strings.EqualFold("DirectoryNotEnabledException", errorCode): 99 return awsRestjson1_deserializeErrorDirectoryNotEnabledException(response, errorBody) 100 101 case strings.EqualFold("FacetValidationException", errorCode): 102 return awsRestjson1_deserializeErrorFacetValidationException(response, errorBody) 103 104 case strings.EqualFold("InternalServiceException", errorCode): 105 return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody) 106 107 case strings.EqualFold("InvalidArnException", errorCode): 108 return awsRestjson1_deserializeErrorInvalidArnException(response, errorBody) 109 110 case strings.EqualFold("LimitExceededException", errorCode): 111 return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody) 112 113 case strings.EqualFold("ResourceNotFoundException", errorCode): 114 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 115 116 case strings.EqualFold("RetryableConflictException", errorCode): 117 return awsRestjson1_deserializeErrorRetryableConflictException(response, errorBody) 118 119 case strings.EqualFold("ValidationException", errorCode): 120 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 121 122 default: 123 genericError := &smithy.GenericAPIError{ 124 Code: errorCode, 125 Message: errorMessage, 126 } 127 return genericError 128 129 } 130} 131 132type awsRestjson1_deserializeOpApplySchema struct { 133} 134 135func (*awsRestjson1_deserializeOpApplySchema) ID() string { 136 return "OperationDeserializer" 137} 138 139func (m *awsRestjson1_deserializeOpApplySchema) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 140 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 141) { 142 out, metadata, err = next.HandleDeserialize(ctx, in) 143 if err != nil { 144 return out, metadata, err 145 } 146 147 response, ok := out.RawResponse.(*smithyhttp.Response) 148 if !ok { 149 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 150 } 151 152 if response.StatusCode < 200 || response.StatusCode >= 300 { 153 return out, metadata, awsRestjson1_deserializeOpErrorApplySchema(response, &metadata) 154 } 155 output := &ApplySchemaOutput{} 156 out.Result = output 157 158 var buff [1024]byte 159 ringBuffer := smithyio.NewRingBuffer(buff[:]) 160 161 body := io.TeeReader(response.Body, ringBuffer) 162 163 decoder := json.NewDecoder(body) 164 decoder.UseNumber() 165 var shape interface{} 166 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 167 var snapshot bytes.Buffer 168 io.Copy(&snapshot, ringBuffer) 169 err = &smithy.DeserializationError{ 170 Err: fmt.Errorf("failed to decode response body, %w", err), 171 Snapshot: snapshot.Bytes(), 172 } 173 return out, metadata, err 174 } 175 176 err = awsRestjson1_deserializeOpDocumentApplySchemaOutput(&output, shape) 177 if err != nil { 178 var snapshot bytes.Buffer 179 io.Copy(&snapshot, ringBuffer) 180 return out, metadata, &smithy.DeserializationError{ 181 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 182 Snapshot: snapshot.Bytes(), 183 } 184 } 185 186 return out, metadata, err 187} 188 189func awsRestjson1_deserializeOpErrorApplySchema(response *smithyhttp.Response, metadata *middleware.Metadata) error { 190 var errorBuffer bytes.Buffer 191 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 192 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 193 } 194 errorBody := bytes.NewReader(errorBuffer.Bytes()) 195 196 errorCode := "UnknownError" 197 errorMessage := errorCode 198 199 code := response.Header.Get("X-Amzn-ErrorType") 200 if len(code) != 0 { 201 errorCode = restjson.SanitizeErrorCode(code) 202 } 203 204 var buff [1024]byte 205 ringBuffer := smithyio.NewRingBuffer(buff[:]) 206 207 body := io.TeeReader(errorBody, ringBuffer) 208 decoder := json.NewDecoder(body) 209 decoder.UseNumber() 210 code, message, err := restjson.GetErrorInfo(decoder) 211 if err != nil { 212 var snapshot bytes.Buffer 213 io.Copy(&snapshot, ringBuffer) 214 err = &smithy.DeserializationError{ 215 Err: fmt.Errorf("failed to decode response body, %w", err), 216 Snapshot: snapshot.Bytes(), 217 } 218 return err 219 } 220 221 errorBody.Seek(0, io.SeekStart) 222 if len(code) != 0 { 223 errorCode = restjson.SanitizeErrorCode(code) 224 } 225 if len(message) != 0 { 226 errorMessage = message 227 } 228 229 switch { 230 case strings.EqualFold("AccessDeniedException", errorCode): 231 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 232 233 case strings.EqualFold("InternalServiceException", errorCode): 234 return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody) 235 236 case strings.EqualFold("InvalidArnException", errorCode): 237 return awsRestjson1_deserializeErrorInvalidArnException(response, errorBody) 238 239 case strings.EqualFold("InvalidAttachmentException", errorCode): 240 return awsRestjson1_deserializeErrorInvalidAttachmentException(response, errorBody) 241 242 case strings.EqualFold("LimitExceededException", errorCode): 243 return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody) 244 245 case strings.EqualFold("ResourceNotFoundException", errorCode): 246 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 247 248 case strings.EqualFold("RetryableConflictException", errorCode): 249 return awsRestjson1_deserializeErrorRetryableConflictException(response, errorBody) 250 251 case strings.EqualFold("SchemaAlreadyExistsException", errorCode): 252 return awsRestjson1_deserializeErrorSchemaAlreadyExistsException(response, errorBody) 253 254 case strings.EqualFold("ValidationException", errorCode): 255 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 256 257 default: 258 genericError := &smithy.GenericAPIError{ 259 Code: errorCode, 260 Message: errorMessage, 261 } 262 return genericError 263 264 } 265} 266 267func awsRestjson1_deserializeOpDocumentApplySchemaOutput(v **ApplySchemaOutput, value interface{}) error { 268 if v == nil { 269 return fmt.Errorf("unexpected nil of type %T", v) 270 } 271 if value == nil { 272 return nil 273 } 274 275 shape, ok := value.(map[string]interface{}) 276 if !ok { 277 return fmt.Errorf("unexpected JSON type %v", value) 278 } 279 280 var sv *ApplySchemaOutput 281 if *v == nil { 282 sv = &ApplySchemaOutput{} 283 } else { 284 sv = *v 285 } 286 287 for key, value := range shape { 288 switch key { 289 case "AppliedSchemaArn": 290 if value != nil { 291 jtv, ok := value.(string) 292 if !ok { 293 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 294 } 295 sv.AppliedSchemaArn = ptr.String(jtv) 296 } 297 298 case "DirectoryArn": 299 if value != nil { 300 jtv, ok := value.(string) 301 if !ok { 302 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 303 } 304 sv.DirectoryArn = ptr.String(jtv) 305 } 306 307 default: 308 _, _ = key, value 309 310 } 311 } 312 *v = sv 313 return nil 314} 315 316type awsRestjson1_deserializeOpAttachObject struct { 317} 318 319func (*awsRestjson1_deserializeOpAttachObject) ID() string { 320 return "OperationDeserializer" 321} 322 323func (m *awsRestjson1_deserializeOpAttachObject) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 324 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 325) { 326 out, metadata, err = next.HandleDeserialize(ctx, in) 327 if err != nil { 328 return out, metadata, err 329 } 330 331 response, ok := out.RawResponse.(*smithyhttp.Response) 332 if !ok { 333 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 334 } 335 336 if response.StatusCode < 200 || response.StatusCode >= 300 { 337 return out, metadata, awsRestjson1_deserializeOpErrorAttachObject(response, &metadata) 338 } 339 output := &AttachObjectOutput{} 340 out.Result = output 341 342 var buff [1024]byte 343 ringBuffer := smithyio.NewRingBuffer(buff[:]) 344 345 body := io.TeeReader(response.Body, ringBuffer) 346 347 decoder := json.NewDecoder(body) 348 decoder.UseNumber() 349 var shape interface{} 350 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 351 var snapshot bytes.Buffer 352 io.Copy(&snapshot, ringBuffer) 353 err = &smithy.DeserializationError{ 354 Err: fmt.Errorf("failed to decode response body, %w", err), 355 Snapshot: snapshot.Bytes(), 356 } 357 return out, metadata, err 358 } 359 360 err = awsRestjson1_deserializeOpDocumentAttachObjectOutput(&output, shape) 361 if err != nil { 362 var snapshot bytes.Buffer 363 io.Copy(&snapshot, ringBuffer) 364 return out, metadata, &smithy.DeserializationError{ 365 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 366 Snapshot: snapshot.Bytes(), 367 } 368 } 369 370 return out, metadata, err 371} 372 373func awsRestjson1_deserializeOpErrorAttachObject(response *smithyhttp.Response, metadata *middleware.Metadata) error { 374 var errorBuffer bytes.Buffer 375 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 376 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 377 } 378 errorBody := bytes.NewReader(errorBuffer.Bytes()) 379 380 errorCode := "UnknownError" 381 errorMessage := errorCode 382 383 code := response.Header.Get("X-Amzn-ErrorType") 384 if len(code) != 0 { 385 errorCode = restjson.SanitizeErrorCode(code) 386 } 387 388 var buff [1024]byte 389 ringBuffer := smithyio.NewRingBuffer(buff[:]) 390 391 body := io.TeeReader(errorBody, ringBuffer) 392 decoder := json.NewDecoder(body) 393 decoder.UseNumber() 394 code, message, err := restjson.GetErrorInfo(decoder) 395 if err != nil { 396 var snapshot bytes.Buffer 397 io.Copy(&snapshot, ringBuffer) 398 err = &smithy.DeserializationError{ 399 Err: fmt.Errorf("failed to decode response body, %w", err), 400 Snapshot: snapshot.Bytes(), 401 } 402 return err 403 } 404 405 errorBody.Seek(0, io.SeekStart) 406 if len(code) != 0 { 407 errorCode = restjson.SanitizeErrorCode(code) 408 } 409 if len(message) != 0 { 410 errorMessage = message 411 } 412 413 switch { 414 case strings.EqualFold("AccessDeniedException", errorCode): 415 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 416 417 case strings.EqualFold("DirectoryNotEnabledException", errorCode): 418 return awsRestjson1_deserializeErrorDirectoryNotEnabledException(response, errorBody) 419 420 case strings.EqualFold("FacetValidationException", errorCode): 421 return awsRestjson1_deserializeErrorFacetValidationException(response, errorBody) 422 423 case strings.EqualFold("InternalServiceException", errorCode): 424 return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody) 425 426 case strings.EqualFold("InvalidArnException", errorCode): 427 return awsRestjson1_deserializeErrorInvalidArnException(response, errorBody) 428 429 case strings.EqualFold("InvalidAttachmentException", errorCode): 430 return awsRestjson1_deserializeErrorInvalidAttachmentException(response, errorBody) 431 432 case strings.EqualFold("LimitExceededException", errorCode): 433 return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody) 434 435 case strings.EqualFold("LinkNameAlreadyInUseException", errorCode): 436 return awsRestjson1_deserializeErrorLinkNameAlreadyInUseException(response, errorBody) 437 438 case strings.EqualFold("ResourceNotFoundException", errorCode): 439 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 440 441 case strings.EqualFold("RetryableConflictException", errorCode): 442 return awsRestjson1_deserializeErrorRetryableConflictException(response, errorBody) 443 444 case strings.EqualFold("ValidationException", errorCode): 445 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 446 447 default: 448 genericError := &smithy.GenericAPIError{ 449 Code: errorCode, 450 Message: errorMessage, 451 } 452 return genericError 453 454 } 455} 456 457func awsRestjson1_deserializeOpDocumentAttachObjectOutput(v **AttachObjectOutput, value interface{}) error { 458 if v == nil { 459 return fmt.Errorf("unexpected nil of type %T", v) 460 } 461 if value == nil { 462 return nil 463 } 464 465 shape, ok := value.(map[string]interface{}) 466 if !ok { 467 return fmt.Errorf("unexpected JSON type %v", value) 468 } 469 470 var sv *AttachObjectOutput 471 if *v == nil { 472 sv = &AttachObjectOutput{} 473 } else { 474 sv = *v 475 } 476 477 for key, value := range shape { 478 switch key { 479 case "AttachedObjectIdentifier": 480 if value != nil { 481 jtv, ok := value.(string) 482 if !ok { 483 return fmt.Errorf("expected ObjectIdentifier to be of type string, got %T instead", value) 484 } 485 sv.AttachedObjectIdentifier = ptr.String(jtv) 486 } 487 488 default: 489 _, _ = key, value 490 491 } 492 } 493 *v = sv 494 return nil 495} 496 497type awsRestjson1_deserializeOpAttachPolicy struct { 498} 499 500func (*awsRestjson1_deserializeOpAttachPolicy) ID() string { 501 return "OperationDeserializer" 502} 503 504func (m *awsRestjson1_deserializeOpAttachPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 505 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 506) { 507 out, metadata, err = next.HandleDeserialize(ctx, in) 508 if err != nil { 509 return out, metadata, err 510 } 511 512 response, ok := out.RawResponse.(*smithyhttp.Response) 513 if !ok { 514 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 515 } 516 517 if response.StatusCode < 200 || response.StatusCode >= 300 { 518 return out, metadata, awsRestjson1_deserializeOpErrorAttachPolicy(response, &metadata) 519 } 520 output := &AttachPolicyOutput{} 521 out.Result = output 522 523 return out, metadata, err 524} 525 526func awsRestjson1_deserializeOpErrorAttachPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { 527 var errorBuffer bytes.Buffer 528 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 529 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 530 } 531 errorBody := bytes.NewReader(errorBuffer.Bytes()) 532 533 errorCode := "UnknownError" 534 errorMessage := errorCode 535 536 code := response.Header.Get("X-Amzn-ErrorType") 537 if len(code) != 0 { 538 errorCode = restjson.SanitizeErrorCode(code) 539 } 540 541 var buff [1024]byte 542 ringBuffer := smithyio.NewRingBuffer(buff[:]) 543 544 body := io.TeeReader(errorBody, ringBuffer) 545 decoder := json.NewDecoder(body) 546 decoder.UseNumber() 547 code, message, err := restjson.GetErrorInfo(decoder) 548 if err != nil { 549 var snapshot bytes.Buffer 550 io.Copy(&snapshot, ringBuffer) 551 err = &smithy.DeserializationError{ 552 Err: fmt.Errorf("failed to decode response body, %w", err), 553 Snapshot: snapshot.Bytes(), 554 } 555 return err 556 } 557 558 errorBody.Seek(0, io.SeekStart) 559 if len(code) != 0 { 560 errorCode = restjson.SanitizeErrorCode(code) 561 } 562 if len(message) != 0 { 563 errorMessage = message 564 } 565 566 switch { 567 case strings.EqualFold("AccessDeniedException", errorCode): 568 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 569 570 case strings.EqualFold("DirectoryNotEnabledException", errorCode): 571 return awsRestjson1_deserializeErrorDirectoryNotEnabledException(response, errorBody) 572 573 case strings.EqualFold("InternalServiceException", errorCode): 574 return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody) 575 576 case strings.EqualFold("InvalidArnException", errorCode): 577 return awsRestjson1_deserializeErrorInvalidArnException(response, errorBody) 578 579 case strings.EqualFold("LimitExceededException", errorCode): 580 return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody) 581 582 case strings.EqualFold("NotPolicyException", errorCode): 583 return awsRestjson1_deserializeErrorNotPolicyException(response, errorBody) 584 585 case strings.EqualFold("ResourceNotFoundException", errorCode): 586 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 587 588 case strings.EqualFold("RetryableConflictException", errorCode): 589 return awsRestjson1_deserializeErrorRetryableConflictException(response, errorBody) 590 591 case strings.EqualFold("ValidationException", errorCode): 592 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 593 594 default: 595 genericError := &smithy.GenericAPIError{ 596 Code: errorCode, 597 Message: errorMessage, 598 } 599 return genericError 600 601 } 602} 603 604type awsRestjson1_deserializeOpAttachToIndex struct { 605} 606 607func (*awsRestjson1_deserializeOpAttachToIndex) ID() string { 608 return "OperationDeserializer" 609} 610 611func (m *awsRestjson1_deserializeOpAttachToIndex) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 612 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 613) { 614 out, metadata, err = next.HandleDeserialize(ctx, in) 615 if err != nil { 616 return out, metadata, err 617 } 618 619 response, ok := out.RawResponse.(*smithyhttp.Response) 620 if !ok { 621 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 622 } 623 624 if response.StatusCode < 200 || response.StatusCode >= 300 { 625 return out, metadata, awsRestjson1_deserializeOpErrorAttachToIndex(response, &metadata) 626 } 627 output := &AttachToIndexOutput{} 628 out.Result = output 629 630 var buff [1024]byte 631 ringBuffer := smithyio.NewRingBuffer(buff[:]) 632 633 body := io.TeeReader(response.Body, ringBuffer) 634 635 decoder := json.NewDecoder(body) 636 decoder.UseNumber() 637 var shape interface{} 638 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 639 var snapshot bytes.Buffer 640 io.Copy(&snapshot, ringBuffer) 641 err = &smithy.DeserializationError{ 642 Err: fmt.Errorf("failed to decode response body, %w", err), 643 Snapshot: snapshot.Bytes(), 644 } 645 return out, metadata, err 646 } 647 648 err = awsRestjson1_deserializeOpDocumentAttachToIndexOutput(&output, shape) 649 if err != nil { 650 var snapshot bytes.Buffer 651 io.Copy(&snapshot, ringBuffer) 652 return out, metadata, &smithy.DeserializationError{ 653 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 654 Snapshot: snapshot.Bytes(), 655 } 656 } 657 658 return out, metadata, err 659} 660 661func awsRestjson1_deserializeOpErrorAttachToIndex(response *smithyhttp.Response, metadata *middleware.Metadata) error { 662 var errorBuffer bytes.Buffer 663 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 664 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 665 } 666 errorBody := bytes.NewReader(errorBuffer.Bytes()) 667 668 errorCode := "UnknownError" 669 errorMessage := errorCode 670 671 code := response.Header.Get("X-Amzn-ErrorType") 672 if len(code) != 0 { 673 errorCode = restjson.SanitizeErrorCode(code) 674 } 675 676 var buff [1024]byte 677 ringBuffer := smithyio.NewRingBuffer(buff[:]) 678 679 body := io.TeeReader(errorBody, ringBuffer) 680 decoder := json.NewDecoder(body) 681 decoder.UseNumber() 682 code, message, err := restjson.GetErrorInfo(decoder) 683 if err != nil { 684 var snapshot bytes.Buffer 685 io.Copy(&snapshot, ringBuffer) 686 err = &smithy.DeserializationError{ 687 Err: fmt.Errorf("failed to decode response body, %w", err), 688 Snapshot: snapshot.Bytes(), 689 } 690 return err 691 } 692 693 errorBody.Seek(0, io.SeekStart) 694 if len(code) != 0 { 695 errorCode = restjson.SanitizeErrorCode(code) 696 } 697 if len(message) != 0 { 698 errorMessage = message 699 } 700 701 switch { 702 case strings.EqualFold("AccessDeniedException", errorCode): 703 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 704 705 case strings.EqualFold("DirectoryNotEnabledException", errorCode): 706 return awsRestjson1_deserializeErrorDirectoryNotEnabledException(response, errorBody) 707 708 case strings.EqualFold("IndexedAttributeMissingException", errorCode): 709 return awsRestjson1_deserializeErrorIndexedAttributeMissingException(response, errorBody) 710 711 case strings.EqualFold("InternalServiceException", errorCode): 712 return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody) 713 714 case strings.EqualFold("InvalidArnException", errorCode): 715 return awsRestjson1_deserializeErrorInvalidArnException(response, errorBody) 716 717 case strings.EqualFold("InvalidAttachmentException", errorCode): 718 return awsRestjson1_deserializeErrorInvalidAttachmentException(response, errorBody) 719 720 case strings.EqualFold("LimitExceededException", errorCode): 721 return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody) 722 723 case strings.EqualFold("LinkNameAlreadyInUseException", errorCode): 724 return awsRestjson1_deserializeErrorLinkNameAlreadyInUseException(response, errorBody) 725 726 case strings.EqualFold("NotIndexException", errorCode): 727 return awsRestjson1_deserializeErrorNotIndexException(response, errorBody) 728 729 case strings.EqualFold("ResourceNotFoundException", errorCode): 730 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 731 732 case strings.EqualFold("RetryableConflictException", errorCode): 733 return awsRestjson1_deserializeErrorRetryableConflictException(response, errorBody) 734 735 case strings.EqualFold("ValidationException", errorCode): 736 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 737 738 default: 739 genericError := &smithy.GenericAPIError{ 740 Code: errorCode, 741 Message: errorMessage, 742 } 743 return genericError 744 745 } 746} 747 748func awsRestjson1_deserializeOpDocumentAttachToIndexOutput(v **AttachToIndexOutput, value interface{}) error { 749 if v == nil { 750 return fmt.Errorf("unexpected nil of type %T", v) 751 } 752 if value == nil { 753 return nil 754 } 755 756 shape, ok := value.(map[string]interface{}) 757 if !ok { 758 return fmt.Errorf("unexpected JSON type %v", value) 759 } 760 761 var sv *AttachToIndexOutput 762 if *v == nil { 763 sv = &AttachToIndexOutput{} 764 } else { 765 sv = *v 766 } 767 768 for key, value := range shape { 769 switch key { 770 case "AttachedObjectIdentifier": 771 if value != nil { 772 jtv, ok := value.(string) 773 if !ok { 774 return fmt.Errorf("expected ObjectIdentifier to be of type string, got %T instead", value) 775 } 776 sv.AttachedObjectIdentifier = ptr.String(jtv) 777 } 778 779 default: 780 _, _ = key, value 781 782 } 783 } 784 *v = sv 785 return nil 786} 787 788type awsRestjson1_deserializeOpAttachTypedLink struct { 789} 790 791func (*awsRestjson1_deserializeOpAttachTypedLink) ID() string { 792 return "OperationDeserializer" 793} 794 795func (m *awsRestjson1_deserializeOpAttachTypedLink) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 796 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 797) { 798 out, metadata, err = next.HandleDeserialize(ctx, in) 799 if err != nil { 800 return out, metadata, err 801 } 802 803 response, ok := out.RawResponse.(*smithyhttp.Response) 804 if !ok { 805 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 806 } 807 808 if response.StatusCode < 200 || response.StatusCode >= 300 { 809 return out, metadata, awsRestjson1_deserializeOpErrorAttachTypedLink(response, &metadata) 810 } 811 output := &AttachTypedLinkOutput{} 812 out.Result = output 813 814 var buff [1024]byte 815 ringBuffer := smithyio.NewRingBuffer(buff[:]) 816 817 body := io.TeeReader(response.Body, ringBuffer) 818 819 decoder := json.NewDecoder(body) 820 decoder.UseNumber() 821 var shape interface{} 822 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 823 var snapshot bytes.Buffer 824 io.Copy(&snapshot, ringBuffer) 825 err = &smithy.DeserializationError{ 826 Err: fmt.Errorf("failed to decode response body, %w", err), 827 Snapshot: snapshot.Bytes(), 828 } 829 return out, metadata, err 830 } 831 832 err = awsRestjson1_deserializeOpDocumentAttachTypedLinkOutput(&output, shape) 833 if err != nil { 834 var snapshot bytes.Buffer 835 io.Copy(&snapshot, ringBuffer) 836 return out, metadata, &smithy.DeserializationError{ 837 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 838 Snapshot: snapshot.Bytes(), 839 } 840 } 841 842 return out, metadata, err 843} 844 845func awsRestjson1_deserializeOpErrorAttachTypedLink(response *smithyhttp.Response, metadata *middleware.Metadata) error { 846 var errorBuffer bytes.Buffer 847 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 848 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 849 } 850 errorBody := bytes.NewReader(errorBuffer.Bytes()) 851 852 errorCode := "UnknownError" 853 errorMessage := errorCode 854 855 code := response.Header.Get("X-Amzn-ErrorType") 856 if len(code) != 0 { 857 errorCode = restjson.SanitizeErrorCode(code) 858 } 859 860 var buff [1024]byte 861 ringBuffer := smithyio.NewRingBuffer(buff[:]) 862 863 body := io.TeeReader(errorBody, ringBuffer) 864 decoder := json.NewDecoder(body) 865 decoder.UseNumber() 866 code, message, err := restjson.GetErrorInfo(decoder) 867 if err != nil { 868 var snapshot bytes.Buffer 869 io.Copy(&snapshot, ringBuffer) 870 err = &smithy.DeserializationError{ 871 Err: fmt.Errorf("failed to decode response body, %w", err), 872 Snapshot: snapshot.Bytes(), 873 } 874 return err 875 } 876 877 errorBody.Seek(0, io.SeekStart) 878 if len(code) != 0 { 879 errorCode = restjson.SanitizeErrorCode(code) 880 } 881 if len(message) != 0 { 882 errorMessage = message 883 } 884 885 switch { 886 case strings.EqualFold("AccessDeniedException", errorCode): 887 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 888 889 case strings.EqualFold("DirectoryNotEnabledException", errorCode): 890 return awsRestjson1_deserializeErrorDirectoryNotEnabledException(response, errorBody) 891 892 case strings.EqualFold("FacetValidationException", errorCode): 893 return awsRestjson1_deserializeErrorFacetValidationException(response, errorBody) 894 895 case strings.EqualFold("InternalServiceException", errorCode): 896 return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody) 897 898 case strings.EqualFold("InvalidArnException", errorCode): 899 return awsRestjson1_deserializeErrorInvalidArnException(response, errorBody) 900 901 case strings.EqualFold("InvalidAttachmentException", errorCode): 902 return awsRestjson1_deserializeErrorInvalidAttachmentException(response, errorBody) 903 904 case strings.EqualFold("LimitExceededException", errorCode): 905 return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody) 906 907 case strings.EqualFold("ResourceNotFoundException", errorCode): 908 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 909 910 case strings.EqualFold("RetryableConflictException", errorCode): 911 return awsRestjson1_deserializeErrorRetryableConflictException(response, errorBody) 912 913 case strings.EqualFold("ValidationException", errorCode): 914 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 915 916 default: 917 genericError := &smithy.GenericAPIError{ 918 Code: errorCode, 919 Message: errorMessage, 920 } 921 return genericError 922 923 } 924} 925 926func awsRestjson1_deserializeOpDocumentAttachTypedLinkOutput(v **AttachTypedLinkOutput, value interface{}) error { 927 if v == nil { 928 return fmt.Errorf("unexpected nil of type %T", v) 929 } 930 if value == nil { 931 return nil 932 } 933 934 shape, ok := value.(map[string]interface{}) 935 if !ok { 936 return fmt.Errorf("unexpected JSON type %v", value) 937 } 938 939 var sv *AttachTypedLinkOutput 940 if *v == nil { 941 sv = &AttachTypedLinkOutput{} 942 } else { 943 sv = *v 944 } 945 946 for key, value := range shape { 947 switch key { 948 case "TypedLinkSpecifier": 949 if err := awsRestjson1_deserializeDocumentTypedLinkSpecifier(&sv.TypedLinkSpecifier, value); err != nil { 950 return err 951 } 952 953 default: 954 _, _ = key, value 955 956 } 957 } 958 *v = sv 959 return nil 960} 961 962type awsRestjson1_deserializeOpBatchRead struct { 963} 964 965func (*awsRestjson1_deserializeOpBatchRead) ID() string { 966 return "OperationDeserializer" 967} 968 969func (m *awsRestjson1_deserializeOpBatchRead) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 970 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 971) { 972 out, metadata, err = next.HandleDeserialize(ctx, in) 973 if err != nil { 974 return out, metadata, err 975 } 976 977 response, ok := out.RawResponse.(*smithyhttp.Response) 978 if !ok { 979 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 980 } 981 982 if response.StatusCode < 200 || response.StatusCode >= 300 { 983 return out, metadata, awsRestjson1_deserializeOpErrorBatchRead(response, &metadata) 984 } 985 output := &BatchReadOutput{} 986 out.Result = output 987 988 var buff [1024]byte 989 ringBuffer := smithyio.NewRingBuffer(buff[:]) 990 991 body := io.TeeReader(response.Body, ringBuffer) 992 993 decoder := json.NewDecoder(body) 994 decoder.UseNumber() 995 var shape interface{} 996 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 997 var snapshot bytes.Buffer 998 io.Copy(&snapshot, ringBuffer) 999 err = &smithy.DeserializationError{ 1000 Err: fmt.Errorf("failed to decode response body, %w", err), 1001 Snapshot: snapshot.Bytes(), 1002 } 1003 return out, metadata, err 1004 } 1005 1006 err = awsRestjson1_deserializeOpDocumentBatchReadOutput(&output, shape) 1007 if err != nil { 1008 var snapshot bytes.Buffer 1009 io.Copy(&snapshot, ringBuffer) 1010 return out, metadata, &smithy.DeserializationError{ 1011 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 1012 Snapshot: snapshot.Bytes(), 1013 } 1014 } 1015 1016 return out, metadata, err 1017} 1018 1019func awsRestjson1_deserializeOpErrorBatchRead(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1020 var errorBuffer bytes.Buffer 1021 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1022 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1023 } 1024 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1025 1026 errorCode := "UnknownError" 1027 errorMessage := errorCode 1028 1029 code := response.Header.Get("X-Amzn-ErrorType") 1030 if len(code) != 0 { 1031 errorCode = restjson.SanitizeErrorCode(code) 1032 } 1033 1034 var buff [1024]byte 1035 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1036 1037 body := io.TeeReader(errorBody, ringBuffer) 1038 decoder := json.NewDecoder(body) 1039 decoder.UseNumber() 1040 code, message, err := restjson.GetErrorInfo(decoder) 1041 if err != nil { 1042 var snapshot bytes.Buffer 1043 io.Copy(&snapshot, ringBuffer) 1044 err = &smithy.DeserializationError{ 1045 Err: fmt.Errorf("failed to decode response body, %w", err), 1046 Snapshot: snapshot.Bytes(), 1047 } 1048 return err 1049 } 1050 1051 errorBody.Seek(0, io.SeekStart) 1052 if len(code) != 0 { 1053 errorCode = restjson.SanitizeErrorCode(code) 1054 } 1055 if len(message) != 0 { 1056 errorMessage = message 1057 } 1058 1059 switch { 1060 case strings.EqualFold("AccessDeniedException", errorCode): 1061 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 1062 1063 case strings.EqualFold("DirectoryNotEnabledException", errorCode): 1064 return awsRestjson1_deserializeErrorDirectoryNotEnabledException(response, errorBody) 1065 1066 case strings.EqualFold("InternalServiceException", errorCode): 1067 return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody) 1068 1069 case strings.EqualFold("InvalidArnException", errorCode): 1070 return awsRestjson1_deserializeErrorInvalidArnException(response, errorBody) 1071 1072 case strings.EqualFold("LimitExceededException", errorCode): 1073 return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody) 1074 1075 case strings.EqualFold("RetryableConflictException", errorCode): 1076 return awsRestjson1_deserializeErrorRetryableConflictException(response, errorBody) 1077 1078 case strings.EqualFold("ValidationException", errorCode): 1079 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 1080 1081 default: 1082 genericError := &smithy.GenericAPIError{ 1083 Code: errorCode, 1084 Message: errorMessage, 1085 } 1086 return genericError 1087 1088 } 1089} 1090 1091func awsRestjson1_deserializeOpDocumentBatchReadOutput(v **BatchReadOutput, value interface{}) error { 1092 if v == nil { 1093 return fmt.Errorf("unexpected nil of type %T", v) 1094 } 1095 if value == nil { 1096 return nil 1097 } 1098 1099 shape, ok := value.(map[string]interface{}) 1100 if !ok { 1101 return fmt.Errorf("unexpected JSON type %v", value) 1102 } 1103 1104 var sv *BatchReadOutput 1105 if *v == nil { 1106 sv = &BatchReadOutput{} 1107 } else { 1108 sv = *v 1109 } 1110 1111 for key, value := range shape { 1112 switch key { 1113 case "Responses": 1114 if err := awsRestjson1_deserializeDocumentBatchReadOperationResponseList(&sv.Responses, value); err != nil { 1115 return err 1116 } 1117 1118 default: 1119 _, _ = key, value 1120 1121 } 1122 } 1123 *v = sv 1124 return nil 1125} 1126 1127type awsRestjson1_deserializeOpBatchWrite struct { 1128} 1129 1130func (*awsRestjson1_deserializeOpBatchWrite) ID() string { 1131 return "OperationDeserializer" 1132} 1133 1134func (m *awsRestjson1_deserializeOpBatchWrite) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1135 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1136) { 1137 out, metadata, err = next.HandleDeserialize(ctx, in) 1138 if err != nil { 1139 return out, metadata, err 1140 } 1141 1142 response, ok := out.RawResponse.(*smithyhttp.Response) 1143 if !ok { 1144 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1145 } 1146 1147 if response.StatusCode < 200 || response.StatusCode >= 300 { 1148 return out, metadata, awsRestjson1_deserializeOpErrorBatchWrite(response, &metadata) 1149 } 1150 output := &BatchWriteOutput{} 1151 out.Result = output 1152 1153 var buff [1024]byte 1154 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1155 1156 body := io.TeeReader(response.Body, ringBuffer) 1157 1158 decoder := json.NewDecoder(body) 1159 decoder.UseNumber() 1160 var shape interface{} 1161 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1162 var snapshot bytes.Buffer 1163 io.Copy(&snapshot, ringBuffer) 1164 err = &smithy.DeserializationError{ 1165 Err: fmt.Errorf("failed to decode response body, %w", err), 1166 Snapshot: snapshot.Bytes(), 1167 } 1168 return out, metadata, err 1169 } 1170 1171 err = awsRestjson1_deserializeOpDocumentBatchWriteOutput(&output, shape) 1172 if err != nil { 1173 var snapshot bytes.Buffer 1174 io.Copy(&snapshot, ringBuffer) 1175 return out, metadata, &smithy.DeserializationError{ 1176 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 1177 Snapshot: snapshot.Bytes(), 1178 } 1179 } 1180 1181 return out, metadata, err 1182} 1183 1184func awsRestjson1_deserializeOpErrorBatchWrite(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1185 var errorBuffer bytes.Buffer 1186 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1187 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1188 } 1189 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1190 1191 errorCode := "UnknownError" 1192 errorMessage := errorCode 1193 1194 code := response.Header.Get("X-Amzn-ErrorType") 1195 if len(code) != 0 { 1196 errorCode = restjson.SanitizeErrorCode(code) 1197 } 1198 1199 var buff [1024]byte 1200 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1201 1202 body := io.TeeReader(errorBody, ringBuffer) 1203 decoder := json.NewDecoder(body) 1204 decoder.UseNumber() 1205 code, message, err := restjson.GetErrorInfo(decoder) 1206 if err != nil { 1207 var snapshot bytes.Buffer 1208 io.Copy(&snapshot, ringBuffer) 1209 err = &smithy.DeserializationError{ 1210 Err: fmt.Errorf("failed to decode response body, %w", err), 1211 Snapshot: snapshot.Bytes(), 1212 } 1213 return err 1214 } 1215 1216 errorBody.Seek(0, io.SeekStart) 1217 if len(code) != 0 { 1218 errorCode = restjson.SanitizeErrorCode(code) 1219 } 1220 if len(message) != 0 { 1221 errorMessage = message 1222 } 1223 1224 switch { 1225 case strings.EqualFold("AccessDeniedException", errorCode): 1226 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 1227 1228 case strings.EqualFold("BatchWriteException", errorCode): 1229 return awsRestjson1_deserializeErrorBatchWriteException(response, errorBody) 1230 1231 case strings.EqualFold("DirectoryNotEnabledException", errorCode): 1232 return awsRestjson1_deserializeErrorDirectoryNotEnabledException(response, errorBody) 1233 1234 case strings.EqualFold("InternalServiceException", errorCode): 1235 return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody) 1236 1237 case strings.EqualFold("InvalidArnException", errorCode): 1238 return awsRestjson1_deserializeErrorInvalidArnException(response, errorBody) 1239 1240 case strings.EqualFold("LimitExceededException", errorCode): 1241 return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody) 1242 1243 case strings.EqualFold("RetryableConflictException", errorCode): 1244 return awsRestjson1_deserializeErrorRetryableConflictException(response, errorBody) 1245 1246 case strings.EqualFold("ValidationException", errorCode): 1247 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 1248 1249 default: 1250 genericError := &smithy.GenericAPIError{ 1251 Code: errorCode, 1252 Message: errorMessage, 1253 } 1254 return genericError 1255 1256 } 1257} 1258 1259func awsRestjson1_deserializeOpDocumentBatchWriteOutput(v **BatchWriteOutput, value interface{}) error { 1260 if v == nil { 1261 return fmt.Errorf("unexpected nil of type %T", v) 1262 } 1263 if value == nil { 1264 return nil 1265 } 1266 1267 shape, ok := value.(map[string]interface{}) 1268 if !ok { 1269 return fmt.Errorf("unexpected JSON type %v", value) 1270 } 1271 1272 var sv *BatchWriteOutput 1273 if *v == nil { 1274 sv = &BatchWriteOutput{} 1275 } else { 1276 sv = *v 1277 } 1278 1279 for key, value := range shape { 1280 switch key { 1281 case "Responses": 1282 if err := awsRestjson1_deserializeDocumentBatchWriteOperationResponseList(&sv.Responses, value); err != nil { 1283 return err 1284 } 1285 1286 default: 1287 _, _ = key, value 1288 1289 } 1290 } 1291 *v = sv 1292 return nil 1293} 1294 1295type awsRestjson1_deserializeOpCreateDirectory struct { 1296} 1297 1298func (*awsRestjson1_deserializeOpCreateDirectory) ID() string { 1299 return "OperationDeserializer" 1300} 1301 1302func (m *awsRestjson1_deserializeOpCreateDirectory) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1303 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1304) { 1305 out, metadata, err = next.HandleDeserialize(ctx, in) 1306 if err != nil { 1307 return out, metadata, err 1308 } 1309 1310 response, ok := out.RawResponse.(*smithyhttp.Response) 1311 if !ok { 1312 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1313 } 1314 1315 if response.StatusCode < 200 || response.StatusCode >= 300 { 1316 return out, metadata, awsRestjson1_deserializeOpErrorCreateDirectory(response, &metadata) 1317 } 1318 output := &CreateDirectoryOutput{} 1319 out.Result = output 1320 1321 var buff [1024]byte 1322 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1323 1324 body := io.TeeReader(response.Body, ringBuffer) 1325 1326 decoder := json.NewDecoder(body) 1327 decoder.UseNumber() 1328 var shape interface{} 1329 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1330 var snapshot bytes.Buffer 1331 io.Copy(&snapshot, ringBuffer) 1332 err = &smithy.DeserializationError{ 1333 Err: fmt.Errorf("failed to decode response body, %w", err), 1334 Snapshot: snapshot.Bytes(), 1335 } 1336 return out, metadata, err 1337 } 1338 1339 err = awsRestjson1_deserializeOpDocumentCreateDirectoryOutput(&output, shape) 1340 if err != nil { 1341 var snapshot bytes.Buffer 1342 io.Copy(&snapshot, ringBuffer) 1343 return out, metadata, &smithy.DeserializationError{ 1344 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 1345 Snapshot: snapshot.Bytes(), 1346 } 1347 } 1348 1349 return out, metadata, err 1350} 1351 1352func awsRestjson1_deserializeOpErrorCreateDirectory(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1353 var errorBuffer bytes.Buffer 1354 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1355 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1356 } 1357 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1358 1359 errorCode := "UnknownError" 1360 errorMessage := errorCode 1361 1362 code := response.Header.Get("X-Amzn-ErrorType") 1363 if len(code) != 0 { 1364 errorCode = restjson.SanitizeErrorCode(code) 1365 } 1366 1367 var buff [1024]byte 1368 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1369 1370 body := io.TeeReader(errorBody, ringBuffer) 1371 decoder := json.NewDecoder(body) 1372 decoder.UseNumber() 1373 code, message, err := restjson.GetErrorInfo(decoder) 1374 if err != nil { 1375 var snapshot bytes.Buffer 1376 io.Copy(&snapshot, ringBuffer) 1377 err = &smithy.DeserializationError{ 1378 Err: fmt.Errorf("failed to decode response body, %w", err), 1379 Snapshot: snapshot.Bytes(), 1380 } 1381 return err 1382 } 1383 1384 errorBody.Seek(0, io.SeekStart) 1385 if len(code) != 0 { 1386 errorCode = restjson.SanitizeErrorCode(code) 1387 } 1388 if len(message) != 0 { 1389 errorMessage = message 1390 } 1391 1392 switch { 1393 case strings.EqualFold("AccessDeniedException", errorCode): 1394 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 1395 1396 case strings.EqualFold("DirectoryAlreadyExistsException", errorCode): 1397 return awsRestjson1_deserializeErrorDirectoryAlreadyExistsException(response, errorBody) 1398 1399 case strings.EqualFold("InternalServiceException", errorCode): 1400 return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody) 1401 1402 case strings.EqualFold("InvalidArnException", errorCode): 1403 return awsRestjson1_deserializeErrorInvalidArnException(response, errorBody) 1404 1405 case strings.EqualFold("LimitExceededException", errorCode): 1406 return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody) 1407 1408 case strings.EqualFold("ResourceNotFoundException", errorCode): 1409 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 1410 1411 case strings.EqualFold("RetryableConflictException", errorCode): 1412 return awsRestjson1_deserializeErrorRetryableConflictException(response, errorBody) 1413 1414 case strings.EqualFold("ValidationException", errorCode): 1415 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 1416 1417 default: 1418 genericError := &smithy.GenericAPIError{ 1419 Code: errorCode, 1420 Message: errorMessage, 1421 } 1422 return genericError 1423 1424 } 1425} 1426 1427func awsRestjson1_deserializeOpDocumentCreateDirectoryOutput(v **CreateDirectoryOutput, value interface{}) error { 1428 if v == nil { 1429 return fmt.Errorf("unexpected nil of type %T", v) 1430 } 1431 if value == nil { 1432 return nil 1433 } 1434 1435 shape, ok := value.(map[string]interface{}) 1436 if !ok { 1437 return fmt.Errorf("unexpected JSON type %v", value) 1438 } 1439 1440 var sv *CreateDirectoryOutput 1441 if *v == nil { 1442 sv = &CreateDirectoryOutput{} 1443 } else { 1444 sv = *v 1445 } 1446 1447 for key, value := range shape { 1448 switch key { 1449 case "AppliedSchemaArn": 1450 if value != nil { 1451 jtv, ok := value.(string) 1452 if !ok { 1453 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 1454 } 1455 sv.AppliedSchemaArn = ptr.String(jtv) 1456 } 1457 1458 case "DirectoryArn": 1459 if value != nil { 1460 jtv, ok := value.(string) 1461 if !ok { 1462 return fmt.Errorf("expected DirectoryArn to be of type string, got %T instead", value) 1463 } 1464 sv.DirectoryArn = ptr.String(jtv) 1465 } 1466 1467 case "Name": 1468 if value != nil { 1469 jtv, ok := value.(string) 1470 if !ok { 1471 return fmt.Errorf("expected DirectoryName to be of type string, got %T instead", value) 1472 } 1473 sv.Name = ptr.String(jtv) 1474 } 1475 1476 case "ObjectIdentifier": 1477 if value != nil { 1478 jtv, ok := value.(string) 1479 if !ok { 1480 return fmt.Errorf("expected ObjectIdentifier to be of type string, got %T instead", value) 1481 } 1482 sv.ObjectIdentifier = ptr.String(jtv) 1483 } 1484 1485 default: 1486 _, _ = key, value 1487 1488 } 1489 } 1490 *v = sv 1491 return nil 1492} 1493 1494type awsRestjson1_deserializeOpCreateFacet struct { 1495} 1496 1497func (*awsRestjson1_deserializeOpCreateFacet) ID() string { 1498 return "OperationDeserializer" 1499} 1500 1501func (m *awsRestjson1_deserializeOpCreateFacet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1502 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1503) { 1504 out, metadata, err = next.HandleDeserialize(ctx, in) 1505 if err != nil { 1506 return out, metadata, err 1507 } 1508 1509 response, ok := out.RawResponse.(*smithyhttp.Response) 1510 if !ok { 1511 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1512 } 1513 1514 if response.StatusCode < 200 || response.StatusCode >= 300 { 1515 return out, metadata, awsRestjson1_deserializeOpErrorCreateFacet(response, &metadata) 1516 } 1517 output := &CreateFacetOutput{} 1518 out.Result = output 1519 1520 return out, metadata, err 1521} 1522 1523func awsRestjson1_deserializeOpErrorCreateFacet(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1524 var errorBuffer bytes.Buffer 1525 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1526 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1527 } 1528 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1529 1530 errorCode := "UnknownError" 1531 errorMessage := errorCode 1532 1533 code := response.Header.Get("X-Amzn-ErrorType") 1534 if len(code) != 0 { 1535 errorCode = restjson.SanitizeErrorCode(code) 1536 } 1537 1538 var buff [1024]byte 1539 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1540 1541 body := io.TeeReader(errorBody, ringBuffer) 1542 decoder := json.NewDecoder(body) 1543 decoder.UseNumber() 1544 code, message, err := restjson.GetErrorInfo(decoder) 1545 if err != nil { 1546 var snapshot bytes.Buffer 1547 io.Copy(&snapshot, ringBuffer) 1548 err = &smithy.DeserializationError{ 1549 Err: fmt.Errorf("failed to decode response body, %w", err), 1550 Snapshot: snapshot.Bytes(), 1551 } 1552 return err 1553 } 1554 1555 errorBody.Seek(0, io.SeekStart) 1556 if len(code) != 0 { 1557 errorCode = restjson.SanitizeErrorCode(code) 1558 } 1559 if len(message) != 0 { 1560 errorMessage = message 1561 } 1562 1563 switch { 1564 case strings.EqualFold("AccessDeniedException", errorCode): 1565 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 1566 1567 case strings.EqualFold("FacetAlreadyExistsException", errorCode): 1568 return awsRestjson1_deserializeErrorFacetAlreadyExistsException(response, errorBody) 1569 1570 case strings.EqualFold("FacetValidationException", errorCode): 1571 return awsRestjson1_deserializeErrorFacetValidationException(response, errorBody) 1572 1573 case strings.EqualFold("InternalServiceException", errorCode): 1574 return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody) 1575 1576 case strings.EqualFold("InvalidArnException", errorCode): 1577 return awsRestjson1_deserializeErrorInvalidArnException(response, errorBody) 1578 1579 case strings.EqualFold("InvalidRuleException", errorCode): 1580 return awsRestjson1_deserializeErrorInvalidRuleException(response, errorBody) 1581 1582 case strings.EqualFold("LimitExceededException", errorCode): 1583 return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody) 1584 1585 case strings.EqualFold("ResourceNotFoundException", errorCode): 1586 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 1587 1588 case strings.EqualFold("RetryableConflictException", errorCode): 1589 return awsRestjson1_deserializeErrorRetryableConflictException(response, errorBody) 1590 1591 case strings.EqualFold("ValidationException", errorCode): 1592 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 1593 1594 default: 1595 genericError := &smithy.GenericAPIError{ 1596 Code: errorCode, 1597 Message: errorMessage, 1598 } 1599 return genericError 1600 1601 } 1602} 1603 1604type awsRestjson1_deserializeOpCreateIndex struct { 1605} 1606 1607func (*awsRestjson1_deserializeOpCreateIndex) ID() string { 1608 return "OperationDeserializer" 1609} 1610 1611func (m *awsRestjson1_deserializeOpCreateIndex) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1612 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1613) { 1614 out, metadata, err = next.HandleDeserialize(ctx, in) 1615 if err != nil { 1616 return out, metadata, err 1617 } 1618 1619 response, ok := out.RawResponse.(*smithyhttp.Response) 1620 if !ok { 1621 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1622 } 1623 1624 if response.StatusCode < 200 || response.StatusCode >= 300 { 1625 return out, metadata, awsRestjson1_deserializeOpErrorCreateIndex(response, &metadata) 1626 } 1627 output := &CreateIndexOutput{} 1628 out.Result = output 1629 1630 var buff [1024]byte 1631 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1632 1633 body := io.TeeReader(response.Body, ringBuffer) 1634 1635 decoder := json.NewDecoder(body) 1636 decoder.UseNumber() 1637 var shape interface{} 1638 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1639 var snapshot bytes.Buffer 1640 io.Copy(&snapshot, ringBuffer) 1641 err = &smithy.DeserializationError{ 1642 Err: fmt.Errorf("failed to decode response body, %w", err), 1643 Snapshot: snapshot.Bytes(), 1644 } 1645 return out, metadata, err 1646 } 1647 1648 err = awsRestjson1_deserializeOpDocumentCreateIndexOutput(&output, shape) 1649 if err != nil { 1650 var snapshot bytes.Buffer 1651 io.Copy(&snapshot, ringBuffer) 1652 return out, metadata, &smithy.DeserializationError{ 1653 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 1654 Snapshot: snapshot.Bytes(), 1655 } 1656 } 1657 1658 return out, metadata, err 1659} 1660 1661func awsRestjson1_deserializeOpErrorCreateIndex(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1662 var errorBuffer bytes.Buffer 1663 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1664 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1665 } 1666 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1667 1668 errorCode := "UnknownError" 1669 errorMessage := errorCode 1670 1671 code := response.Header.Get("X-Amzn-ErrorType") 1672 if len(code) != 0 { 1673 errorCode = restjson.SanitizeErrorCode(code) 1674 } 1675 1676 var buff [1024]byte 1677 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1678 1679 body := io.TeeReader(errorBody, ringBuffer) 1680 decoder := json.NewDecoder(body) 1681 decoder.UseNumber() 1682 code, message, err := restjson.GetErrorInfo(decoder) 1683 if err != nil { 1684 var snapshot bytes.Buffer 1685 io.Copy(&snapshot, ringBuffer) 1686 err = &smithy.DeserializationError{ 1687 Err: fmt.Errorf("failed to decode response body, %w", err), 1688 Snapshot: snapshot.Bytes(), 1689 } 1690 return err 1691 } 1692 1693 errorBody.Seek(0, io.SeekStart) 1694 if len(code) != 0 { 1695 errorCode = restjson.SanitizeErrorCode(code) 1696 } 1697 if len(message) != 0 { 1698 errorMessage = message 1699 } 1700 1701 switch { 1702 case strings.EqualFold("AccessDeniedException", errorCode): 1703 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 1704 1705 case strings.EqualFold("DirectoryNotEnabledException", errorCode): 1706 return awsRestjson1_deserializeErrorDirectoryNotEnabledException(response, errorBody) 1707 1708 case strings.EqualFold("FacetValidationException", errorCode): 1709 return awsRestjson1_deserializeErrorFacetValidationException(response, errorBody) 1710 1711 case strings.EqualFold("InternalServiceException", errorCode): 1712 return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody) 1713 1714 case strings.EqualFold("InvalidArnException", errorCode): 1715 return awsRestjson1_deserializeErrorInvalidArnException(response, errorBody) 1716 1717 case strings.EqualFold("LimitExceededException", errorCode): 1718 return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody) 1719 1720 case strings.EqualFold("LinkNameAlreadyInUseException", errorCode): 1721 return awsRestjson1_deserializeErrorLinkNameAlreadyInUseException(response, errorBody) 1722 1723 case strings.EqualFold("ResourceNotFoundException", errorCode): 1724 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 1725 1726 case strings.EqualFold("RetryableConflictException", errorCode): 1727 return awsRestjson1_deserializeErrorRetryableConflictException(response, errorBody) 1728 1729 case strings.EqualFold("UnsupportedIndexTypeException", errorCode): 1730 return awsRestjson1_deserializeErrorUnsupportedIndexTypeException(response, errorBody) 1731 1732 case strings.EqualFold("ValidationException", errorCode): 1733 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 1734 1735 default: 1736 genericError := &smithy.GenericAPIError{ 1737 Code: errorCode, 1738 Message: errorMessage, 1739 } 1740 return genericError 1741 1742 } 1743} 1744 1745func awsRestjson1_deserializeOpDocumentCreateIndexOutput(v **CreateIndexOutput, value interface{}) error { 1746 if v == nil { 1747 return fmt.Errorf("unexpected nil of type %T", v) 1748 } 1749 if value == nil { 1750 return nil 1751 } 1752 1753 shape, ok := value.(map[string]interface{}) 1754 if !ok { 1755 return fmt.Errorf("unexpected JSON type %v", value) 1756 } 1757 1758 var sv *CreateIndexOutput 1759 if *v == nil { 1760 sv = &CreateIndexOutput{} 1761 } else { 1762 sv = *v 1763 } 1764 1765 for key, value := range shape { 1766 switch key { 1767 case "ObjectIdentifier": 1768 if value != nil { 1769 jtv, ok := value.(string) 1770 if !ok { 1771 return fmt.Errorf("expected ObjectIdentifier to be of type string, got %T instead", value) 1772 } 1773 sv.ObjectIdentifier = ptr.String(jtv) 1774 } 1775 1776 default: 1777 _, _ = key, value 1778 1779 } 1780 } 1781 *v = sv 1782 return nil 1783} 1784 1785type awsRestjson1_deserializeOpCreateObject struct { 1786} 1787 1788func (*awsRestjson1_deserializeOpCreateObject) ID() string { 1789 return "OperationDeserializer" 1790} 1791 1792func (m *awsRestjson1_deserializeOpCreateObject) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1793 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1794) { 1795 out, metadata, err = next.HandleDeserialize(ctx, in) 1796 if err != nil { 1797 return out, metadata, err 1798 } 1799 1800 response, ok := out.RawResponse.(*smithyhttp.Response) 1801 if !ok { 1802 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1803 } 1804 1805 if response.StatusCode < 200 || response.StatusCode >= 300 { 1806 return out, metadata, awsRestjson1_deserializeOpErrorCreateObject(response, &metadata) 1807 } 1808 output := &CreateObjectOutput{} 1809 out.Result = output 1810 1811 var buff [1024]byte 1812 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1813 1814 body := io.TeeReader(response.Body, ringBuffer) 1815 1816 decoder := json.NewDecoder(body) 1817 decoder.UseNumber() 1818 var shape interface{} 1819 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1820 var snapshot bytes.Buffer 1821 io.Copy(&snapshot, ringBuffer) 1822 err = &smithy.DeserializationError{ 1823 Err: fmt.Errorf("failed to decode response body, %w", err), 1824 Snapshot: snapshot.Bytes(), 1825 } 1826 return out, metadata, err 1827 } 1828 1829 err = awsRestjson1_deserializeOpDocumentCreateObjectOutput(&output, shape) 1830 if err != nil { 1831 var snapshot bytes.Buffer 1832 io.Copy(&snapshot, ringBuffer) 1833 return out, metadata, &smithy.DeserializationError{ 1834 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 1835 Snapshot: snapshot.Bytes(), 1836 } 1837 } 1838 1839 return out, metadata, err 1840} 1841 1842func awsRestjson1_deserializeOpErrorCreateObject(response *smithyhttp.Response, metadata *middleware.Metadata) error { 1843 var errorBuffer bytes.Buffer 1844 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 1845 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 1846 } 1847 errorBody := bytes.NewReader(errorBuffer.Bytes()) 1848 1849 errorCode := "UnknownError" 1850 errorMessage := errorCode 1851 1852 code := response.Header.Get("X-Amzn-ErrorType") 1853 if len(code) != 0 { 1854 errorCode = restjson.SanitizeErrorCode(code) 1855 } 1856 1857 var buff [1024]byte 1858 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1859 1860 body := io.TeeReader(errorBody, ringBuffer) 1861 decoder := json.NewDecoder(body) 1862 decoder.UseNumber() 1863 code, message, err := restjson.GetErrorInfo(decoder) 1864 if err != nil { 1865 var snapshot bytes.Buffer 1866 io.Copy(&snapshot, ringBuffer) 1867 err = &smithy.DeserializationError{ 1868 Err: fmt.Errorf("failed to decode response body, %w", err), 1869 Snapshot: snapshot.Bytes(), 1870 } 1871 return err 1872 } 1873 1874 errorBody.Seek(0, io.SeekStart) 1875 if len(code) != 0 { 1876 errorCode = restjson.SanitizeErrorCode(code) 1877 } 1878 if len(message) != 0 { 1879 errorMessage = message 1880 } 1881 1882 switch { 1883 case strings.EqualFold("AccessDeniedException", errorCode): 1884 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 1885 1886 case strings.EqualFold("DirectoryNotEnabledException", errorCode): 1887 return awsRestjson1_deserializeErrorDirectoryNotEnabledException(response, errorBody) 1888 1889 case strings.EqualFold("FacetValidationException", errorCode): 1890 return awsRestjson1_deserializeErrorFacetValidationException(response, errorBody) 1891 1892 case strings.EqualFold("InternalServiceException", errorCode): 1893 return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody) 1894 1895 case strings.EqualFold("InvalidArnException", errorCode): 1896 return awsRestjson1_deserializeErrorInvalidArnException(response, errorBody) 1897 1898 case strings.EqualFold("LimitExceededException", errorCode): 1899 return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody) 1900 1901 case strings.EqualFold("LinkNameAlreadyInUseException", errorCode): 1902 return awsRestjson1_deserializeErrorLinkNameAlreadyInUseException(response, errorBody) 1903 1904 case strings.EqualFold("ResourceNotFoundException", errorCode): 1905 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 1906 1907 case strings.EqualFold("RetryableConflictException", errorCode): 1908 return awsRestjson1_deserializeErrorRetryableConflictException(response, errorBody) 1909 1910 case strings.EqualFold("UnsupportedIndexTypeException", errorCode): 1911 return awsRestjson1_deserializeErrorUnsupportedIndexTypeException(response, errorBody) 1912 1913 case strings.EqualFold("ValidationException", errorCode): 1914 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 1915 1916 default: 1917 genericError := &smithy.GenericAPIError{ 1918 Code: errorCode, 1919 Message: errorMessage, 1920 } 1921 return genericError 1922 1923 } 1924} 1925 1926func awsRestjson1_deserializeOpDocumentCreateObjectOutput(v **CreateObjectOutput, value interface{}) error { 1927 if v == nil { 1928 return fmt.Errorf("unexpected nil of type %T", v) 1929 } 1930 if value == nil { 1931 return nil 1932 } 1933 1934 shape, ok := value.(map[string]interface{}) 1935 if !ok { 1936 return fmt.Errorf("unexpected JSON type %v", value) 1937 } 1938 1939 var sv *CreateObjectOutput 1940 if *v == nil { 1941 sv = &CreateObjectOutput{} 1942 } else { 1943 sv = *v 1944 } 1945 1946 for key, value := range shape { 1947 switch key { 1948 case "ObjectIdentifier": 1949 if value != nil { 1950 jtv, ok := value.(string) 1951 if !ok { 1952 return fmt.Errorf("expected ObjectIdentifier to be of type string, got %T instead", value) 1953 } 1954 sv.ObjectIdentifier = ptr.String(jtv) 1955 } 1956 1957 default: 1958 _, _ = key, value 1959 1960 } 1961 } 1962 *v = sv 1963 return nil 1964} 1965 1966type awsRestjson1_deserializeOpCreateSchema struct { 1967} 1968 1969func (*awsRestjson1_deserializeOpCreateSchema) ID() string { 1970 return "OperationDeserializer" 1971} 1972 1973func (m *awsRestjson1_deserializeOpCreateSchema) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 1974 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 1975) { 1976 out, metadata, err = next.HandleDeserialize(ctx, in) 1977 if err != nil { 1978 return out, metadata, err 1979 } 1980 1981 response, ok := out.RawResponse.(*smithyhttp.Response) 1982 if !ok { 1983 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 1984 } 1985 1986 if response.StatusCode < 200 || response.StatusCode >= 300 { 1987 return out, metadata, awsRestjson1_deserializeOpErrorCreateSchema(response, &metadata) 1988 } 1989 output := &CreateSchemaOutput{} 1990 out.Result = output 1991 1992 var buff [1024]byte 1993 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1994 1995 body := io.TeeReader(response.Body, ringBuffer) 1996 1997 decoder := json.NewDecoder(body) 1998 decoder.UseNumber() 1999 var shape interface{} 2000 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2001 var snapshot bytes.Buffer 2002 io.Copy(&snapshot, ringBuffer) 2003 err = &smithy.DeserializationError{ 2004 Err: fmt.Errorf("failed to decode response body, %w", err), 2005 Snapshot: snapshot.Bytes(), 2006 } 2007 return out, metadata, err 2008 } 2009 2010 err = awsRestjson1_deserializeOpDocumentCreateSchemaOutput(&output, shape) 2011 if err != nil { 2012 var snapshot bytes.Buffer 2013 io.Copy(&snapshot, ringBuffer) 2014 return out, metadata, &smithy.DeserializationError{ 2015 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 2016 Snapshot: snapshot.Bytes(), 2017 } 2018 } 2019 2020 return out, metadata, err 2021} 2022 2023func awsRestjson1_deserializeOpErrorCreateSchema(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2024 var errorBuffer bytes.Buffer 2025 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2026 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2027 } 2028 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2029 2030 errorCode := "UnknownError" 2031 errorMessage := errorCode 2032 2033 code := response.Header.Get("X-Amzn-ErrorType") 2034 if len(code) != 0 { 2035 errorCode = restjson.SanitizeErrorCode(code) 2036 } 2037 2038 var buff [1024]byte 2039 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2040 2041 body := io.TeeReader(errorBody, ringBuffer) 2042 decoder := json.NewDecoder(body) 2043 decoder.UseNumber() 2044 code, message, err := restjson.GetErrorInfo(decoder) 2045 if err != nil { 2046 var snapshot bytes.Buffer 2047 io.Copy(&snapshot, ringBuffer) 2048 err = &smithy.DeserializationError{ 2049 Err: fmt.Errorf("failed to decode response body, %w", err), 2050 Snapshot: snapshot.Bytes(), 2051 } 2052 return err 2053 } 2054 2055 errorBody.Seek(0, io.SeekStart) 2056 if len(code) != 0 { 2057 errorCode = restjson.SanitizeErrorCode(code) 2058 } 2059 if len(message) != 0 { 2060 errorMessage = message 2061 } 2062 2063 switch { 2064 case strings.EqualFold("AccessDeniedException", errorCode): 2065 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 2066 2067 case strings.EqualFold("InternalServiceException", errorCode): 2068 return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody) 2069 2070 case strings.EqualFold("InvalidArnException", errorCode): 2071 return awsRestjson1_deserializeErrorInvalidArnException(response, errorBody) 2072 2073 case strings.EqualFold("LimitExceededException", errorCode): 2074 return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody) 2075 2076 case strings.EqualFold("RetryableConflictException", errorCode): 2077 return awsRestjson1_deserializeErrorRetryableConflictException(response, errorBody) 2078 2079 case strings.EqualFold("SchemaAlreadyExistsException", errorCode): 2080 return awsRestjson1_deserializeErrorSchemaAlreadyExistsException(response, errorBody) 2081 2082 case strings.EqualFold("ValidationException", errorCode): 2083 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 2084 2085 default: 2086 genericError := &smithy.GenericAPIError{ 2087 Code: errorCode, 2088 Message: errorMessage, 2089 } 2090 return genericError 2091 2092 } 2093} 2094 2095func awsRestjson1_deserializeOpDocumentCreateSchemaOutput(v **CreateSchemaOutput, value interface{}) error { 2096 if v == nil { 2097 return fmt.Errorf("unexpected nil of type %T", v) 2098 } 2099 if value == nil { 2100 return nil 2101 } 2102 2103 shape, ok := value.(map[string]interface{}) 2104 if !ok { 2105 return fmt.Errorf("unexpected JSON type %v", value) 2106 } 2107 2108 var sv *CreateSchemaOutput 2109 if *v == nil { 2110 sv = &CreateSchemaOutput{} 2111 } else { 2112 sv = *v 2113 } 2114 2115 for key, value := range shape { 2116 switch key { 2117 case "SchemaArn": 2118 if value != nil { 2119 jtv, ok := value.(string) 2120 if !ok { 2121 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 2122 } 2123 sv.SchemaArn = ptr.String(jtv) 2124 } 2125 2126 default: 2127 _, _ = key, value 2128 2129 } 2130 } 2131 *v = sv 2132 return nil 2133} 2134 2135type awsRestjson1_deserializeOpCreateTypedLinkFacet struct { 2136} 2137 2138func (*awsRestjson1_deserializeOpCreateTypedLinkFacet) ID() string { 2139 return "OperationDeserializer" 2140} 2141 2142func (m *awsRestjson1_deserializeOpCreateTypedLinkFacet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2143 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2144) { 2145 out, metadata, err = next.HandleDeserialize(ctx, in) 2146 if err != nil { 2147 return out, metadata, err 2148 } 2149 2150 response, ok := out.RawResponse.(*smithyhttp.Response) 2151 if !ok { 2152 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2153 } 2154 2155 if response.StatusCode < 200 || response.StatusCode >= 300 { 2156 return out, metadata, awsRestjson1_deserializeOpErrorCreateTypedLinkFacet(response, &metadata) 2157 } 2158 output := &CreateTypedLinkFacetOutput{} 2159 out.Result = output 2160 2161 return out, metadata, err 2162} 2163 2164func awsRestjson1_deserializeOpErrorCreateTypedLinkFacet(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2165 var errorBuffer bytes.Buffer 2166 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2167 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2168 } 2169 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2170 2171 errorCode := "UnknownError" 2172 errorMessage := errorCode 2173 2174 code := response.Header.Get("X-Amzn-ErrorType") 2175 if len(code) != 0 { 2176 errorCode = restjson.SanitizeErrorCode(code) 2177 } 2178 2179 var buff [1024]byte 2180 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2181 2182 body := io.TeeReader(errorBody, ringBuffer) 2183 decoder := json.NewDecoder(body) 2184 decoder.UseNumber() 2185 code, message, err := restjson.GetErrorInfo(decoder) 2186 if err != nil { 2187 var snapshot bytes.Buffer 2188 io.Copy(&snapshot, ringBuffer) 2189 err = &smithy.DeserializationError{ 2190 Err: fmt.Errorf("failed to decode response body, %w", err), 2191 Snapshot: snapshot.Bytes(), 2192 } 2193 return err 2194 } 2195 2196 errorBody.Seek(0, io.SeekStart) 2197 if len(code) != 0 { 2198 errorCode = restjson.SanitizeErrorCode(code) 2199 } 2200 if len(message) != 0 { 2201 errorMessage = message 2202 } 2203 2204 switch { 2205 case strings.EqualFold("AccessDeniedException", errorCode): 2206 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 2207 2208 case strings.EqualFold("FacetAlreadyExistsException", errorCode): 2209 return awsRestjson1_deserializeErrorFacetAlreadyExistsException(response, errorBody) 2210 2211 case strings.EqualFold("FacetValidationException", errorCode): 2212 return awsRestjson1_deserializeErrorFacetValidationException(response, errorBody) 2213 2214 case strings.EqualFold("InternalServiceException", errorCode): 2215 return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody) 2216 2217 case strings.EqualFold("InvalidArnException", errorCode): 2218 return awsRestjson1_deserializeErrorInvalidArnException(response, errorBody) 2219 2220 case strings.EqualFold("InvalidRuleException", errorCode): 2221 return awsRestjson1_deserializeErrorInvalidRuleException(response, errorBody) 2222 2223 case strings.EqualFold("LimitExceededException", errorCode): 2224 return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody) 2225 2226 case strings.EqualFold("ResourceNotFoundException", errorCode): 2227 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 2228 2229 case strings.EqualFold("RetryableConflictException", errorCode): 2230 return awsRestjson1_deserializeErrorRetryableConflictException(response, errorBody) 2231 2232 case strings.EqualFold("ValidationException", errorCode): 2233 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 2234 2235 default: 2236 genericError := &smithy.GenericAPIError{ 2237 Code: errorCode, 2238 Message: errorMessage, 2239 } 2240 return genericError 2241 2242 } 2243} 2244 2245type awsRestjson1_deserializeOpDeleteDirectory struct { 2246} 2247 2248func (*awsRestjson1_deserializeOpDeleteDirectory) ID() string { 2249 return "OperationDeserializer" 2250} 2251 2252func (m *awsRestjson1_deserializeOpDeleteDirectory) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2253 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2254) { 2255 out, metadata, err = next.HandleDeserialize(ctx, in) 2256 if err != nil { 2257 return out, metadata, err 2258 } 2259 2260 response, ok := out.RawResponse.(*smithyhttp.Response) 2261 if !ok { 2262 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2263 } 2264 2265 if response.StatusCode < 200 || response.StatusCode >= 300 { 2266 return out, metadata, awsRestjson1_deserializeOpErrorDeleteDirectory(response, &metadata) 2267 } 2268 output := &DeleteDirectoryOutput{} 2269 out.Result = output 2270 2271 var buff [1024]byte 2272 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2273 2274 body := io.TeeReader(response.Body, ringBuffer) 2275 2276 decoder := json.NewDecoder(body) 2277 decoder.UseNumber() 2278 var shape interface{} 2279 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2280 var snapshot bytes.Buffer 2281 io.Copy(&snapshot, ringBuffer) 2282 err = &smithy.DeserializationError{ 2283 Err: fmt.Errorf("failed to decode response body, %w", err), 2284 Snapshot: snapshot.Bytes(), 2285 } 2286 return out, metadata, err 2287 } 2288 2289 err = awsRestjson1_deserializeOpDocumentDeleteDirectoryOutput(&output, shape) 2290 if err != nil { 2291 var snapshot bytes.Buffer 2292 io.Copy(&snapshot, ringBuffer) 2293 return out, metadata, &smithy.DeserializationError{ 2294 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 2295 Snapshot: snapshot.Bytes(), 2296 } 2297 } 2298 2299 return out, metadata, err 2300} 2301 2302func awsRestjson1_deserializeOpErrorDeleteDirectory(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2303 var errorBuffer bytes.Buffer 2304 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2305 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2306 } 2307 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2308 2309 errorCode := "UnknownError" 2310 errorMessage := errorCode 2311 2312 code := response.Header.Get("X-Amzn-ErrorType") 2313 if len(code) != 0 { 2314 errorCode = restjson.SanitizeErrorCode(code) 2315 } 2316 2317 var buff [1024]byte 2318 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2319 2320 body := io.TeeReader(errorBody, ringBuffer) 2321 decoder := json.NewDecoder(body) 2322 decoder.UseNumber() 2323 code, message, err := restjson.GetErrorInfo(decoder) 2324 if err != nil { 2325 var snapshot bytes.Buffer 2326 io.Copy(&snapshot, ringBuffer) 2327 err = &smithy.DeserializationError{ 2328 Err: fmt.Errorf("failed to decode response body, %w", err), 2329 Snapshot: snapshot.Bytes(), 2330 } 2331 return err 2332 } 2333 2334 errorBody.Seek(0, io.SeekStart) 2335 if len(code) != 0 { 2336 errorCode = restjson.SanitizeErrorCode(code) 2337 } 2338 if len(message) != 0 { 2339 errorMessage = message 2340 } 2341 2342 switch { 2343 case strings.EqualFold("AccessDeniedException", errorCode): 2344 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 2345 2346 case strings.EqualFold("DirectoryDeletedException", errorCode): 2347 return awsRestjson1_deserializeErrorDirectoryDeletedException(response, errorBody) 2348 2349 case strings.EqualFold("DirectoryNotDisabledException", errorCode): 2350 return awsRestjson1_deserializeErrorDirectoryNotDisabledException(response, errorBody) 2351 2352 case strings.EqualFold("InternalServiceException", errorCode): 2353 return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody) 2354 2355 case strings.EqualFold("InvalidArnException", errorCode): 2356 return awsRestjson1_deserializeErrorInvalidArnException(response, errorBody) 2357 2358 case strings.EqualFold("LimitExceededException", errorCode): 2359 return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody) 2360 2361 case strings.EqualFold("ResourceNotFoundException", errorCode): 2362 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 2363 2364 case strings.EqualFold("RetryableConflictException", errorCode): 2365 return awsRestjson1_deserializeErrorRetryableConflictException(response, errorBody) 2366 2367 case strings.EqualFold("ValidationException", errorCode): 2368 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 2369 2370 default: 2371 genericError := &smithy.GenericAPIError{ 2372 Code: errorCode, 2373 Message: errorMessage, 2374 } 2375 return genericError 2376 2377 } 2378} 2379 2380func awsRestjson1_deserializeOpDocumentDeleteDirectoryOutput(v **DeleteDirectoryOutput, value interface{}) error { 2381 if v == nil { 2382 return fmt.Errorf("unexpected nil of type %T", v) 2383 } 2384 if value == nil { 2385 return nil 2386 } 2387 2388 shape, ok := value.(map[string]interface{}) 2389 if !ok { 2390 return fmt.Errorf("unexpected JSON type %v", value) 2391 } 2392 2393 var sv *DeleteDirectoryOutput 2394 if *v == nil { 2395 sv = &DeleteDirectoryOutput{} 2396 } else { 2397 sv = *v 2398 } 2399 2400 for key, value := range shape { 2401 switch key { 2402 case "DirectoryArn": 2403 if value != nil { 2404 jtv, ok := value.(string) 2405 if !ok { 2406 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 2407 } 2408 sv.DirectoryArn = ptr.String(jtv) 2409 } 2410 2411 default: 2412 _, _ = key, value 2413 2414 } 2415 } 2416 *v = sv 2417 return nil 2418} 2419 2420type awsRestjson1_deserializeOpDeleteFacet struct { 2421} 2422 2423func (*awsRestjson1_deserializeOpDeleteFacet) ID() string { 2424 return "OperationDeserializer" 2425} 2426 2427func (m *awsRestjson1_deserializeOpDeleteFacet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2428 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2429) { 2430 out, metadata, err = next.HandleDeserialize(ctx, in) 2431 if err != nil { 2432 return out, metadata, err 2433 } 2434 2435 response, ok := out.RawResponse.(*smithyhttp.Response) 2436 if !ok { 2437 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2438 } 2439 2440 if response.StatusCode < 200 || response.StatusCode >= 300 { 2441 return out, metadata, awsRestjson1_deserializeOpErrorDeleteFacet(response, &metadata) 2442 } 2443 output := &DeleteFacetOutput{} 2444 out.Result = output 2445 2446 return out, metadata, err 2447} 2448 2449func awsRestjson1_deserializeOpErrorDeleteFacet(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2450 var errorBuffer bytes.Buffer 2451 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2452 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2453 } 2454 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2455 2456 errorCode := "UnknownError" 2457 errorMessage := errorCode 2458 2459 code := response.Header.Get("X-Amzn-ErrorType") 2460 if len(code) != 0 { 2461 errorCode = restjson.SanitizeErrorCode(code) 2462 } 2463 2464 var buff [1024]byte 2465 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2466 2467 body := io.TeeReader(errorBody, ringBuffer) 2468 decoder := json.NewDecoder(body) 2469 decoder.UseNumber() 2470 code, message, err := restjson.GetErrorInfo(decoder) 2471 if err != nil { 2472 var snapshot bytes.Buffer 2473 io.Copy(&snapshot, ringBuffer) 2474 err = &smithy.DeserializationError{ 2475 Err: fmt.Errorf("failed to decode response body, %w", err), 2476 Snapshot: snapshot.Bytes(), 2477 } 2478 return err 2479 } 2480 2481 errorBody.Seek(0, io.SeekStart) 2482 if len(code) != 0 { 2483 errorCode = restjson.SanitizeErrorCode(code) 2484 } 2485 if len(message) != 0 { 2486 errorMessage = message 2487 } 2488 2489 switch { 2490 case strings.EqualFold("AccessDeniedException", errorCode): 2491 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 2492 2493 case strings.EqualFold("FacetInUseException", errorCode): 2494 return awsRestjson1_deserializeErrorFacetInUseException(response, errorBody) 2495 2496 case strings.EqualFold("FacetNotFoundException", errorCode): 2497 return awsRestjson1_deserializeErrorFacetNotFoundException(response, errorBody) 2498 2499 case strings.EqualFold("InternalServiceException", errorCode): 2500 return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody) 2501 2502 case strings.EqualFold("InvalidArnException", errorCode): 2503 return awsRestjson1_deserializeErrorInvalidArnException(response, errorBody) 2504 2505 case strings.EqualFold("LimitExceededException", errorCode): 2506 return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody) 2507 2508 case strings.EqualFold("ResourceNotFoundException", errorCode): 2509 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 2510 2511 case strings.EqualFold("RetryableConflictException", errorCode): 2512 return awsRestjson1_deserializeErrorRetryableConflictException(response, errorBody) 2513 2514 case strings.EqualFold("ValidationException", errorCode): 2515 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 2516 2517 default: 2518 genericError := &smithy.GenericAPIError{ 2519 Code: errorCode, 2520 Message: errorMessage, 2521 } 2522 return genericError 2523 2524 } 2525} 2526 2527type awsRestjson1_deserializeOpDeleteObject struct { 2528} 2529 2530func (*awsRestjson1_deserializeOpDeleteObject) ID() string { 2531 return "OperationDeserializer" 2532} 2533 2534func (m *awsRestjson1_deserializeOpDeleteObject) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2535 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2536) { 2537 out, metadata, err = next.HandleDeserialize(ctx, in) 2538 if err != nil { 2539 return out, metadata, err 2540 } 2541 2542 response, ok := out.RawResponse.(*smithyhttp.Response) 2543 if !ok { 2544 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2545 } 2546 2547 if response.StatusCode < 200 || response.StatusCode >= 300 { 2548 return out, metadata, awsRestjson1_deserializeOpErrorDeleteObject(response, &metadata) 2549 } 2550 output := &DeleteObjectOutput{} 2551 out.Result = output 2552 2553 return out, metadata, err 2554} 2555 2556func awsRestjson1_deserializeOpErrorDeleteObject(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2557 var errorBuffer bytes.Buffer 2558 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2559 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2560 } 2561 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2562 2563 errorCode := "UnknownError" 2564 errorMessage := errorCode 2565 2566 code := response.Header.Get("X-Amzn-ErrorType") 2567 if len(code) != 0 { 2568 errorCode = restjson.SanitizeErrorCode(code) 2569 } 2570 2571 var buff [1024]byte 2572 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2573 2574 body := io.TeeReader(errorBody, ringBuffer) 2575 decoder := json.NewDecoder(body) 2576 decoder.UseNumber() 2577 code, message, err := restjson.GetErrorInfo(decoder) 2578 if err != nil { 2579 var snapshot bytes.Buffer 2580 io.Copy(&snapshot, ringBuffer) 2581 err = &smithy.DeserializationError{ 2582 Err: fmt.Errorf("failed to decode response body, %w", err), 2583 Snapshot: snapshot.Bytes(), 2584 } 2585 return err 2586 } 2587 2588 errorBody.Seek(0, io.SeekStart) 2589 if len(code) != 0 { 2590 errorCode = restjson.SanitizeErrorCode(code) 2591 } 2592 if len(message) != 0 { 2593 errorMessage = message 2594 } 2595 2596 switch { 2597 case strings.EqualFold("AccessDeniedException", errorCode): 2598 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 2599 2600 case strings.EqualFold("DirectoryNotEnabledException", errorCode): 2601 return awsRestjson1_deserializeErrorDirectoryNotEnabledException(response, errorBody) 2602 2603 case strings.EqualFold("InternalServiceException", errorCode): 2604 return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody) 2605 2606 case strings.EqualFold("InvalidArnException", errorCode): 2607 return awsRestjson1_deserializeErrorInvalidArnException(response, errorBody) 2608 2609 case strings.EqualFold("LimitExceededException", errorCode): 2610 return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody) 2611 2612 case strings.EqualFold("ObjectNotDetachedException", errorCode): 2613 return awsRestjson1_deserializeErrorObjectNotDetachedException(response, errorBody) 2614 2615 case strings.EqualFold("ResourceNotFoundException", errorCode): 2616 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 2617 2618 case strings.EqualFold("RetryableConflictException", errorCode): 2619 return awsRestjson1_deserializeErrorRetryableConflictException(response, errorBody) 2620 2621 case strings.EqualFold("ValidationException", errorCode): 2622 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 2623 2624 default: 2625 genericError := &smithy.GenericAPIError{ 2626 Code: errorCode, 2627 Message: errorMessage, 2628 } 2629 return genericError 2630 2631 } 2632} 2633 2634type awsRestjson1_deserializeOpDeleteSchema struct { 2635} 2636 2637func (*awsRestjson1_deserializeOpDeleteSchema) ID() string { 2638 return "OperationDeserializer" 2639} 2640 2641func (m *awsRestjson1_deserializeOpDeleteSchema) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2642 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2643) { 2644 out, metadata, err = next.HandleDeserialize(ctx, in) 2645 if err != nil { 2646 return out, metadata, err 2647 } 2648 2649 response, ok := out.RawResponse.(*smithyhttp.Response) 2650 if !ok { 2651 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2652 } 2653 2654 if response.StatusCode < 200 || response.StatusCode >= 300 { 2655 return out, metadata, awsRestjson1_deserializeOpErrorDeleteSchema(response, &metadata) 2656 } 2657 output := &DeleteSchemaOutput{} 2658 out.Result = output 2659 2660 var buff [1024]byte 2661 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2662 2663 body := io.TeeReader(response.Body, ringBuffer) 2664 2665 decoder := json.NewDecoder(body) 2666 decoder.UseNumber() 2667 var shape interface{} 2668 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2669 var snapshot bytes.Buffer 2670 io.Copy(&snapshot, ringBuffer) 2671 err = &smithy.DeserializationError{ 2672 Err: fmt.Errorf("failed to decode response body, %w", err), 2673 Snapshot: snapshot.Bytes(), 2674 } 2675 return out, metadata, err 2676 } 2677 2678 err = awsRestjson1_deserializeOpDocumentDeleteSchemaOutput(&output, shape) 2679 if err != nil { 2680 var snapshot bytes.Buffer 2681 io.Copy(&snapshot, ringBuffer) 2682 return out, metadata, &smithy.DeserializationError{ 2683 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 2684 Snapshot: snapshot.Bytes(), 2685 } 2686 } 2687 2688 return out, metadata, err 2689} 2690 2691func awsRestjson1_deserializeOpErrorDeleteSchema(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2692 var errorBuffer bytes.Buffer 2693 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2694 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2695 } 2696 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2697 2698 errorCode := "UnknownError" 2699 errorMessage := errorCode 2700 2701 code := response.Header.Get("X-Amzn-ErrorType") 2702 if len(code) != 0 { 2703 errorCode = restjson.SanitizeErrorCode(code) 2704 } 2705 2706 var buff [1024]byte 2707 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2708 2709 body := io.TeeReader(errorBody, ringBuffer) 2710 decoder := json.NewDecoder(body) 2711 decoder.UseNumber() 2712 code, message, err := restjson.GetErrorInfo(decoder) 2713 if err != nil { 2714 var snapshot bytes.Buffer 2715 io.Copy(&snapshot, ringBuffer) 2716 err = &smithy.DeserializationError{ 2717 Err: fmt.Errorf("failed to decode response body, %w", err), 2718 Snapshot: snapshot.Bytes(), 2719 } 2720 return err 2721 } 2722 2723 errorBody.Seek(0, io.SeekStart) 2724 if len(code) != 0 { 2725 errorCode = restjson.SanitizeErrorCode(code) 2726 } 2727 if len(message) != 0 { 2728 errorMessage = message 2729 } 2730 2731 switch { 2732 case strings.EqualFold("AccessDeniedException", errorCode): 2733 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 2734 2735 case strings.EqualFold("InternalServiceException", errorCode): 2736 return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody) 2737 2738 case strings.EqualFold("InvalidArnException", errorCode): 2739 return awsRestjson1_deserializeErrorInvalidArnException(response, errorBody) 2740 2741 case strings.EqualFold("LimitExceededException", errorCode): 2742 return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody) 2743 2744 case strings.EqualFold("ResourceNotFoundException", errorCode): 2745 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 2746 2747 case strings.EqualFold("RetryableConflictException", errorCode): 2748 return awsRestjson1_deserializeErrorRetryableConflictException(response, errorBody) 2749 2750 case strings.EqualFold("StillContainsLinksException", errorCode): 2751 return awsRestjson1_deserializeErrorStillContainsLinksException(response, errorBody) 2752 2753 case strings.EqualFold("ValidationException", errorCode): 2754 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 2755 2756 default: 2757 genericError := &smithy.GenericAPIError{ 2758 Code: errorCode, 2759 Message: errorMessage, 2760 } 2761 return genericError 2762 2763 } 2764} 2765 2766func awsRestjson1_deserializeOpDocumentDeleteSchemaOutput(v **DeleteSchemaOutput, value interface{}) error { 2767 if v == nil { 2768 return fmt.Errorf("unexpected nil of type %T", v) 2769 } 2770 if value == nil { 2771 return nil 2772 } 2773 2774 shape, ok := value.(map[string]interface{}) 2775 if !ok { 2776 return fmt.Errorf("unexpected JSON type %v", value) 2777 } 2778 2779 var sv *DeleteSchemaOutput 2780 if *v == nil { 2781 sv = &DeleteSchemaOutput{} 2782 } else { 2783 sv = *v 2784 } 2785 2786 for key, value := range shape { 2787 switch key { 2788 case "SchemaArn": 2789 if value != nil { 2790 jtv, ok := value.(string) 2791 if !ok { 2792 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 2793 } 2794 sv.SchemaArn = ptr.String(jtv) 2795 } 2796 2797 default: 2798 _, _ = key, value 2799 2800 } 2801 } 2802 *v = sv 2803 return nil 2804} 2805 2806type awsRestjson1_deserializeOpDeleteTypedLinkFacet struct { 2807} 2808 2809func (*awsRestjson1_deserializeOpDeleteTypedLinkFacet) ID() string { 2810 return "OperationDeserializer" 2811} 2812 2813func (m *awsRestjson1_deserializeOpDeleteTypedLinkFacet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2814 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2815) { 2816 out, metadata, err = next.HandleDeserialize(ctx, in) 2817 if err != nil { 2818 return out, metadata, err 2819 } 2820 2821 response, ok := out.RawResponse.(*smithyhttp.Response) 2822 if !ok { 2823 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2824 } 2825 2826 if response.StatusCode < 200 || response.StatusCode >= 300 { 2827 return out, metadata, awsRestjson1_deserializeOpErrorDeleteTypedLinkFacet(response, &metadata) 2828 } 2829 output := &DeleteTypedLinkFacetOutput{} 2830 out.Result = output 2831 2832 return out, metadata, err 2833} 2834 2835func awsRestjson1_deserializeOpErrorDeleteTypedLinkFacet(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2836 var errorBuffer bytes.Buffer 2837 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2838 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2839 } 2840 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2841 2842 errorCode := "UnknownError" 2843 errorMessage := errorCode 2844 2845 code := response.Header.Get("X-Amzn-ErrorType") 2846 if len(code) != 0 { 2847 errorCode = restjson.SanitizeErrorCode(code) 2848 } 2849 2850 var buff [1024]byte 2851 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2852 2853 body := io.TeeReader(errorBody, ringBuffer) 2854 decoder := json.NewDecoder(body) 2855 decoder.UseNumber() 2856 code, message, err := restjson.GetErrorInfo(decoder) 2857 if err != nil { 2858 var snapshot bytes.Buffer 2859 io.Copy(&snapshot, ringBuffer) 2860 err = &smithy.DeserializationError{ 2861 Err: fmt.Errorf("failed to decode response body, %w", err), 2862 Snapshot: snapshot.Bytes(), 2863 } 2864 return err 2865 } 2866 2867 errorBody.Seek(0, io.SeekStart) 2868 if len(code) != 0 { 2869 errorCode = restjson.SanitizeErrorCode(code) 2870 } 2871 if len(message) != 0 { 2872 errorMessage = message 2873 } 2874 2875 switch { 2876 case strings.EqualFold("AccessDeniedException", errorCode): 2877 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 2878 2879 case strings.EqualFold("FacetNotFoundException", errorCode): 2880 return awsRestjson1_deserializeErrorFacetNotFoundException(response, errorBody) 2881 2882 case strings.EqualFold("InternalServiceException", errorCode): 2883 return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody) 2884 2885 case strings.EqualFold("InvalidArnException", errorCode): 2886 return awsRestjson1_deserializeErrorInvalidArnException(response, errorBody) 2887 2888 case strings.EqualFold("LimitExceededException", errorCode): 2889 return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody) 2890 2891 case strings.EqualFold("ResourceNotFoundException", errorCode): 2892 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 2893 2894 case strings.EqualFold("RetryableConflictException", errorCode): 2895 return awsRestjson1_deserializeErrorRetryableConflictException(response, errorBody) 2896 2897 case strings.EqualFold("ValidationException", errorCode): 2898 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 2899 2900 default: 2901 genericError := &smithy.GenericAPIError{ 2902 Code: errorCode, 2903 Message: errorMessage, 2904 } 2905 return genericError 2906 2907 } 2908} 2909 2910type awsRestjson1_deserializeOpDetachFromIndex struct { 2911} 2912 2913func (*awsRestjson1_deserializeOpDetachFromIndex) ID() string { 2914 return "OperationDeserializer" 2915} 2916 2917func (m *awsRestjson1_deserializeOpDetachFromIndex) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 2918 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 2919) { 2920 out, metadata, err = next.HandleDeserialize(ctx, in) 2921 if err != nil { 2922 return out, metadata, err 2923 } 2924 2925 response, ok := out.RawResponse.(*smithyhttp.Response) 2926 if !ok { 2927 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 2928 } 2929 2930 if response.StatusCode < 200 || response.StatusCode >= 300 { 2931 return out, metadata, awsRestjson1_deserializeOpErrorDetachFromIndex(response, &metadata) 2932 } 2933 output := &DetachFromIndexOutput{} 2934 out.Result = output 2935 2936 var buff [1024]byte 2937 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2938 2939 body := io.TeeReader(response.Body, ringBuffer) 2940 2941 decoder := json.NewDecoder(body) 2942 decoder.UseNumber() 2943 var shape interface{} 2944 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 2945 var snapshot bytes.Buffer 2946 io.Copy(&snapshot, ringBuffer) 2947 err = &smithy.DeserializationError{ 2948 Err: fmt.Errorf("failed to decode response body, %w", err), 2949 Snapshot: snapshot.Bytes(), 2950 } 2951 return out, metadata, err 2952 } 2953 2954 err = awsRestjson1_deserializeOpDocumentDetachFromIndexOutput(&output, shape) 2955 if err != nil { 2956 var snapshot bytes.Buffer 2957 io.Copy(&snapshot, ringBuffer) 2958 return out, metadata, &smithy.DeserializationError{ 2959 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 2960 Snapshot: snapshot.Bytes(), 2961 } 2962 } 2963 2964 return out, metadata, err 2965} 2966 2967func awsRestjson1_deserializeOpErrorDetachFromIndex(response *smithyhttp.Response, metadata *middleware.Metadata) error { 2968 var errorBuffer bytes.Buffer 2969 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 2970 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 2971 } 2972 errorBody := bytes.NewReader(errorBuffer.Bytes()) 2973 2974 errorCode := "UnknownError" 2975 errorMessage := errorCode 2976 2977 code := response.Header.Get("X-Amzn-ErrorType") 2978 if len(code) != 0 { 2979 errorCode = restjson.SanitizeErrorCode(code) 2980 } 2981 2982 var buff [1024]byte 2983 ringBuffer := smithyio.NewRingBuffer(buff[:]) 2984 2985 body := io.TeeReader(errorBody, ringBuffer) 2986 decoder := json.NewDecoder(body) 2987 decoder.UseNumber() 2988 code, message, err := restjson.GetErrorInfo(decoder) 2989 if err != nil { 2990 var snapshot bytes.Buffer 2991 io.Copy(&snapshot, ringBuffer) 2992 err = &smithy.DeserializationError{ 2993 Err: fmt.Errorf("failed to decode response body, %w", err), 2994 Snapshot: snapshot.Bytes(), 2995 } 2996 return err 2997 } 2998 2999 errorBody.Seek(0, io.SeekStart) 3000 if len(code) != 0 { 3001 errorCode = restjson.SanitizeErrorCode(code) 3002 } 3003 if len(message) != 0 { 3004 errorMessage = message 3005 } 3006 3007 switch { 3008 case strings.EqualFold("AccessDeniedException", errorCode): 3009 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 3010 3011 case strings.EqualFold("DirectoryNotEnabledException", errorCode): 3012 return awsRestjson1_deserializeErrorDirectoryNotEnabledException(response, errorBody) 3013 3014 case strings.EqualFold("InternalServiceException", errorCode): 3015 return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody) 3016 3017 case strings.EqualFold("InvalidArnException", errorCode): 3018 return awsRestjson1_deserializeErrorInvalidArnException(response, errorBody) 3019 3020 case strings.EqualFold("LimitExceededException", errorCode): 3021 return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody) 3022 3023 case strings.EqualFold("NotIndexException", errorCode): 3024 return awsRestjson1_deserializeErrorNotIndexException(response, errorBody) 3025 3026 case strings.EqualFold("ObjectAlreadyDetachedException", errorCode): 3027 return awsRestjson1_deserializeErrorObjectAlreadyDetachedException(response, errorBody) 3028 3029 case strings.EqualFold("ResourceNotFoundException", errorCode): 3030 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 3031 3032 case strings.EqualFold("RetryableConflictException", errorCode): 3033 return awsRestjson1_deserializeErrorRetryableConflictException(response, errorBody) 3034 3035 case strings.EqualFold("ValidationException", errorCode): 3036 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 3037 3038 default: 3039 genericError := &smithy.GenericAPIError{ 3040 Code: errorCode, 3041 Message: errorMessage, 3042 } 3043 return genericError 3044 3045 } 3046} 3047 3048func awsRestjson1_deserializeOpDocumentDetachFromIndexOutput(v **DetachFromIndexOutput, value interface{}) error { 3049 if v == nil { 3050 return fmt.Errorf("unexpected nil of type %T", v) 3051 } 3052 if value == nil { 3053 return nil 3054 } 3055 3056 shape, ok := value.(map[string]interface{}) 3057 if !ok { 3058 return fmt.Errorf("unexpected JSON type %v", value) 3059 } 3060 3061 var sv *DetachFromIndexOutput 3062 if *v == nil { 3063 sv = &DetachFromIndexOutput{} 3064 } else { 3065 sv = *v 3066 } 3067 3068 for key, value := range shape { 3069 switch key { 3070 case "DetachedObjectIdentifier": 3071 if value != nil { 3072 jtv, ok := value.(string) 3073 if !ok { 3074 return fmt.Errorf("expected ObjectIdentifier to be of type string, got %T instead", value) 3075 } 3076 sv.DetachedObjectIdentifier = ptr.String(jtv) 3077 } 3078 3079 default: 3080 _, _ = key, value 3081 3082 } 3083 } 3084 *v = sv 3085 return nil 3086} 3087 3088type awsRestjson1_deserializeOpDetachObject struct { 3089} 3090 3091func (*awsRestjson1_deserializeOpDetachObject) ID() string { 3092 return "OperationDeserializer" 3093} 3094 3095func (m *awsRestjson1_deserializeOpDetachObject) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3096 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3097) { 3098 out, metadata, err = next.HandleDeserialize(ctx, in) 3099 if err != nil { 3100 return out, metadata, err 3101 } 3102 3103 response, ok := out.RawResponse.(*smithyhttp.Response) 3104 if !ok { 3105 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3106 } 3107 3108 if response.StatusCode < 200 || response.StatusCode >= 300 { 3109 return out, metadata, awsRestjson1_deserializeOpErrorDetachObject(response, &metadata) 3110 } 3111 output := &DetachObjectOutput{} 3112 out.Result = output 3113 3114 var buff [1024]byte 3115 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3116 3117 body := io.TeeReader(response.Body, ringBuffer) 3118 3119 decoder := json.NewDecoder(body) 3120 decoder.UseNumber() 3121 var shape interface{} 3122 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3123 var snapshot bytes.Buffer 3124 io.Copy(&snapshot, ringBuffer) 3125 err = &smithy.DeserializationError{ 3126 Err: fmt.Errorf("failed to decode response body, %w", err), 3127 Snapshot: snapshot.Bytes(), 3128 } 3129 return out, metadata, err 3130 } 3131 3132 err = awsRestjson1_deserializeOpDocumentDetachObjectOutput(&output, shape) 3133 if err != nil { 3134 var snapshot bytes.Buffer 3135 io.Copy(&snapshot, ringBuffer) 3136 return out, metadata, &smithy.DeserializationError{ 3137 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 3138 Snapshot: snapshot.Bytes(), 3139 } 3140 } 3141 3142 return out, metadata, err 3143} 3144 3145func awsRestjson1_deserializeOpErrorDetachObject(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3146 var errorBuffer bytes.Buffer 3147 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3148 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3149 } 3150 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3151 3152 errorCode := "UnknownError" 3153 errorMessage := errorCode 3154 3155 code := response.Header.Get("X-Amzn-ErrorType") 3156 if len(code) != 0 { 3157 errorCode = restjson.SanitizeErrorCode(code) 3158 } 3159 3160 var buff [1024]byte 3161 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3162 3163 body := io.TeeReader(errorBody, ringBuffer) 3164 decoder := json.NewDecoder(body) 3165 decoder.UseNumber() 3166 code, message, err := restjson.GetErrorInfo(decoder) 3167 if err != nil { 3168 var snapshot bytes.Buffer 3169 io.Copy(&snapshot, ringBuffer) 3170 err = &smithy.DeserializationError{ 3171 Err: fmt.Errorf("failed to decode response body, %w", err), 3172 Snapshot: snapshot.Bytes(), 3173 } 3174 return err 3175 } 3176 3177 errorBody.Seek(0, io.SeekStart) 3178 if len(code) != 0 { 3179 errorCode = restjson.SanitizeErrorCode(code) 3180 } 3181 if len(message) != 0 { 3182 errorMessage = message 3183 } 3184 3185 switch { 3186 case strings.EqualFold("AccessDeniedException", errorCode): 3187 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 3188 3189 case strings.EqualFold("DirectoryNotEnabledException", errorCode): 3190 return awsRestjson1_deserializeErrorDirectoryNotEnabledException(response, errorBody) 3191 3192 case strings.EqualFold("InternalServiceException", errorCode): 3193 return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody) 3194 3195 case strings.EqualFold("InvalidArnException", errorCode): 3196 return awsRestjson1_deserializeErrorInvalidArnException(response, errorBody) 3197 3198 case strings.EqualFold("LimitExceededException", errorCode): 3199 return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody) 3200 3201 case strings.EqualFold("NotNodeException", errorCode): 3202 return awsRestjson1_deserializeErrorNotNodeException(response, errorBody) 3203 3204 case strings.EqualFold("ResourceNotFoundException", errorCode): 3205 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 3206 3207 case strings.EqualFold("RetryableConflictException", errorCode): 3208 return awsRestjson1_deserializeErrorRetryableConflictException(response, errorBody) 3209 3210 case strings.EqualFold("ValidationException", errorCode): 3211 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 3212 3213 default: 3214 genericError := &smithy.GenericAPIError{ 3215 Code: errorCode, 3216 Message: errorMessage, 3217 } 3218 return genericError 3219 3220 } 3221} 3222 3223func awsRestjson1_deserializeOpDocumentDetachObjectOutput(v **DetachObjectOutput, value interface{}) error { 3224 if v == nil { 3225 return fmt.Errorf("unexpected nil of type %T", v) 3226 } 3227 if value == nil { 3228 return nil 3229 } 3230 3231 shape, ok := value.(map[string]interface{}) 3232 if !ok { 3233 return fmt.Errorf("unexpected JSON type %v", value) 3234 } 3235 3236 var sv *DetachObjectOutput 3237 if *v == nil { 3238 sv = &DetachObjectOutput{} 3239 } else { 3240 sv = *v 3241 } 3242 3243 for key, value := range shape { 3244 switch key { 3245 case "DetachedObjectIdentifier": 3246 if value != nil { 3247 jtv, ok := value.(string) 3248 if !ok { 3249 return fmt.Errorf("expected ObjectIdentifier to be of type string, got %T instead", value) 3250 } 3251 sv.DetachedObjectIdentifier = ptr.String(jtv) 3252 } 3253 3254 default: 3255 _, _ = key, value 3256 3257 } 3258 } 3259 *v = sv 3260 return nil 3261} 3262 3263type awsRestjson1_deserializeOpDetachPolicy struct { 3264} 3265 3266func (*awsRestjson1_deserializeOpDetachPolicy) ID() string { 3267 return "OperationDeserializer" 3268} 3269 3270func (m *awsRestjson1_deserializeOpDetachPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3271 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3272) { 3273 out, metadata, err = next.HandleDeserialize(ctx, in) 3274 if err != nil { 3275 return out, metadata, err 3276 } 3277 3278 response, ok := out.RawResponse.(*smithyhttp.Response) 3279 if !ok { 3280 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3281 } 3282 3283 if response.StatusCode < 200 || response.StatusCode >= 300 { 3284 return out, metadata, awsRestjson1_deserializeOpErrorDetachPolicy(response, &metadata) 3285 } 3286 output := &DetachPolicyOutput{} 3287 out.Result = output 3288 3289 return out, metadata, err 3290} 3291 3292func awsRestjson1_deserializeOpErrorDetachPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3293 var errorBuffer bytes.Buffer 3294 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3295 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3296 } 3297 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3298 3299 errorCode := "UnknownError" 3300 errorMessage := errorCode 3301 3302 code := response.Header.Get("X-Amzn-ErrorType") 3303 if len(code) != 0 { 3304 errorCode = restjson.SanitizeErrorCode(code) 3305 } 3306 3307 var buff [1024]byte 3308 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3309 3310 body := io.TeeReader(errorBody, ringBuffer) 3311 decoder := json.NewDecoder(body) 3312 decoder.UseNumber() 3313 code, message, err := restjson.GetErrorInfo(decoder) 3314 if err != nil { 3315 var snapshot bytes.Buffer 3316 io.Copy(&snapshot, ringBuffer) 3317 err = &smithy.DeserializationError{ 3318 Err: fmt.Errorf("failed to decode response body, %w", err), 3319 Snapshot: snapshot.Bytes(), 3320 } 3321 return err 3322 } 3323 3324 errorBody.Seek(0, io.SeekStart) 3325 if len(code) != 0 { 3326 errorCode = restjson.SanitizeErrorCode(code) 3327 } 3328 if len(message) != 0 { 3329 errorMessage = message 3330 } 3331 3332 switch { 3333 case strings.EqualFold("AccessDeniedException", errorCode): 3334 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 3335 3336 case strings.EqualFold("DirectoryNotEnabledException", errorCode): 3337 return awsRestjson1_deserializeErrorDirectoryNotEnabledException(response, errorBody) 3338 3339 case strings.EqualFold("InternalServiceException", errorCode): 3340 return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody) 3341 3342 case strings.EqualFold("InvalidArnException", errorCode): 3343 return awsRestjson1_deserializeErrorInvalidArnException(response, errorBody) 3344 3345 case strings.EqualFold("LimitExceededException", errorCode): 3346 return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody) 3347 3348 case strings.EqualFold("NotPolicyException", errorCode): 3349 return awsRestjson1_deserializeErrorNotPolicyException(response, errorBody) 3350 3351 case strings.EqualFold("ResourceNotFoundException", errorCode): 3352 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 3353 3354 case strings.EqualFold("RetryableConflictException", errorCode): 3355 return awsRestjson1_deserializeErrorRetryableConflictException(response, errorBody) 3356 3357 case strings.EqualFold("ValidationException", errorCode): 3358 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 3359 3360 default: 3361 genericError := &smithy.GenericAPIError{ 3362 Code: errorCode, 3363 Message: errorMessage, 3364 } 3365 return genericError 3366 3367 } 3368} 3369 3370type awsRestjson1_deserializeOpDetachTypedLink struct { 3371} 3372 3373func (*awsRestjson1_deserializeOpDetachTypedLink) ID() string { 3374 return "OperationDeserializer" 3375} 3376 3377func (m *awsRestjson1_deserializeOpDetachTypedLink) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3378 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3379) { 3380 out, metadata, err = next.HandleDeserialize(ctx, in) 3381 if err != nil { 3382 return out, metadata, err 3383 } 3384 3385 response, ok := out.RawResponse.(*smithyhttp.Response) 3386 if !ok { 3387 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3388 } 3389 3390 if response.StatusCode < 200 || response.StatusCode >= 300 { 3391 return out, metadata, awsRestjson1_deserializeOpErrorDetachTypedLink(response, &metadata) 3392 } 3393 output := &DetachTypedLinkOutput{} 3394 out.Result = output 3395 3396 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil { 3397 return out, metadata, &smithy.DeserializationError{ 3398 Err: fmt.Errorf("failed to discard response body, %w", err), 3399 } 3400 } 3401 3402 return out, metadata, err 3403} 3404 3405func awsRestjson1_deserializeOpErrorDetachTypedLink(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3406 var errorBuffer bytes.Buffer 3407 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3408 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3409 } 3410 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3411 3412 errorCode := "UnknownError" 3413 errorMessage := errorCode 3414 3415 code := response.Header.Get("X-Amzn-ErrorType") 3416 if len(code) != 0 { 3417 errorCode = restjson.SanitizeErrorCode(code) 3418 } 3419 3420 var buff [1024]byte 3421 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3422 3423 body := io.TeeReader(errorBody, ringBuffer) 3424 decoder := json.NewDecoder(body) 3425 decoder.UseNumber() 3426 code, message, err := restjson.GetErrorInfo(decoder) 3427 if err != nil { 3428 var snapshot bytes.Buffer 3429 io.Copy(&snapshot, ringBuffer) 3430 err = &smithy.DeserializationError{ 3431 Err: fmt.Errorf("failed to decode response body, %w", err), 3432 Snapshot: snapshot.Bytes(), 3433 } 3434 return err 3435 } 3436 3437 errorBody.Seek(0, io.SeekStart) 3438 if len(code) != 0 { 3439 errorCode = restjson.SanitizeErrorCode(code) 3440 } 3441 if len(message) != 0 { 3442 errorMessage = message 3443 } 3444 3445 switch { 3446 case strings.EqualFold("AccessDeniedException", errorCode): 3447 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 3448 3449 case strings.EqualFold("DirectoryNotEnabledException", errorCode): 3450 return awsRestjson1_deserializeErrorDirectoryNotEnabledException(response, errorBody) 3451 3452 case strings.EqualFold("FacetValidationException", errorCode): 3453 return awsRestjson1_deserializeErrorFacetValidationException(response, errorBody) 3454 3455 case strings.EqualFold("InternalServiceException", errorCode): 3456 return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody) 3457 3458 case strings.EqualFold("InvalidArnException", errorCode): 3459 return awsRestjson1_deserializeErrorInvalidArnException(response, errorBody) 3460 3461 case strings.EqualFold("LimitExceededException", errorCode): 3462 return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody) 3463 3464 case strings.EqualFold("ResourceNotFoundException", errorCode): 3465 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 3466 3467 case strings.EqualFold("RetryableConflictException", errorCode): 3468 return awsRestjson1_deserializeErrorRetryableConflictException(response, errorBody) 3469 3470 case strings.EqualFold("ValidationException", errorCode): 3471 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 3472 3473 default: 3474 genericError := &smithy.GenericAPIError{ 3475 Code: errorCode, 3476 Message: errorMessage, 3477 } 3478 return genericError 3479 3480 } 3481} 3482 3483type awsRestjson1_deserializeOpDisableDirectory struct { 3484} 3485 3486func (*awsRestjson1_deserializeOpDisableDirectory) ID() string { 3487 return "OperationDeserializer" 3488} 3489 3490func (m *awsRestjson1_deserializeOpDisableDirectory) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3491 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3492) { 3493 out, metadata, err = next.HandleDeserialize(ctx, in) 3494 if err != nil { 3495 return out, metadata, err 3496 } 3497 3498 response, ok := out.RawResponse.(*smithyhttp.Response) 3499 if !ok { 3500 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3501 } 3502 3503 if response.StatusCode < 200 || response.StatusCode >= 300 { 3504 return out, metadata, awsRestjson1_deserializeOpErrorDisableDirectory(response, &metadata) 3505 } 3506 output := &DisableDirectoryOutput{} 3507 out.Result = output 3508 3509 var buff [1024]byte 3510 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3511 3512 body := io.TeeReader(response.Body, ringBuffer) 3513 3514 decoder := json.NewDecoder(body) 3515 decoder.UseNumber() 3516 var shape interface{} 3517 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3518 var snapshot bytes.Buffer 3519 io.Copy(&snapshot, ringBuffer) 3520 err = &smithy.DeserializationError{ 3521 Err: fmt.Errorf("failed to decode response body, %w", err), 3522 Snapshot: snapshot.Bytes(), 3523 } 3524 return out, metadata, err 3525 } 3526 3527 err = awsRestjson1_deserializeOpDocumentDisableDirectoryOutput(&output, shape) 3528 if err != nil { 3529 var snapshot bytes.Buffer 3530 io.Copy(&snapshot, ringBuffer) 3531 return out, metadata, &smithy.DeserializationError{ 3532 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 3533 Snapshot: snapshot.Bytes(), 3534 } 3535 } 3536 3537 return out, metadata, err 3538} 3539 3540func awsRestjson1_deserializeOpErrorDisableDirectory(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3541 var errorBuffer bytes.Buffer 3542 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3543 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3544 } 3545 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3546 3547 errorCode := "UnknownError" 3548 errorMessage := errorCode 3549 3550 code := response.Header.Get("X-Amzn-ErrorType") 3551 if len(code) != 0 { 3552 errorCode = restjson.SanitizeErrorCode(code) 3553 } 3554 3555 var buff [1024]byte 3556 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3557 3558 body := io.TeeReader(errorBody, ringBuffer) 3559 decoder := json.NewDecoder(body) 3560 decoder.UseNumber() 3561 code, message, err := restjson.GetErrorInfo(decoder) 3562 if err != nil { 3563 var snapshot bytes.Buffer 3564 io.Copy(&snapshot, ringBuffer) 3565 err = &smithy.DeserializationError{ 3566 Err: fmt.Errorf("failed to decode response body, %w", err), 3567 Snapshot: snapshot.Bytes(), 3568 } 3569 return err 3570 } 3571 3572 errorBody.Seek(0, io.SeekStart) 3573 if len(code) != 0 { 3574 errorCode = restjson.SanitizeErrorCode(code) 3575 } 3576 if len(message) != 0 { 3577 errorMessage = message 3578 } 3579 3580 switch { 3581 case strings.EqualFold("AccessDeniedException", errorCode): 3582 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 3583 3584 case strings.EqualFold("DirectoryDeletedException", errorCode): 3585 return awsRestjson1_deserializeErrorDirectoryDeletedException(response, errorBody) 3586 3587 case strings.EqualFold("InternalServiceException", errorCode): 3588 return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody) 3589 3590 case strings.EqualFold("InvalidArnException", errorCode): 3591 return awsRestjson1_deserializeErrorInvalidArnException(response, errorBody) 3592 3593 case strings.EqualFold("LimitExceededException", errorCode): 3594 return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody) 3595 3596 case strings.EqualFold("ResourceNotFoundException", errorCode): 3597 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 3598 3599 case strings.EqualFold("RetryableConflictException", errorCode): 3600 return awsRestjson1_deserializeErrorRetryableConflictException(response, errorBody) 3601 3602 case strings.EqualFold("ValidationException", errorCode): 3603 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 3604 3605 default: 3606 genericError := &smithy.GenericAPIError{ 3607 Code: errorCode, 3608 Message: errorMessage, 3609 } 3610 return genericError 3611 3612 } 3613} 3614 3615func awsRestjson1_deserializeOpDocumentDisableDirectoryOutput(v **DisableDirectoryOutput, value interface{}) error { 3616 if v == nil { 3617 return fmt.Errorf("unexpected nil of type %T", v) 3618 } 3619 if value == nil { 3620 return nil 3621 } 3622 3623 shape, ok := value.(map[string]interface{}) 3624 if !ok { 3625 return fmt.Errorf("unexpected JSON type %v", value) 3626 } 3627 3628 var sv *DisableDirectoryOutput 3629 if *v == nil { 3630 sv = &DisableDirectoryOutput{} 3631 } else { 3632 sv = *v 3633 } 3634 3635 for key, value := range shape { 3636 switch key { 3637 case "DirectoryArn": 3638 if value != nil { 3639 jtv, ok := value.(string) 3640 if !ok { 3641 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 3642 } 3643 sv.DirectoryArn = ptr.String(jtv) 3644 } 3645 3646 default: 3647 _, _ = key, value 3648 3649 } 3650 } 3651 *v = sv 3652 return nil 3653} 3654 3655type awsRestjson1_deserializeOpEnableDirectory struct { 3656} 3657 3658func (*awsRestjson1_deserializeOpEnableDirectory) ID() string { 3659 return "OperationDeserializer" 3660} 3661 3662func (m *awsRestjson1_deserializeOpEnableDirectory) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3663 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3664) { 3665 out, metadata, err = next.HandleDeserialize(ctx, in) 3666 if err != nil { 3667 return out, metadata, err 3668 } 3669 3670 response, ok := out.RawResponse.(*smithyhttp.Response) 3671 if !ok { 3672 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3673 } 3674 3675 if response.StatusCode < 200 || response.StatusCode >= 300 { 3676 return out, metadata, awsRestjson1_deserializeOpErrorEnableDirectory(response, &metadata) 3677 } 3678 output := &EnableDirectoryOutput{} 3679 out.Result = output 3680 3681 var buff [1024]byte 3682 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3683 3684 body := io.TeeReader(response.Body, ringBuffer) 3685 3686 decoder := json.NewDecoder(body) 3687 decoder.UseNumber() 3688 var shape interface{} 3689 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3690 var snapshot bytes.Buffer 3691 io.Copy(&snapshot, ringBuffer) 3692 err = &smithy.DeserializationError{ 3693 Err: fmt.Errorf("failed to decode response body, %w", err), 3694 Snapshot: snapshot.Bytes(), 3695 } 3696 return out, metadata, err 3697 } 3698 3699 err = awsRestjson1_deserializeOpDocumentEnableDirectoryOutput(&output, shape) 3700 if err != nil { 3701 var snapshot bytes.Buffer 3702 io.Copy(&snapshot, ringBuffer) 3703 return out, metadata, &smithy.DeserializationError{ 3704 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 3705 Snapshot: snapshot.Bytes(), 3706 } 3707 } 3708 3709 return out, metadata, err 3710} 3711 3712func awsRestjson1_deserializeOpErrorEnableDirectory(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3713 var errorBuffer bytes.Buffer 3714 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3715 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3716 } 3717 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3718 3719 errorCode := "UnknownError" 3720 errorMessage := errorCode 3721 3722 code := response.Header.Get("X-Amzn-ErrorType") 3723 if len(code) != 0 { 3724 errorCode = restjson.SanitizeErrorCode(code) 3725 } 3726 3727 var buff [1024]byte 3728 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3729 3730 body := io.TeeReader(errorBody, ringBuffer) 3731 decoder := json.NewDecoder(body) 3732 decoder.UseNumber() 3733 code, message, err := restjson.GetErrorInfo(decoder) 3734 if err != nil { 3735 var snapshot bytes.Buffer 3736 io.Copy(&snapshot, ringBuffer) 3737 err = &smithy.DeserializationError{ 3738 Err: fmt.Errorf("failed to decode response body, %w", err), 3739 Snapshot: snapshot.Bytes(), 3740 } 3741 return err 3742 } 3743 3744 errorBody.Seek(0, io.SeekStart) 3745 if len(code) != 0 { 3746 errorCode = restjson.SanitizeErrorCode(code) 3747 } 3748 if len(message) != 0 { 3749 errorMessage = message 3750 } 3751 3752 switch { 3753 case strings.EqualFold("AccessDeniedException", errorCode): 3754 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 3755 3756 case strings.EqualFold("DirectoryDeletedException", errorCode): 3757 return awsRestjson1_deserializeErrorDirectoryDeletedException(response, errorBody) 3758 3759 case strings.EqualFold("InternalServiceException", errorCode): 3760 return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody) 3761 3762 case strings.EqualFold("InvalidArnException", errorCode): 3763 return awsRestjson1_deserializeErrorInvalidArnException(response, errorBody) 3764 3765 case strings.EqualFold("LimitExceededException", errorCode): 3766 return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody) 3767 3768 case strings.EqualFold("ResourceNotFoundException", errorCode): 3769 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 3770 3771 case strings.EqualFold("RetryableConflictException", errorCode): 3772 return awsRestjson1_deserializeErrorRetryableConflictException(response, errorBody) 3773 3774 case strings.EqualFold("ValidationException", errorCode): 3775 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 3776 3777 default: 3778 genericError := &smithy.GenericAPIError{ 3779 Code: errorCode, 3780 Message: errorMessage, 3781 } 3782 return genericError 3783 3784 } 3785} 3786 3787func awsRestjson1_deserializeOpDocumentEnableDirectoryOutput(v **EnableDirectoryOutput, value interface{}) error { 3788 if v == nil { 3789 return fmt.Errorf("unexpected nil of type %T", v) 3790 } 3791 if value == nil { 3792 return nil 3793 } 3794 3795 shape, ok := value.(map[string]interface{}) 3796 if !ok { 3797 return fmt.Errorf("unexpected JSON type %v", value) 3798 } 3799 3800 var sv *EnableDirectoryOutput 3801 if *v == nil { 3802 sv = &EnableDirectoryOutput{} 3803 } else { 3804 sv = *v 3805 } 3806 3807 for key, value := range shape { 3808 switch key { 3809 case "DirectoryArn": 3810 if value != nil { 3811 jtv, ok := value.(string) 3812 if !ok { 3813 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 3814 } 3815 sv.DirectoryArn = ptr.String(jtv) 3816 } 3817 3818 default: 3819 _, _ = key, value 3820 3821 } 3822 } 3823 *v = sv 3824 return nil 3825} 3826 3827type awsRestjson1_deserializeOpGetAppliedSchemaVersion struct { 3828} 3829 3830func (*awsRestjson1_deserializeOpGetAppliedSchemaVersion) ID() string { 3831 return "OperationDeserializer" 3832} 3833 3834func (m *awsRestjson1_deserializeOpGetAppliedSchemaVersion) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 3835 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 3836) { 3837 out, metadata, err = next.HandleDeserialize(ctx, in) 3838 if err != nil { 3839 return out, metadata, err 3840 } 3841 3842 response, ok := out.RawResponse.(*smithyhttp.Response) 3843 if !ok { 3844 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 3845 } 3846 3847 if response.StatusCode < 200 || response.StatusCode >= 300 { 3848 return out, metadata, awsRestjson1_deserializeOpErrorGetAppliedSchemaVersion(response, &metadata) 3849 } 3850 output := &GetAppliedSchemaVersionOutput{} 3851 out.Result = output 3852 3853 var buff [1024]byte 3854 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3855 3856 body := io.TeeReader(response.Body, ringBuffer) 3857 3858 decoder := json.NewDecoder(body) 3859 decoder.UseNumber() 3860 var shape interface{} 3861 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 3862 var snapshot bytes.Buffer 3863 io.Copy(&snapshot, ringBuffer) 3864 err = &smithy.DeserializationError{ 3865 Err: fmt.Errorf("failed to decode response body, %w", err), 3866 Snapshot: snapshot.Bytes(), 3867 } 3868 return out, metadata, err 3869 } 3870 3871 err = awsRestjson1_deserializeOpDocumentGetAppliedSchemaVersionOutput(&output, shape) 3872 if err != nil { 3873 var snapshot bytes.Buffer 3874 io.Copy(&snapshot, ringBuffer) 3875 return out, metadata, &smithy.DeserializationError{ 3876 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 3877 Snapshot: snapshot.Bytes(), 3878 } 3879 } 3880 3881 return out, metadata, err 3882} 3883 3884func awsRestjson1_deserializeOpErrorGetAppliedSchemaVersion(response *smithyhttp.Response, metadata *middleware.Metadata) error { 3885 var errorBuffer bytes.Buffer 3886 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 3887 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 3888 } 3889 errorBody := bytes.NewReader(errorBuffer.Bytes()) 3890 3891 errorCode := "UnknownError" 3892 errorMessage := errorCode 3893 3894 code := response.Header.Get("X-Amzn-ErrorType") 3895 if len(code) != 0 { 3896 errorCode = restjson.SanitizeErrorCode(code) 3897 } 3898 3899 var buff [1024]byte 3900 ringBuffer := smithyio.NewRingBuffer(buff[:]) 3901 3902 body := io.TeeReader(errorBody, ringBuffer) 3903 decoder := json.NewDecoder(body) 3904 decoder.UseNumber() 3905 code, message, err := restjson.GetErrorInfo(decoder) 3906 if err != nil { 3907 var snapshot bytes.Buffer 3908 io.Copy(&snapshot, ringBuffer) 3909 err = &smithy.DeserializationError{ 3910 Err: fmt.Errorf("failed to decode response body, %w", err), 3911 Snapshot: snapshot.Bytes(), 3912 } 3913 return err 3914 } 3915 3916 errorBody.Seek(0, io.SeekStart) 3917 if len(code) != 0 { 3918 errorCode = restjson.SanitizeErrorCode(code) 3919 } 3920 if len(message) != 0 { 3921 errorMessage = message 3922 } 3923 3924 switch { 3925 case strings.EqualFold("AccessDeniedException", errorCode): 3926 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 3927 3928 case strings.EqualFold("InternalServiceException", errorCode): 3929 return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody) 3930 3931 case strings.EqualFold("InvalidArnException", errorCode): 3932 return awsRestjson1_deserializeErrorInvalidArnException(response, errorBody) 3933 3934 case strings.EqualFold("LimitExceededException", errorCode): 3935 return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody) 3936 3937 case strings.EqualFold("ResourceNotFoundException", errorCode): 3938 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 3939 3940 case strings.EqualFold("RetryableConflictException", errorCode): 3941 return awsRestjson1_deserializeErrorRetryableConflictException(response, errorBody) 3942 3943 case strings.EqualFold("ValidationException", errorCode): 3944 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 3945 3946 default: 3947 genericError := &smithy.GenericAPIError{ 3948 Code: errorCode, 3949 Message: errorMessage, 3950 } 3951 return genericError 3952 3953 } 3954} 3955 3956func awsRestjson1_deserializeOpDocumentGetAppliedSchemaVersionOutput(v **GetAppliedSchemaVersionOutput, value interface{}) error { 3957 if v == nil { 3958 return fmt.Errorf("unexpected nil of type %T", v) 3959 } 3960 if value == nil { 3961 return nil 3962 } 3963 3964 shape, ok := value.(map[string]interface{}) 3965 if !ok { 3966 return fmt.Errorf("unexpected JSON type %v", value) 3967 } 3968 3969 var sv *GetAppliedSchemaVersionOutput 3970 if *v == nil { 3971 sv = &GetAppliedSchemaVersionOutput{} 3972 } else { 3973 sv = *v 3974 } 3975 3976 for key, value := range shape { 3977 switch key { 3978 case "AppliedSchemaArn": 3979 if value != nil { 3980 jtv, ok := value.(string) 3981 if !ok { 3982 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 3983 } 3984 sv.AppliedSchemaArn = ptr.String(jtv) 3985 } 3986 3987 default: 3988 _, _ = key, value 3989 3990 } 3991 } 3992 *v = sv 3993 return nil 3994} 3995 3996type awsRestjson1_deserializeOpGetDirectory struct { 3997} 3998 3999func (*awsRestjson1_deserializeOpGetDirectory) ID() string { 4000 return "OperationDeserializer" 4001} 4002 4003func (m *awsRestjson1_deserializeOpGetDirectory) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4004 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4005) { 4006 out, metadata, err = next.HandleDeserialize(ctx, in) 4007 if err != nil { 4008 return out, metadata, err 4009 } 4010 4011 response, ok := out.RawResponse.(*smithyhttp.Response) 4012 if !ok { 4013 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4014 } 4015 4016 if response.StatusCode < 200 || response.StatusCode >= 300 { 4017 return out, metadata, awsRestjson1_deserializeOpErrorGetDirectory(response, &metadata) 4018 } 4019 output := &GetDirectoryOutput{} 4020 out.Result = output 4021 4022 var buff [1024]byte 4023 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4024 4025 body := io.TeeReader(response.Body, ringBuffer) 4026 4027 decoder := json.NewDecoder(body) 4028 decoder.UseNumber() 4029 var shape interface{} 4030 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4031 var snapshot bytes.Buffer 4032 io.Copy(&snapshot, ringBuffer) 4033 err = &smithy.DeserializationError{ 4034 Err: fmt.Errorf("failed to decode response body, %w", err), 4035 Snapshot: snapshot.Bytes(), 4036 } 4037 return out, metadata, err 4038 } 4039 4040 err = awsRestjson1_deserializeOpDocumentGetDirectoryOutput(&output, shape) 4041 if err != nil { 4042 var snapshot bytes.Buffer 4043 io.Copy(&snapshot, ringBuffer) 4044 return out, metadata, &smithy.DeserializationError{ 4045 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 4046 Snapshot: snapshot.Bytes(), 4047 } 4048 } 4049 4050 return out, metadata, err 4051} 4052 4053func awsRestjson1_deserializeOpErrorGetDirectory(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4054 var errorBuffer bytes.Buffer 4055 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4056 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4057 } 4058 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4059 4060 errorCode := "UnknownError" 4061 errorMessage := errorCode 4062 4063 code := response.Header.Get("X-Amzn-ErrorType") 4064 if len(code) != 0 { 4065 errorCode = restjson.SanitizeErrorCode(code) 4066 } 4067 4068 var buff [1024]byte 4069 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4070 4071 body := io.TeeReader(errorBody, ringBuffer) 4072 decoder := json.NewDecoder(body) 4073 decoder.UseNumber() 4074 code, message, err := restjson.GetErrorInfo(decoder) 4075 if err != nil { 4076 var snapshot bytes.Buffer 4077 io.Copy(&snapshot, ringBuffer) 4078 err = &smithy.DeserializationError{ 4079 Err: fmt.Errorf("failed to decode response body, %w", err), 4080 Snapshot: snapshot.Bytes(), 4081 } 4082 return err 4083 } 4084 4085 errorBody.Seek(0, io.SeekStart) 4086 if len(code) != 0 { 4087 errorCode = restjson.SanitizeErrorCode(code) 4088 } 4089 if len(message) != 0 { 4090 errorMessage = message 4091 } 4092 4093 switch { 4094 case strings.EqualFold("AccessDeniedException", errorCode): 4095 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 4096 4097 case strings.EqualFold("InternalServiceException", errorCode): 4098 return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody) 4099 4100 case strings.EqualFold("InvalidArnException", errorCode): 4101 return awsRestjson1_deserializeErrorInvalidArnException(response, errorBody) 4102 4103 case strings.EqualFold("LimitExceededException", errorCode): 4104 return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody) 4105 4106 case strings.EqualFold("RetryableConflictException", errorCode): 4107 return awsRestjson1_deserializeErrorRetryableConflictException(response, errorBody) 4108 4109 case strings.EqualFold("ValidationException", errorCode): 4110 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 4111 4112 default: 4113 genericError := &smithy.GenericAPIError{ 4114 Code: errorCode, 4115 Message: errorMessage, 4116 } 4117 return genericError 4118 4119 } 4120} 4121 4122func awsRestjson1_deserializeOpDocumentGetDirectoryOutput(v **GetDirectoryOutput, value interface{}) error { 4123 if v == nil { 4124 return fmt.Errorf("unexpected nil of type %T", v) 4125 } 4126 if value == nil { 4127 return nil 4128 } 4129 4130 shape, ok := value.(map[string]interface{}) 4131 if !ok { 4132 return fmt.Errorf("unexpected JSON type %v", value) 4133 } 4134 4135 var sv *GetDirectoryOutput 4136 if *v == nil { 4137 sv = &GetDirectoryOutput{} 4138 } else { 4139 sv = *v 4140 } 4141 4142 for key, value := range shape { 4143 switch key { 4144 case "Directory": 4145 if err := awsRestjson1_deserializeDocumentDirectory(&sv.Directory, value); err != nil { 4146 return err 4147 } 4148 4149 default: 4150 _, _ = key, value 4151 4152 } 4153 } 4154 *v = sv 4155 return nil 4156} 4157 4158type awsRestjson1_deserializeOpGetFacet struct { 4159} 4160 4161func (*awsRestjson1_deserializeOpGetFacet) ID() string { 4162 return "OperationDeserializer" 4163} 4164 4165func (m *awsRestjson1_deserializeOpGetFacet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4166 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4167) { 4168 out, metadata, err = next.HandleDeserialize(ctx, in) 4169 if err != nil { 4170 return out, metadata, err 4171 } 4172 4173 response, ok := out.RawResponse.(*smithyhttp.Response) 4174 if !ok { 4175 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4176 } 4177 4178 if response.StatusCode < 200 || response.StatusCode >= 300 { 4179 return out, metadata, awsRestjson1_deserializeOpErrorGetFacet(response, &metadata) 4180 } 4181 output := &GetFacetOutput{} 4182 out.Result = output 4183 4184 var buff [1024]byte 4185 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4186 4187 body := io.TeeReader(response.Body, ringBuffer) 4188 4189 decoder := json.NewDecoder(body) 4190 decoder.UseNumber() 4191 var shape interface{} 4192 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4193 var snapshot bytes.Buffer 4194 io.Copy(&snapshot, ringBuffer) 4195 err = &smithy.DeserializationError{ 4196 Err: fmt.Errorf("failed to decode response body, %w", err), 4197 Snapshot: snapshot.Bytes(), 4198 } 4199 return out, metadata, err 4200 } 4201 4202 err = awsRestjson1_deserializeOpDocumentGetFacetOutput(&output, shape) 4203 if err != nil { 4204 var snapshot bytes.Buffer 4205 io.Copy(&snapshot, ringBuffer) 4206 return out, metadata, &smithy.DeserializationError{ 4207 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 4208 Snapshot: snapshot.Bytes(), 4209 } 4210 } 4211 4212 return out, metadata, err 4213} 4214 4215func awsRestjson1_deserializeOpErrorGetFacet(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4216 var errorBuffer bytes.Buffer 4217 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4218 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4219 } 4220 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4221 4222 errorCode := "UnknownError" 4223 errorMessage := errorCode 4224 4225 code := response.Header.Get("X-Amzn-ErrorType") 4226 if len(code) != 0 { 4227 errorCode = restjson.SanitizeErrorCode(code) 4228 } 4229 4230 var buff [1024]byte 4231 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4232 4233 body := io.TeeReader(errorBody, ringBuffer) 4234 decoder := json.NewDecoder(body) 4235 decoder.UseNumber() 4236 code, message, err := restjson.GetErrorInfo(decoder) 4237 if err != nil { 4238 var snapshot bytes.Buffer 4239 io.Copy(&snapshot, ringBuffer) 4240 err = &smithy.DeserializationError{ 4241 Err: fmt.Errorf("failed to decode response body, %w", err), 4242 Snapshot: snapshot.Bytes(), 4243 } 4244 return err 4245 } 4246 4247 errorBody.Seek(0, io.SeekStart) 4248 if len(code) != 0 { 4249 errorCode = restjson.SanitizeErrorCode(code) 4250 } 4251 if len(message) != 0 { 4252 errorMessage = message 4253 } 4254 4255 switch { 4256 case strings.EqualFold("AccessDeniedException", errorCode): 4257 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 4258 4259 case strings.EqualFold("FacetNotFoundException", errorCode): 4260 return awsRestjson1_deserializeErrorFacetNotFoundException(response, errorBody) 4261 4262 case strings.EqualFold("InternalServiceException", errorCode): 4263 return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody) 4264 4265 case strings.EqualFold("InvalidArnException", errorCode): 4266 return awsRestjson1_deserializeErrorInvalidArnException(response, errorBody) 4267 4268 case strings.EqualFold("LimitExceededException", errorCode): 4269 return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody) 4270 4271 case strings.EqualFold("ResourceNotFoundException", errorCode): 4272 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 4273 4274 case strings.EqualFold("RetryableConflictException", errorCode): 4275 return awsRestjson1_deserializeErrorRetryableConflictException(response, errorBody) 4276 4277 case strings.EqualFold("ValidationException", errorCode): 4278 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 4279 4280 default: 4281 genericError := &smithy.GenericAPIError{ 4282 Code: errorCode, 4283 Message: errorMessage, 4284 } 4285 return genericError 4286 4287 } 4288} 4289 4290func awsRestjson1_deserializeOpDocumentGetFacetOutput(v **GetFacetOutput, value interface{}) error { 4291 if v == nil { 4292 return fmt.Errorf("unexpected nil of type %T", v) 4293 } 4294 if value == nil { 4295 return nil 4296 } 4297 4298 shape, ok := value.(map[string]interface{}) 4299 if !ok { 4300 return fmt.Errorf("unexpected JSON type %v", value) 4301 } 4302 4303 var sv *GetFacetOutput 4304 if *v == nil { 4305 sv = &GetFacetOutput{} 4306 } else { 4307 sv = *v 4308 } 4309 4310 for key, value := range shape { 4311 switch key { 4312 case "Facet": 4313 if err := awsRestjson1_deserializeDocumentFacet(&sv.Facet, value); err != nil { 4314 return err 4315 } 4316 4317 default: 4318 _, _ = key, value 4319 4320 } 4321 } 4322 *v = sv 4323 return nil 4324} 4325 4326type awsRestjson1_deserializeOpGetLinkAttributes struct { 4327} 4328 4329func (*awsRestjson1_deserializeOpGetLinkAttributes) ID() string { 4330 return "OperationDeserializer" 4331} 4332 4333func (m *awsRestjson1_deserializeOpGetLinkAttributes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4334 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4335) { 4336 out, metadata, err = next.HandleDeserialize(ctx, in) 4337 if err != nil { 4338 return out, metadata, err 4339 } 4340 4341 response, ok := out.RawResponse.(*smithyhttp.Response) 4342 if !ok { 4343 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4344 } 4345 4346 if response.StatusCode < 200 || response.StatusCode >= 300 { 4347 return out, metadata, awsRestjson1_deserializeOpErrorGetLinkAttributes(response, &metadata) 4348 } 4349 output := &GetLinkAttributesOutput{} 4350 out.Result = output 4351 4352 var buff [1024]byte 4353 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4354 4355 body := io.TeeReader(response.Body, ringBuffer) 4356 4357 decoder := json.NewDecoder(body) 4358 decoder.UseNumber() 4359 var shape interface{} 4360 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4361 var snapshot bytes.Buffer 4362 io.Copy(&snapshot, ringBuffer) 4363 err = &smithy.DeserializationError{ 4364 Err: fmt.Errorf("failed to decode response body, %w", err), 4365 Snapshot: snapshot.Bytes(), 4366 } 4367 return out, metadata, err 4368 } 4369 4370 err = awsRestjson1_deserializeOpDocumentGetLinkAttributesOutput(&output, shape) 4371 if err != nil { 4372 var snapshot bytes.Buffer 4373 io.Copy(&snapshot, ringBuffer) 4374 return out, metadata, &smithy.DeserializationError{ 4375 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 4376 Snapshot: snapshot.Bytes(), 4377 } 4378 } 4379 4380 return out, metadata, err 4381} 4382 4383func awsRestjson1_deserializeOpErrorGetLinkAttributes(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4384 var errorBuffer bytes.Buffer 4385 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4386 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4387 } 4388 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4389 4390 errorCode := "UnknownError" 4391 errorMessage := errorCode 4392 4393 code := response.Header.Get("X-Amzn-ErrorType") 4394 if len(code) != 0 { 4395 errorCode = restjson.SanitizeErrorCode(code) 4396 } 4397 4398 var buff [1024]byte 4399 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4400 4401 body := io.TeeReader(errorBody, ringBuffer) 4402 decoder := json.NewDecoder(body) 4403 decoder.UseNumber() 4404 code, message, err := restjson.GetErrorInfo(decoder) 4405 if err != nil { 4406 var snapshot bytes.Buffer 4407 io.Copy(&snapshot, ringBuffer) 4408 err = &smithy.DeserializationError{ 4409 Err: fmt.Errorf("failed to decode response body, %w", err), 4410 Snapshot: snapshot.Bytes(), 4411 } 4412 return err 4413 } 4414 4415 errorBody.Seek(0, io.SeekStart) 4416 if len(code) != 0 { 4417 errorCode = restjson.SanitizeErrorCode(code) 4418 } 4419 if len(message) != 0 { 4420 errorMessage = message 4421 } 4422 4423 switch { 4424 case strings.EqualFold("AccessDeniedException", errorCode): 4425 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 4426 4427 case strings.EqualFold("DirectoryNotEnabledException", errorCode): 4428 return awsRestjson1_deserializeErrorDirectoryNotEnabledException(response, errorBody) 4429 4430 case strings.EqualFold("FacetValidationException", errorCode): 4431 return awsRestjson1_deserializeErrorFacetValidationException(response, errorBody) 4432 4433 case strings.EqualFold("InternalServiceException", errorCode): 4434 return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody) 4435 4436 case strings.EqualFold("InvalidArnException", errorCode): 4437 return awsRestjson1_deserializeErrorInvalidArnException(response, errorBody) 4438 4439 case strings.EqualFold("LimitExceededException", errorCode): 4440 return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody) 4441 4442 case strings.EqualFold("ResourceNotFoundException", errorCode): 4443 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 4444 4445 case strings.EqualFold("RetryableConflictException", errorCode): 4446 return awsRestjson1_deserializeErrorRetryableConflictException(response, errorBody) 4447 4448 case strings.EqualFold("ValidationException", errorCode): 4449 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 4450 4451 default: 4452 genericError := &smithy.GenericAPIError{ 4453 Code: errorCode, 4454 Message: errorMessage, 4455 } 4456 return genericError 4457 4458 } 4459} 4460 4461func awsRestjson1_deserializeOpDocumentGetLinkAttributesOutput(v **GetLinkAttributesOutput, value interface{}) error { 4462 if v == nil { 4463 return fmt.Errorf("unexpected nil of type %T", v) 4464 } 4465 if value == nil { 4466 return nil 4467 } 4468 4469 shape, ok := value.(map[string]interface{}) 4470 if !ok { 4471 return fmt.Errorf("unexpected JSON type %v", value) 4472 } 4473 4474 var sv *GetLinkAttributesOutput 4475 if *v == nil { 4476 sv = &GetLinkAttributesOutput{} 4477 } else { 4478 sv = *v 4479 } 4480 4481 for key, value := range shape { 4482 switch key { 4483 case "Attributes": 4484 if err := awsRestjson1_deserializeDocumentAttributeKeyAndValueList(&sv.Attributes, value); err != nil { 4485 return err 4486 } 4487 4488 default: 4489 _, _ = key, value 4490 4491 } 4492 } 4493 *v = sv 4494 return nil 4495} 4496 4497type awsRestjson1_deserializeOpGetObjectAttributes struct { 4498} 4499 4500func (*awsRestjson1_deserializeOpGetObjectAttributes) ID() string { 4501 return "OperationDeserializer" 4502} 4503 4504func (m *awsRestjson1_deserializeOpGetObjectAttributes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4505 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4506) { 4507 out, metadata, err = next.HandleDeserialize(ctx, in) 4508 if err != nil { 4509 return out, metadata, err 4510 } 4511 4512 response, ok := out.RawResponse.(*smithyhttp.Response) 4513 if !ok { 4514 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4515 } 4516 4517 if response.StatusCode < 200 || response.StatusCode >= 300 { 4518 return out, metadata, awsRestjson1_deserializeOpErrorGetObjectAttributes(response, &metadata) 4519 } 4520 output := &GetObjectAttributesOutput{} 4521 out.Result = output 4522 4523 var buff [1024]byte 4524 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4525 4526 body := io.TeeReader(response.Body, ringBuffer) 4527 4528 decoder := json.NewDecoder(body) 4529 decoder.UseNumber() 4530 var shape interface{} 4531 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4532 var snapshot bytes.Buffer 4533 io.Copy(&snapshot, ringBuffer) 4534 err = &smithy.DeserializationError{ 4535 Err: fmt.Errorf("failed to decode response body, %w", err), 4536 Snapshot: snapshot.Bytes(), 4537 } 4538 return out, metadata, err 4539 } 4540 4541 err = awsRestjson1_deserializeOpDocumentGetObjectAttributesOutput(&output, shape) 4542 if err != nil { 4543 var snapshot bytes.Buffer 4544 io.Copy(&snapshot, ringBuffer) 4545 return out, metadata, &smithy.DeserializationError{ 4546 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 4547 Snapshot: snapshot.Bytes(), 4548 } 4549 } 4550 4551 return out, metadata, err 4552} 4553 4554func awsRestjson1_deserializeOpErrorGetObjectAttributes(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4555 var errorBuffer bytes.Buffer 4556 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4557 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4558 } 4559 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4560 4561 errorCode := "UnknownError" 4562 errorMessage := errorCode 4563 4564 code := response.Header.Get("X-Amzn-ErrorType") 4565 if len(code) != 0 { 4566 errorCode = restjson.SanitizeErrorCode(code) 4567 } 4568 4569 var buff [1024]byte 4570 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4571 4572 body := io.TeeReader(errorBody, ringBuffer) 4573 decoder := json.NewDecoder(body) 4574 decoder.UseNumber() 4575 code, message, err := restjson.GetErrorInfo(decoder) 4576 if err != nil { 4577 var snapshot bytes.Buffer 4578 io.Copy(&snapshot, ringBuffer) 4579 err = &smithy.DeserializationError{ 4580 Err: fmt.Errorf("failed to decode response body, %w", err), 4581 Snapshot: snapshot.Bytes(), 4582 } 4583 return err 4584 } 4585 4586 errorBody.Seek(0, io.SeekStart) 4587 if len(code) != 0 { 4588 errorCode = restjson.SanitizeErrorCode(code) 4589 } 4590 if len(message) != 0 { 4591 errorMessage = message 4592 } 4593 4594 switch { 4595 case strings.EqualFold("AccessDeniedException", errorCode): 4596 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 4597 4598 case strings.EqualFold("DirectoryNotEnabledException", errorCode): 4599 return awsRestjson1_deserializeErrorDirectoryNotEnabledException(response, errorBody) 4600 4601 case strings.EqualFold("FacetValidationException", errorCode): 4602 return awsRestjson1_deserializeErrorFacetValidationException(response, errorBody) 4603 4604 case strings.EqualFold("InternalServiceException", errorCode): 4605 return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody) 4606 4607 case strings.EqualFold("InvalidArnException", errorCode): 4608 return awsRestjson1_deserializeErrorInvalidArnException(response, errorBody) 4609 4610 case strings.EqualFold("LimitExceededException", errorCode): 4611 return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody) 4612 4613 case strings.EqualFold("ResourceNotFoundException", errorCode): 4614 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 4615 4616 case strings.EqualFold("RetryableConflictException", errorCode): 4617 return awsRestjson1_deserializeErrorRetryableConflictException(response, errorBody) 4618 4619 case strings.EqualFold("ValidationException", errorCode): 4620 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 4621 4622 default: 4623 genericError := &smithy.GenericAPIError{ 4624 Code: errorCode, 4625 Message: errorMessage, 4626 } 4627 return genericError 4628 4629 } 4630} 4631 4632func awsRestjson1_deserializeOpDocumentGetObjectAttributesOutput(v **GetObjectAttributesOutput, value interface{}) error { 4633 if v == nil { 4634 return fmt.Errorf("unexpected nil of type %T", v) 4635 } 4636 if value == nil { 4637 return nil 4638 } 4639 4640 shape, ok := value.(map[string]interface{}) 4641 if !ok { 4642 return fmt.Errorf("unexpected JSON type %v", value) 4643 } 4644 4645 var sv *GetObjectAttributesOutput 4646 if *v == nil { 4647 sv = &GetObjectAttributesOutput{} 4648 } else { 4649 sv = *v 4650 } 4651 4652 for key, value := range shape { 4653 switch key { 4654 case "Attributes": 4655 if err := awsRestjson1_deserializeDocumentAttributeKeyAndValueList(&sv.Attributes, value); err != nil { 4656 return err 4657 } 4658 4659 default: 4660 _, _ = key, value 4661 4662 } 4663 } 4664 *v = sv 4665 return nil 4666} 4667 4668type awsRestjson1_deserializeOpGetObjectInformation struct { 4669} 4670 4671func (*awsRestjson1_deserializeOpGetObjectInformation) ID() string { 4672 return "OperationDeserializer" 4673} 4674 4675func (m *awsRestjson1_deserializeOpGetObjectInformation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4676 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4677) { 4678 out, metadata, err = next.HandleDeserialize(ctx, in) 4679 if err != nil { 4680 return out, metadata, err 4681 } 4682 4683 response, ok := out.RawResponse.(*smithyhttp.Response) 4684 if !ok { 4685 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4686 } 4687 4688 if response.StatusCode < 200 || response.StatusCode >= 300 { 4689 return out, metadata, awsRestjson1_deserializeOpErrorGetObjectInformation(response, &metadata) 4690 } 4691 output := &GetObjectInformationOutput{} 4692 out.Result = output 4693 4694 var buff [1024]byte 4695 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4696 4697 body := io.TeeReader(response.Body, ringBuffer) 4698 4699 decoder := json.NewDecoder(body) 4700 decoder.UseNumber() 4701 var shape interface{} 4702 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4703 var snapshot bytes.Buffer 4704 io.Copy(&snapshot, ringBuffer) 4705 err = &smithy.DeserializationError{ 4706 Err: fmt.Errorf("failed to decode response body, %w", err), 4707 Snapshot: snapshot.Bytes(), 4708 } 4709 return out, metadata, err 4710 } 4711 4712 err = awsRestjson1_deserializeOpDocumentGetObjectInformationOutput(&output, shape) 4713 if err != nil { 4714 var snapshot bytes.Buffer 4715 io.Copy(&snapshot, ringBuffer) 4716 return out, metadata, &smithy.DeserializationError{ 4717 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 4718 Snapshot: snapshot.Bytes(), 4719 } 4720 } 4721 4722 return out, metadata, err 4723} 4724 4725func awsRestjson1_deserializeOpErrorGetObjectInformation(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4726 var errorBuffer bytes.Buffer 4727 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4728 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4729 } 4730 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4731 4732 errorCode := "UnknownError" 4733 errorMessage := errorCode 4734 4735 code := response.Header.Get("X-Amzn-ErrorType") 4736 if len(code) != 0 { 4737 errorCode = restjson.SanitizeErrorCode(code) 4738 } 4739 4740 var buff [1024]byte 4741 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4742 4743 body := io.TeeReader(errorBody, ringBuffer) 4744 decoder := json.NewDecoder(body) 4745 decoder.UseNumber() 4746 code, message, err := restjson.GetErrorInfo(decoder) 4747 if err != nil { 4748 var snapshot bytes.Buffer 4749 io.Copy(&snapshot, ringBuffer) 4750 err = &smithy.DeserializationError{ 4751 Err: fmt.Errorf("failed to decode response body, %w", err), 4752 Snapshot: snapshot.Bytes(), 4753 } 4754 return err 4755 } 4756 4757 errorBody.Seek(0, io.SeekStart) 4758 if len(code) != 0 { 4759 errorCode = restjson.SanitizeErrorCode(code) 4760 } 4761 if len(message) != 0 { 4762 errorMessage = message 4763 } 4764 4765 switch { 4766 case strings.EqualFold("AccessDeniedException", errorCode): 4767 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 4768 4769 case strings.EqualFold("DirectoryNotEnabledException", errorCode): 4770 return awsRestjson1_deserializeErrorDirectoryNotEnabledException(response, errorBody) 4771 4772 case strings.EqualFold("InternalServiceException", errorCode): 4773 return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody) 4774 4775 case strings.EqualFold("InvalidArnException", errorCode): 4776 return awsRestjson1_deserializeErrorInvalidArnException(response, errorBody) 4777 4778 case strings.EqualFold("LimitExceededException", errorCode): 4779 return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody) 4780 4781 case strings.EqualFold("ResourceNotFoundException", errorCode): 4782 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 4783 4784 case strings.EqualFold("RetryableConflictException", errorCode): 4785 return awsRestjson1_deserializeErrorRetryableConflictException(response, errorBody) 4786 4787 case strings.EqualFold("ValidationException", errorCode): 4788 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 4789 4790 default: 4791 genericError := &smithy.GenericAPIError{ 4792 Code: errorCode, 4793 Message: errorMessage, 4794 } 4795 return genericError 4796 4797 } 4798} 4799 4800func awsRestjson1_deserializeOpDocumentGetObjectInformationOutput(v **GetObjectInformationOutput, value interface{}) error { 4801 if v == nil { 4802 return fmt.Errorf("unexpected nil of type %T", v) 4803 } 4804 if value == nil { 4805 return nil 4806 } 4807 4808 shape, ok := value.(map[string]interface{}) 4809 if !ok { 4810 return fmt.Errorf("unexpected JSON type %v", value) 4811 } 4812 4813 var sv *GetObjectInformationOutput 4814 if *v == nil { 4815 sv = &GetObjectInformationOutput{} 4816 } else { 4817 sv = *v 4818 } 4819 4820 for key, value := range shape { 4821 switch key { 4822 case "ObjectIdentifier": 4823 if value != nil { 4824 jtv, ok := value.(string) 4825 if !ok { 4826 return fmt.Errorf("expected ObjectIdentifier to be of type string, got %T instead", value) 4827 } 4828 sv.ObjectIdentifier = ptr.String(jtv) 4829 } 4830 4831 case "SchemaFacets": 4832 if err := awsRestjson1_deserializeDocumentSchemaFacetList(&sv.SchemaFacets, value); err != nil { 4833 return err 4834 } 4835 4836 default: 4837 _, _ = key, value 4838 4839 } 4840 } 4841 *v = sv 4842 return nil 4843} 4844 4845type awsRestjson1_deserializeOpGetSchemaAsJson struct { 4846} 4847 4848func (*awsRestjson1_deserializeOpGetSchemaAsJson) ID() string { 4849 return "OperationDeserializer" 4850} 4851 4852func (m *awsRestjson1_deserializeOpGetSchemaAsJson) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 4853 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 4854) { 4855 out, metadata, err = next.HandleDeserialize(ctx, in) 4856 if err != nil { 4857 return out, metadata, err 4858 } 4859 4860 response, ok := out.RawResponse.(*smithyhttp.Response) 4861 if !ok { 4862 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 4863 } 4864 4865 if response.StatusCode < 200 || response.StatusCode >= 300 { 4866 return out, metadata, awsRestjson1_deserializeOpErrorGetSchemaAsJson(response, &metadata) 4867 } 4868 output := &GetSchemaAsJsonOutput{} 4869 out.Result = output 4870 4871 var buff [1024]byte 4872 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4873 4874 body := io.TeeReader(response.Body, ringBuffer) 4875 4876 decoder := json.NewDecoder(body) 4877 decoder.UseNumber() 4878 var shape interface{} 4879 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 4880 var snapshot bytes.Buffer 4881 io.Copy(&snapshot, ringBuffer) 4882 err = &smithy.DeserializationError{ 4883 Err: fmt.Errorf("failed to decode response body, %w", err), 4884 Snapshot: snapshot.Bytes(), 4885 } 4886 return out, metadata, err 4887 } 4888 4889 err = awsRestjson1_deserializeOpDocumentGetSchemaAsJsonOutput(&output, shape) 4890 if err != nil { 4891 var snapshot bytes.Buffer 4892 io.Copy(&snapshot, ringBuffer) 4893 return out, metadata, &smithy.DeserializationError{ 4894 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 4895 Snapshot: snapshot.Bytes(), 4896 } 4897 } 4898 4899 return out, metadata, err 4900} 4901 4902func awsRestjson1_deserializeOpErrorGetSchemaAsJson(response *smithyhttp.Response, metadata *middleware.Metadata) error { 4903 var errorBuffer bytes.Buffer 4904 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 4905 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 4906 } 4907 errorBody := bytes.NewReader(errorBuffer.Bytes()) 4908 4909 errorCode := "UnknownError" 4910 errorMessage := errorCode 4911 4912 code := response.Header.Get("X-Amzn-ErrorType") 4913 if len(code) != 0 { 4914 errorCode = restjson.SanitizeErrorCode(code) 4915 } 4916 4917 var buff [1024]byte 4918 ringBuffer := smithyio.NewRingBuffer(buff[:]) 4919 4920 body := io.TeeReader(errorBody, ringBuffer) 4921 decoder := json.NewDecoder(body) 4922 decoder.UseNumber() 4923 code, message, err := restjson.GetErrorInfo(decoder) 4924 if err != nil { 4925 var snapshot bytes.Buffer 4926 io.Copy(&snapshot, ringBuffer) 4927 err = &smithy.DeserializationError{ 4928 Err: fmt.Errorf("failed to decode response body, %w", err), 4929 Snapshot: snapshot.Bytes(), 4930 } 4931 return err 4932 } 4933 4934 errorBody.Seek(0, io.SeekStart) 4935 if len(code) != 0 { 4936 errorCode = restjson.SanitizeErrorCode(code) 4937 } 4938 if len(message) != 0 { 4939 errorMessage = message 4940 } 4941 4942 switch { 4943 case strings.EqualFold("AccessDeniedException", errorCode): 4944 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 4945 4946 case strings.EqualFold("InternalServiceException", errorCode): 4947 return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody) 4948 4949 case strings.EqualFold("InvalidArnException", errorCode): 4950 return awsRestjson1_deserializeErrorInvalidArnException(response, errorBody) 4951 4952 case strings.EqualFold("LimitExceededException", errorCode): 4953 return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody) 4954 4955 case strings.EqualFold("ResourceNotFoundException", errorCode): 4956 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 4957 4958 case strings.EqualFold("RetryableConflictException", errorCode): 4959 return awsRestjson1_deserializeErrorRetryableConflictException(response, errorBody) 4960 4961 case strings.EqualFold("ValidationException", errorCode): 4962 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 4963 4964 default: 4965 genericError := &smithy.GenericAPIError{ 4966 Code: errorCode, 4967 Message: errorMessage, 4968 } 4969 return genericError 4970 4971 } 4972} 4973 4974func awsRestjson1_deserializeOpDocumentGetSchemaAsJsonOutput(v **GetSchemaAsJsonOutput, value interface{}) error { 4975 if v == nil { 4976 return fmt.Errorf("unexpected nil of type %T", v) 4977 } 4978 if value == nil { 4979 return nil 4980 } 4981 4982 shape, ok := value.(map[string]interface{}) 4983 if !ok { 4984 return fmt.Errorf("unexpected JSON type %v", value) 4985 } 4986 4987 var sv *GetSchemaAsJsonOutput 4988 if *v == nil { 4989 sv = &GetSchemaAsJsonOutput{} 4990 } else { 4991 sv = *v 4992 } 4993 4994 for key, value := range shape { 4995 switch key { 4996 case "Document": 4997 if value != nil { 4998 jtv, ok := value.(string) 4999 if !ok { 5000 return fmt.Errorf("expected SchemaJsonDocument to be of type string, got %T instead", value) 5001 } 5002 sv.Document = ptr.String(jtv) 5003 } 5004 5005 case "Name": 5006 if value != nil { 5007 jtv, ok := value.(string) 5008 if !ok { 5009 return fmt.Errorf("expected SchemaName to be of type string, got %T instead", value) 5010 } 5011 sv.Name = ptr.String(jtv) 5012 } 5013 5014 default: 5015 _, _ = key, value 5016 5017 } 5018 } 5019 *v = sv 5020 return nil 5021} 5022 5023type awsRestjson1_deserializeOpGetTypedLinkFacetInformation struct { 5024} 5025 5026func (*awsRestjson1_deserializeOpGetTypedLinkFacetInformation) ID() string { 5027 return "OperationDeserializer" 5028} 5029 5030func (m *awsRestjson1_deserializeOpGetTypedLinkFacetInformation) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5031 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5032) { 5033 out, metadata, err = next.HandleDeserialize(ctx, in) 5034 if err != nil { 5035 return out, metadata, err 5036 } 5037 5038 response, ok := out.RawResponse.(*smithyhttp.Response) 5039 if !ok { 5040 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5041 } 5042 5043 if response.StatusCode < 200 || response.StatusCode >= 300 { 5044 return out, metadata, awsRestjson1_deserializeOpErrorGetTypedLinkFacetInformation(response, &metadata) 5045 } 5046 output := &GetTypedLinkFacetInformationOutput{} 5047 out.Result = output 5048 5049 var buff [1024]byte 5050 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5051 5052 body := io.TeeReader(response.Body, ringBuffer) 5053 5054 decoder := json.NewDecoder(body) 5055 decoder.UseNumber() 5056 var shape interface{} 5057 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5058 var snapshot bytes.Buffer 5059 io.Copy(&snapshot, ringBuffer) 5060 err = &smithy.DeserializationError{ 5061 Err: fmt.Errorf("failed to decode response body, %w", err), 5062 Snapshot: snapshot.Bytes(), 5063 } 5064 return out, metadata, err 5065 } 5066 5067 err = awsRestjson1_deserializeOpDocumentGetTypedLinkFacetInformationOutput(&output, shape) 5068 if err != nil { 5069 var snapshot bytes.Buffer 5070 io.Copy(&snapshot, ringBuffer) 5071 return out, metadata, &smithy.DeserializationError{ 5072 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 5073 Snapshot: snapshot.Bytes(), 5074 } 5075 } 5076 5077 return out, metadata, err 5078} 5079 5080func awsRestjson1_deserializeOpErrorGetTypedLinkFacetInformation(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5081 var errorBuffer bytes.Buffer 5082 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5083 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5084 } 5085 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5086 5087 errorCode := "UnknownError" 5088 errorMessage := errorCode 5089 5090 code := response.Header.Get("X-Amzn-ErrorType") 5091 if len(code) != 0 { 5092 errorCode = restjson.SanitizeErrorCode(code) 5093 } 5094 5095 var buff [1024]byte 5096 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5097 5098 body := io.TeeReader(errorBody, ringBuffer) 5099 decoder := json.NewDecoder(body) 5100 decoder.UseNumber() 5101 code, message, err := restjson.GetErrorInfo(decoder) 5102 if err != nil { 5103 var snapshot bytes.Buffer 5104 io.Copy(&snapshot, ringBuffer) 5105 err = &smithy.DeserializationError{ 5106 Err: fmt.Errorf("failed to decode response body, %w", err), 5107 Snapshot: snapshot.Bytes(), 5108 } 5109 return err 5110 } 5111 5112 errorBody.Seek(0, io.SeekStart) 5113 if len(code) != 0 { 5114 errorCode = restjson.SanitizeErrorCode(code) 5115 } 5116 if len(message) != 0 { 5117 errorMessage = message 5118 } 5119 5120 switch { 5121 case strings.EqualFold("AccessDeniedException", errorCode): 5122 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 5123 5124 case strings.EqualFold("FacetNotFoundException", errorCode): 5125 return awsRestjson1_deserializeErrorFacetNotFoundException(response, errorBody) 5126 5127 case strings.EqualFold("InternalServiceException", errorCode): 5128 return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody) 5129 5130 case strings.EqualFold("InvalidArnException", errorCode): 5131 return awsRestjson1_deserializeErrorInvalidArnException(response, errorBody) 5132 5133 case strings.EqualFold("InvalidNextTokenException", errorCode): 5134 return awsRestjson1_deserializeErrorInvalidNextTokenException(response, errorBody) 5135 5136 case strings.EqualFold("LimitExceededException", errorCode): 5137 return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody) 5138 5139 case strings.EqualFold("ResourceNotFoundException", errorCode): 5140 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 5141 5142 case strings.EqualFold("RetryableConflictException", errorCode): 5143 return awsRestjson1_deserializeErrorRetryableConflictException(response, errorBody) 5144 5145 case strings.EqualFold("ValidationException", errorCode): 5146 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 5147 5148 default: 5149 genericError := &smithy.GenericAPIError{ 5150 Code: errorCode, 5151 Message: errorMessage, 5152 } 5153 return genericError 5154 5155 } 5156} 5157 5158func awsRestjson1_deserializeOpDocumentGetTypedLinkFacetInformationOutput(v **GetTypedLinkFacetInformationOutput, value interface{}) error { 5159 if v == nil { 5160 return fmt.Errorf("unexpected nil of type %T", v) 5161 } 5162 if value == nil { 5163 return nil 5164 } 5165 5166 shape, ok := value.(map[string]interface{}) 5167 if !ok { 5168 return fmt.Errorf("unexpected JSON type %v", value) 5169 } 5170 5171 var sv *GetTypedLinkFacetInformationOutput 5172 if *v == nil { 5173 sv = &GetTypedLinkFacetInformationOutput{} 5174 } else { 5175 sv = *v 5176 } 5177 5178 for key, value := range shape { 5179 switch key { 5180 case "IdentityAttributeOrder": 5181 if err := awsRestjson1_deserializeDocumentAttributeNameList(&sv.IdentityAttributeOrder, value); err != nil { 5182 return err 5183 } 5184 5185 default: 5186 _, _ = key, value 5187 5188 } 5189 } 5190 *v = sv 5191 return nil 5192} 5193 5194type awsRestjson1_deserializeOpListAppliedSchemaArns struct { 5195} 5196 5197func (*awsRestjson1_deserializeOpListAppliedSchemaArns) ID() string { 5198 return "OperationDeserializer" 5199} 5200 5201func (m *awsRestjson1_deserializeOpListAppliedSchemaArns) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5202 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5203) { 5204 out, metadata, err = next.HandleDeserialize(ctx, in) 5205 if err != nil { 5206 return out, metadata, err 5207 } 5208 5209 response, ok := out.RawResponse.(*smithyhttp.Response) 5210 if !ok { 5211 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5212 } 5213 5214 if response.StatusCode < 200 || response.StatusCode >= 300 { 5215 return out, metadata, awsRestjson1_deserializeOpErrorListAppliedSchemaArns(response, &metadata) 5216 } 5217 output := &ListAppliedSchemaArnsOutput{} 5218 out.Result = output 5219 5220 var buff [1024]byte 5221 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5222 5223 body := io.TeeReader(response.Body, ringBuffer) 5224 5225 decoder := json.NewDecoder(body) 5226 decoder.UseNumber() 5227 var shape interface{} 5228 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5229 var snapshot bytes.Buffer 5230 io.Copy(&snapshot, ringBuffer) 5231 err = &smithy.DeserializationError{ 5232 Err: fmt.Errorf("failed to decode response body, %w", err), 5233 Snapshot: snapshot.Bytes(), 5234 } 5235 return out, metadata, err 5236 } 5237 5238 err = awsRestjson1_deserializeOpDocumentListAppliedSchemaArnsOutput(&output, shape) 5239 if err != nil { 5240 var snapshot bytes.Buffer 5241 io.Copy(&snapshot, ringBuffer) 5242 return out, metadata, &smithy.DeserializationError{ 5243 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 5244 Snapshot: snapshot.Bytes(), 5245 } 5246 } 5247 5248 return out, metadata, err 5249} 5250 5251func awsRestjson1_deserializeOpErrorListAppliedSchemaArns(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5252 var errorBuffer bytes.Buffer 5253 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5254 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5255 } 5256 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5257 5258 errorCode := "UnknownError" 5259 errorMessage := errorCode 5260 5261 code := response.Header.Get("X-Amzn-ErrorType") 5262 if len(code) != 0 { 5263 errorCode = restjson.SanitizeErrorCode(code) 5264 } 5265 5266 var buff [1024]byte 5267 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5268 5269 body := io.TeeReader(errorBody, ringBuffer) 5270 decoder := json.NewDecoder(body) 5271 decoder.UseNumber() 5272 code, message, err := restjson.GetErrorInfo(decoder) 5273 if err != nil { 5274 var snapshot bytes.Buffer 5275 io.Copy(&snapshot, ringBuffer) 5276 err = &smithy.DeserializationError{ 5277 Err: fmt.Errorf("failed to decode response body, %w", err), 5278 Snapshot: snapshot.Bytes(), 5279 } 5280 return err 5281 } 5282 5283 errorBody.Seek(0, io.SeekStart) 5284 if len(code) != 0 { 5285 errorCode = restjson.SanitizeErrorCode(code) 5286 } 5287 if len(message) != 0 { 5288 errorMessage = message 5289 } 5290 5291 switch { 5292 case strings.EqualFold("AccessDeniedException", errorCode): 5293 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 5294 5295 case strings.EqualFold("InternalServiceException", errorCode): 5296 return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody) 5297 5298 case strings.EqualFold("InvalidArnException", errorCode): 5299 return awsRestjson1_deserializeErrorInvalidArnException(response, errorBody) 5300 5301 case strings.EqualFold("InvalidNextTokenException", errorCode): 5302 return awsRestjson1_deserializeErrorInvalidNextTokenException(response, errorBody) 5303 5304 case strings.EqualFold("LimitExceededException", errorCode): 5305 return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody) 5306 5307 case strings.EqualFold("ResourceNotFoundException", errorCode): 5308 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 5309 5310 case strings.EqualFold("RetryableConflictException", errorCode): 5311 return awsRestjson1_deserializeErrorRetryableConflictException(response, errorBody) 5312 5313 case strings.EqualFold("ValidationException", errorCode): 5314 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 5315 5316 default: 5317 genericError := &smithy.GenericAPIError{ 5318 Code: errorCode, 5319 Message: errorMessage, 5320 } 5321 return genericError 5322 5323 } 5324} 5325 5326func awsRestjson1_deserializeOpDocumentListAppliedSchemaArnsOutput(v **ListAppliedSchemaArnsOutput, value interface{}) error { 5327 if v == nil { 5328 return fmt.Errorf("unexpected nil of type %T", v) 5329 } 5330 if value == nil { 5331 return nil 5332 } 5333 5334 shape, ok := value.(map[string]interface{}) 5335 if !ok { 5336 return fmt.Errorf("unexpected JSON type %v", value) 5337 } 5338 5339 var sv *ListAppliedSchemaArnsOutput 5340 if *v == nil { 5341 sv = &ListAppliedSchemaArnsOutput{} 5342 } else { 5343 sv = *v 5344 } 5345 5346 for key, value := range shape { 5347 switch key { 5348 case "NextToken": 5349 if value != nil { 5350 jtv, ok := value.(string) 5351 if !ok { 5352 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 5353 } 5354 sv.NextToken = ptr.String(jtv) 5355 } 5356 5357 case "SchemaArns": 5358 if err := awsRestjson1_deserializeDocumentArns(&sv.SchemaArns, value); err != nil { 5359 return err 5360 } 5361 5362 default: 5363 _, _ = key, value 5364 5365 } 5366 } 5367 *v = sv 5368 return nil 5369} 5370 5371type awsRestjson1_deserializeOpListAttachedIndices struct { 5372} 5373 5374func (*awsRestjson1_deserializeOpListAttachedIndices) ID() string { 5375 return "OperationDeserializer" 5376} 5377 5378func (m *awsRestjson1_deserializeOpListAttachedIndices) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5379 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5380) { 5381 out, metadata, err = next.HandleDeserialize(ctx, in) 5382 if err != nil { 5383 return out, metadata, err 5384 } 5385 5386 response, ok := out.RawResponse.(*smithyhttp.Response) 5387 if !ok { 5388 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5389 } 5390 5391 if response.StatusCode < 200 || response.StatusCode >= 300 { 5392 return out, metadata, awsRestjson1_deserializeOpErrorListAttachedIndices(response, &metadata) 5393 } 5394 output := &ListAttachedIndicesOutput{} 5395 out.Result = output 5396 5397 var buff [1024]byte 5398 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5399 5400 body := io.TeeReader(response.Body, ringBuffer) 5401 5402 decoder := json.NewDecoder(body) 5403 decoder.UseNumber() 5404 var shape interface{} 5405 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5406 var snapshot bytes.Buffer 5407 io.Copy(&snapshot, ringBuffer) 5408 err = &smithy.DeserializationError{ 5409 Err: fmt.Errorf("failed to decode response body, %w", err), 5410 Snapshot: snapshot.Bytes(), 5411 } 5412 return out, metadata, err 5413 } 5414 5415 err = awsRestjson1_deserializeOpDocumentListAttachedIndicesOutput(&output, shape) 5416 if err != nil { 5417 var snapshot bytes.Buffer 5418 io.Copy(&snapshot, ringBuffer) 5419 return out, metadata, &smithy.DeserializationError{ 5420 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 5421 Snapshot: snapshot.Bytes(), 5422 } 5423 } 5424 5425 return out, metadata, err 5426} 5427 5428func awsRestjson1_deserializeOpErrorListAttachedIndices(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5429 var errorBuffer bytes.Buffer 5430 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5431 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5432 } 5433 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5434 5435 errorCode := "UnknownError" 5436 errorMessage := errorCode 5437 5438 code := response.Header.Get("X-Amzn-ErrorType") 5439 if len(code) != 0 { 5440 errorCode = restjson.SanitizeErrorCode(code) 5441 } 5442 5443 var buff [1024]byte 5444 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5445 5446 body := io.TeeReader(errorBody, ringBuffer) 5447 decoder := json.NewDecoder(body) 5448 decoder.UseNumber() 5449 code, message, err := restjson.GetErrorInfo(decoder) 5450 if err != nil { 5451 var snapshot bytes.Buffer 5452 io.Copy(&snapshot, ringBuffer) 5453 err = &smithy.DeserializationError{ 5454 Err: fmt.Errorf("failed to decode response body, %w", err), 5455 Snapshot: snapshot.Bytes(), 5456 } 5457 return err 5458 } 5459 5460 errorBody.Seek(0, io.SeekStart) 5461 if len(code) != 0 { 5462 errorCode = restjson.SanitizeErrorCode(code) 5463 } 5464 if len(message) != 0 { 5465 errorMessage = message 5466 } 5467 5468 switch { 5469 case strings.EqualFold("AccessDeniedException", errorCode): 5470 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 5471 5472 case strings.EqualFold("DirectoryNotEnabledException", errorCode): 5473 return awsRestjson1_deserializeErrorDirectoryNotEnabledException(response, errorBody) 5474 5475 case strings.EqualFold("InternalServiceException", errorCode): 5476 return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody) 5477 5478 case strings.EqualFold("InvalidArnException", errorCode): 5479 return awsRestjson1_deserializeErrorInvalidArnException(response, errorBody) 5480 5481 case strings.EqualFold("LimitExceededException", errorCode): 5482 return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody) 5483 5484 case strings.EqualFold("ResourceNotFoundException", errorCode): 5485 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 5486 5487 case strings.EqualFold("RetryableConflictException", errorCode): 5488 return awsRestjson1_deserializeErrorRetryableConflictException(response, errorBody) 5489 5490 case strings.EqualFold("ValidationException", errorCode): 5491 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 5492 5493 default: 5494 genericError := &smithy.GenericAPIError{ 5495 Code: errorCode, 5496 Message: errorMessage, 5497 } 5498 return genericError 5499 5500 } 5501} 5502 5503func awsRestjson1_deserializeOpDocumentListAttachedIndicesOutput(v **ListAttachedIndicesOutput, value interface{}) error { 5504 if v == nil { 5505 return fmt.Errorf("unexpected nil of type %T", v) 5506 } 5507 if value == nil { 5508 return nil 5509 } 5510 5511 shape, ok := value.(map[string]interface{}) 5512 if !ok { 5513 return fmt.Errorf("unexpected JSON type %v", value) 5514 } 5515 5516 var sv *ListAttachedIndicesOutput 5517 if *v == nil { 5518 sv = &ListAttachedIndicesOutput{} 5519 } else { 5520 sv = *v 5521 } 5522 5523 for key, value := range shape { 5524 switch key { 5525 case "IndexAttachments": 5526 if err := awsRestjson1_deserializeDocumentIndexAttachmentList(&sv.IndexAttachments, value); err != nil { 5527 return err 5528 } 5529 5530 case "NextToken": 5531 if value != nil { 5532 jtv, ok := value.(string) 5533 if !ok { 5534 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 5535 } 5536 sv.NextToken = ptr.String(jtv) 5537 } 5538 5539 default: 5540 _, _ = key, value 5541 5542 } 5543 } 5544 *v = sv 5545 return nil 5546} 5547 5548type awsRestjson1_deserializeOpListDevelopmentSchemaArns struct { 5549} 5550 5551func (*awsRestjson1_deserializeOpListDevelopmentSchemaArns) ID() string { 5552 return "OperationDeserializer" 5553} 5554 5555func (m *awsRestjson1_deserializeOpListDevelopmentSchemaArns) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5556 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5557) { 5558 out, metadata, err = next.HandleDeserialize(ctx, in) 5559 if err != nil { 5560 return out, metadata, err 5561 } 5562 5563 response, ok := out.RawResponse.(*smithyhttp.Response) 5564 if !ok { 5565 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5566 } 5567 5568 if response.StatusCode < 200 || response.StatusCode >= 300 { 5569 return out, metadata, awsRestjson1_deserializeOpErrorListDevelopmentSchemaArns(response, &metadata) 5570 } 5571 output := &ListDevelopmentSchemaArnsOutput{} 5572 out.Result = output 5573 5574 var buff [1024]byte 5575 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5576 5577 body := io.TeeReader(response.Body, ringBuffer) 5578 5579 decoder := json.NewDecoder(body) 5580 decoder.UseNumber() 5581 var shape interface{} 5582 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5583 var snapshot bytes.Buffer 5584 io.Copy(&snapshot, ringBuffer) 5585 err = &smithy.DeserializationError{ 5586 Err: fmt.Errorf("failed to decode response body, %w", err), 5587 Snapshot: snapshot.Bytes(), 5588 } 5589 return out, metadata, err 5590 } 5591 5592 err = awsRestjson1_deserializeOpDocumentListDevelopmentSchemaArnsOutput(&output, shape) 5593 if err != nil { 5594 var snapshot bytes.Buffer 5595 io.Copy(&snapshot, ringBuffer) 5596 return out, metadata, &smithy.DeserializationError{ 5597 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 5598 Snapshot: snapshot.Bytes(), 5599 } 5600 } 5601 5602 return out, metadata, err 5603} 5604 5605func awsRestjson1_deserializeOpErrorListDevelopmentSchemaArns(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5606 var errorBuffer bytes.Buffer 5607 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5608 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5609 } 5610 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5611 5612 errorCode := "UnknownError" 5613 errorMessage := errorCode 5614 5615 code := response.Header.Get("X-Amzn-ErrorType") 5616 if len(code) != 0 { 5617 errorCode = restjson.SanitizeErrorCode(code) 5618 } 5619 5620 var buff [1024]byte 5621 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5622 5623 body := io.TeeReader(errorBody, ringBuffer) 5624 decoder := json.NewDecoder(body) 5625 decoder.UseNumber() 5626 code, message, err := restjson.GetErrorInfo(decoder) 5627 if err != nil { 5628 var snapshot bytes.Buffer 5629 io.Copy(&snapshot, ringBuffer) 5630 err = &smithy.DeserializationError{ 5631 Err: fmt.Errorf("failed to decode response body, %w", err), 5632 Snapshot: snapshot.Bytes(), 5633 } 5634 return err 5635 } 5636 5637 errorBody.Seek(0, io.SeekStart) 5638 if len(code) != 0 { 5639 errorCode = restjson.SanitizeErrorCode(code) 5640 } 5641 if len(message) != 0 { 5642 errorMessage = message 5643 } 5644 5645 switch { 5646 case strings.EqualFold("AccessDeniedException", errorCode): 5647 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 5648 5649 case strings.EqualFold("InternalServiceException", errorCode): 5650 return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody) 5651 5652 case strings.EqualFold("InvalidArnException", errorCode): 5653 return awsRestjson1_deserializeErrorInvalidArnException(response, errorBody) 5654 5655 case strings.EqualFold("InvalidNextTokenException", errorCode): 5656 return awsRestjson1_deserializeErrorInvalidNextTokenException(response, errorBody) 5657 5658 case strings.EqualFold("LimitExceededException", errorCode): 5659 return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody) 5660 5661 case strings.EqualFold("ResourceNotFoundException", errorCode): 5662 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 5663 5664 case strings.EqualFold("RetryableConflictException", errorCode): 5665 return awsRestjson1_deserializeErrorRetryableConflictException(response, errorBody) 5666 5667 case strings.EqualFold("ValidationException", errorCode): 5668 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 5669 5670 default: 5671 genericError := &smithy.GenericAPIError{ 5672 Code: errorCode, 5673 Message: errorMessage, 5674 } 5675 return genericError 5676 5677 } 5678} 5679 5680func awsRestjson1_deserializeOpDocumentListDevelopmentSchemaArnsOutput(v **ListDevelopmentSchemaArnsOutput, value interface{}) error { 5681 if v == nil { 5682 return fmt.Errorf("unexpected nil of type %T", v) 5683 } 5684 if value == nil { 5685 return nil 5686 } 5687 5688 shape, ok := value.(map[string]interface{}) 5689 if !ok { 5690 return fmt.Errorf("unexpected JSON type %v", value) 5691 } 5692 5693 var sv *ListDevelopmentSchemaArnsOutput 5694 if *v == nil { 5695 sv = &ListDevelopmentSchemaArnsOutput{} 5696 } else { 5697 sv = *v 5698 } 5699 5700 for key, value := range shape { 5701 switch key { 5702 case "NextToken": 5703 if value != nil { 5704 jtv, ok := value.(string) 5705 if !ok { 5706 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 5707 } 5708 sv.NextToken = ptr.String(jtv) 5709 } 5710 5711 case "SchemaArns": 5712 if err := awsRestjson1_deserializeDocumentArns(&sv.SchemaArns, value); err != nil { 5713 return err 5714 } 5715 5716 default: 5717 _, _ = key, value 5718 5719 } 5720 } 5721 *v = sv 5722 return nil 5723} 5724 5725type awsRestjson1_deserializeOpListDirectories struct { 5726} 5727 5728func (*awsRestjson1_deserializeOpListDirectories) ID() string { 5729 return "OperationDeserializer" 5730} 5731 5732func (m *awsRestjson1_deserializeOpListDirectories) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5733 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5734) { 5735 out, metadata, err = next.HandleDeserialize(ctx, in) 5736 if err != nil { 5737 return out, metadata, err 5738 } 5739 5740 response, ok := out.RawResponse.(*smithyhttp.Response) 5741 if !ok { 5742 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5743 } 5744 5745 if response.StatusCode < 200 || response.StatusCode >= 300 { 5746 return out, metadata, awsRestjson1_deserializeOpErrorListDirectories(response, &metadata) 5747 } 5748 output := &ListDirectoriesOutput{} 5749 out.Result = output 5750 5751 var buff [1024]byte 5752 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5753 5754 body := io.TeeReader(response.Body, ringBuffer) 5755 5756 decoder := json.NewDecoder(body) 5757 decoder.UseNumber() 5758 var shape interface{} 5759 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5760 var snapshot bytes.Buffer 5761 io.Copy(&snapshot, ringBuffer) 5762 err = &smithy.DeserializationError{ 5763 Err: fmt.Errorf("failed to decode response body, %w", err), 5764 Snapshot: snapshot.Bytes(), 5765 } 5766 return out, metadata, err 5767 } 5768 5769 err = awsRestjson1_deserializeOpDocumentListDirectoriesOutput(&output, shape) 5770 if err != nil { 5771 var snapshot bytes.Buffer 5772 io.Copy(&snapshot, ringBuffer) 5773 return out, metadata, &smithy.DeserializationError{ 5774 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 5775 Snapshot: snapshot.Bytes(), 5776 } 5777 } 5778 5779 return out, metadata, err 5780} 5781 5782func awsRestjson1_deserializeOpErrorListDirectories(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5783 var errorBuffer bytes.Buffer 5784 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5785 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5786 } 5787 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5788 5789 errorCode := "UnknownError" 5790 errorMessage := errorCode 5791 5792 code := response.Header.Get("X-Amzn-ErrorType") 5793 if len(code) != 0 { 5794 errorCode = restjson.SanitizeErrorCode(code) 5795 } 5796 5797 var buff [1024]byte 5798 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5799 5800 body := io.TeeReader(errorBody, ringBuffer) 5801 decoder := json.NewDecoder(body) 5802 decoder.UseNumber() 5803 code, message, err := restjson.GetErrorInfo(decoder) 5804 if err != nil { 5805 var snapshot bytes.Buffer 5806 io.Copy(&snapshot, ringBuffer) 5807 err = &smithy.DeserializationError{ 5808 Err: fmt.Errorf("failed to decode response body, %w", err), 5809 Snapshot: snapshot.Bytes(), 5810 } 5811 return err 5812 } 5813 5814 errorBody.Seek(0, io.SeekStart) 5815 if len(code) != 0 { 5816 errorCode = restjson.SanitizeErrorCode(code) 5817 } 5818 if len(message) != 0 { 5819 errorMessage = message 5820 } 5821 5822 switch { 5823 case strings.EqualFold("AccessDeniedException", errorCode): 5824 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 5825 5826 case strings.EqualFold("InternalServiceException", errorCode): 5827 return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody) 5828 5829 case strings.EqualFold("InvalidArnException", errorCode): 5830 return awsRestjson1_deserializeErrorInvalidArnException(response, errorBody) 5831 5832 case strings.EqualFold("InvalidNextTokenException", errorCode): 5833 return awsRestjson1_deserializeErrorInvalidNextTokenException(response, errorBody) 5834 5835 case strings.EqualFold("LimitExceededException", errorCode): 5836 return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody) 5837 5838 case strings.EqualFold("RetryableConflictException", errorCode): 5839 return awsRestjson1_deserializeErrorRetryableConflictException(response, errorBody) 5840 5841 case strings.EqualFold("ValidationException", errorCode): 5842 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 5843 5844 default: 5845 genericError := &smithy.GenericAPIError{ 5846 Code: errorCode, 5847 Message: errorMessage, 5848 } 5849 return genericError 5850 5851 } 5852} 5853 5854func awsRestjson1_deserializeOpDocumentListDirectoriesOutput(v **ListDirectoriesOutput, value interface{}) error { 5855 if v == nil { 5856 return fmt.Errorf("unexpected nil of type %T", v) 5857 } 5858 if value == nil { 5859 return nil 5860 } 5861 5862 shape, ok := value.(map[string]interface{}) 5863 if !ok { 5864 return fmt.Errorf("unexpected JSON type %v", value) 5865 } 5866 5867 var sv *ListDirectoriesOutput 5868 if *v == nil { 5869 sv = &ListDirectoriesOutput{} 5870 } else { 5871 sv = *v 5872 } 5873 5874 for key, value := range shape { 5875 switch key { 5876 case "Directories": 5877 if err := awsRestjson1_deserializeDocumentDirectoryList(&sv.Directories, value); err != nil { 5878 return err 5879 } 5880 5881 case "NextToken": 5882 if value != nil { 5883 jtv, ok := value.(string) 5884 if !ok { 5885 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 5886 } 5887 sv.NextToken = ptr.String(jtv) 5888 } 5889 5890 default: 5891 _, _ = key, value 5892 5893 } 5894 } 5895 *v = sv 5896 return nil 5897} 5898 5899type awsRestjson1_deserializeOpListFacetAttributes struct { 5900} 5901 5902func (*awsRestjson1_deserializeOpListFacetAttributes) ID() string { 5903 return "OperationDeserializer" 5904} 5905 5906func (m *awsRestjson1_deserializeOpListFacetAttributes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 5907 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 5908) { 5909 out, metadata, err = next.HandleDeserialize(ctx, in) 5910 if err != nil { 5911 return out, metadata, err 5912 } 5913 5914 response, ok := out.RawResponse.(*smithyhttp.Response) 5915 if !ok { 5916 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 5917 } 5918 5919 if response.StatusCode < 200 || response.StatusCode >= 300 { 5920 return out, metadata, awsRestjson1_deserializeOpErrorListFacetAttributes(response, &metadata) 5921 } 5922 output := &ListFacetAttributesOutput{} 5923 out.Result = output 5924 5925 var buff [1024]byte 5926 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5927 5928 body := io.TeeReader(response.Body, ringBuffer) 5929 5930 decoder := json.NewDecoder(body) 5931 decoder.UseNumber() 5932 var shape interface{} 5933 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 5934 var snapshot bytes.Buffer 5935 io.Copy(&snapshot, ringBuffer) 5936 err = &smithy.DeserializationError{ 5937 Err: fmt.Errorf("failed to decode response body, %w", err), 5938 Snapshot: snapshot.Bytes(), 5939 } 5940 return out, metadata, err 5941 } 5942 5943 err = awsRestjson1_deserializeOpDocumentListFacetAttributesOutput(&output, shape) 5944 if err != nil { 5945 var snapshot bytes.Buffer 5946 io.Copy(&snapshot, ringBuffer) 5947 return out, metadata, &smithy.DeserializationError{ 5948 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 5949 Snapshot: snapshot.Bytes(), 5950 } 5951 } 5952 5953 return out, metadata, err 5954} 5955 5956func awsRestjson1_deserializeOpErrorListFacetAttributes(response *smithyhttp.Response, metadata *middleware.Metadata) error { 5957 var errorBuffer bytes.Buffer 5958 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 5959 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 5960 } 5961 errorBody := bytes.NewReader(errorBuffer.Bytes()) 5962 5963 errorCode := "UnknownError" 5964 errorMessage := errorCode 5965 5966 code := response.Header.Get("X-Amzn-ErrorType") 5967 if len(code) != 0 { 5968 errorCode = restjson.SanitizeErrorCode(code) 5969 } 5970 5971 var buff [1024]byte 5972 ringBuffer := smithyio.NewRingBuffer(buff[:]) 5973 5974 body := io.TeeReader(errorBody, ringBuffer) 5975 decoder := json.NewDecoder(body) 5976 decoder.UseNumber() 5977 code, message, err := restjson.GetErrorInfo(decoder) 5978 if err != nil { 5979 var snapshot bytes.Buffer 5980 io.Copy(&snapshot, ringBuffer) 5981 err = &smithy.DeserializationError{ 5982 Err: fmt.Errorf("failed to decode response body, %w", err), 5983 Snapshot: snapshot.Bytes(), 5984 } 5985 return err 5986 } 5987 5988 errorBody.Seek(0, io.SeekStart) 5989 if len(code) != 0 { 5990 errorCode = restjson.SanitizeErrorCode(code) 5991 } 5992 if len(message) != 0 { 5993 errorMessage = message 5994 } 5995 5996 switch { 5997 case strings.EqualFold("AccessDeniedException", errorCode): 5998 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 5999 6000 case strings.EqualFold("FacetNotFoundException", errorCode): 6001 return awsRestjson1_deserializeErrorFacetNotFoundException(response, errorBody) 6002 6003 case strings.EqualFold("InternalServiceException", errorCode): 6004 return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody) 6005 6006 case strings.EqualFold("InvalidArnException", errorCode): 6007 return awsRestjson1_deserializeErrorInvalidArnException(response, errorBody) 6008 6009 case strings.EqualFold("InvalidNextTokenException", errorCode): 6010 return awsRestjson1_deserializeErrorInvalidNextTokenException(response, errorBody) 6011 6012 case strings.EqualFold("LimitExceededException", errorCode): 6013 return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody) 6014 6015 case strings.EqualFold("ResourceNotFoundException", errorCode): 6016 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 6017 6018 case strings.EqualFold("RetryableConflictException", errorCode): 6019 return awsRestjson1_deserializeErrorRetryableConflictException(response, errorBody) 6020 6021 case strings.EqualFold("ValidationException", errorCode): 6022 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 6023 6024 default: 6025 genericError := &smithy.GenericAPIError{ 6026 Code: errorCode, 6027 Message: errorMessage, 6028 } 6029 return genericError 6030 6031 } 6032} 6033 6034func awsRestjson1_deserializeOpDocumentListFacetAttributesOutput(v **ListFacetAttributesOutput, value interface{}) error { 6035 if v == nil { 6036 return fmt.Errorf("unexpected nil of type %T", v) 6037 } 6038 if value == nil { 6039 return nil 6040 } 6041 6042 shape, ok := value.(map[string]interface{}) 6043 if !ok { 6044 return fmt.Errorf("unexpected JSON type %v", value) 6045 } 6046 6047 var sv *ListFacetAttributesOutput 6048 if *v == nil { 6049 sv = &ListFacetAttributesOutput{} 6050 } else { 6051 sv = *v 6052 } 6053 6054 for key, value := range shape { 6055 switch key { 6056 case "Attributes": 6057 if err := awsRestjson1_deserializeDocumentFacetAttributeList(&sv.Attributes, value); err != nil { 6058 return err 6059 } 6060 6061 case "NextToken": 6062 if value != nil { 6063 jtv, ok := value.(string) 6064 if !ok { 6065 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 6066 } 6067 sv.NextToken = ptr.String(jtv) 6068 } 6069 6070 default: 6071 _, _ = key, value 6072 6073 } 6074 } 6075 *v = sv 6076 return nil 6077} 6078 6079type awsRestjson1_deserializeOpListFacetNames struct { 6080} 6081 6082func (*awsRestjson1_deserializeOpListFacetNames) ID() string { 6083 return "OperationDeserializer" 6084} 6085 6086func (m *awsRestjson1_deserializeOpListFacetNames) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6087 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6088) { 6089 out, metadata, err = next.HandleDeserialize(ctx, in) 6090 if err != nil { 6091 return out, metadata, err 6092 } 6093 6094 response, ok := out.RawResponse.(*smithyhttp.Response) 6095 if !ok { 6096 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6097 } 6098 6099 if response.StatusCode < 200 || response.StatusCode >= 300 { 6100 return out, metadata, awsRestjson1_deserializeOpErrorListFacetNames(response, &metadata) 6101 } 6102 output := &ListFacetNamesOutput{} 6103 out.Result = output 6104 6105 var buff [1024]byte 6106 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6107 6108 body := io.TeeReader(response.Body, ringBuffer) 6109 6110 decoder := json.NewDecoder(body) 6111 decoder.UseNumber() 6112 var shape interface{} 6113 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6114 var snapshot bytes.Buffer 6115 io.Copy(&snapshot, ringBuffer) 6116 err = &smithy.DeserializationError{ 6117 Err: fmt.Errorf("failed to decode response body, %w", err), 6118 Snapshot: snapshot.Bytes(), 6119 } 6120 return out, metadata, err 6121 } 6122 6123 err = awsRestjson1_deserializeOpDocumentListFacetNamesOutput(&output, shape) 6124 if err != nil { 6125 var snapshot bytes.Buffer 6126 io.Copy(&snapshot, ringBuffer) 6127 return out, metadata, &smithy.DeserializationError{ 6128 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 6129 Snapshot: snapshot.Bytes(), 6130 } 6131 } 6132 6133 return out, metadata, err 6134} 6135 6136func awsRestjson1_deserializeOpErrorListFacetNames(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6137 var errorBuffer bytes.Buffer 6138 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6139 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6140 } 6141 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6142 6143 errorCode := "UnknownError" 6144 errorMessage := errorCode 6145 6146 code := response.Header.Get("X-Amzn-ErrorType") 6147 if len(code) != 0 { 6148 errorCode = restjson.SanitizeErrorCode(code) 6149 } 6150 6151 var buff [1024]byte 6152 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6153 6154 body := io.TeeReader(errorBody, ringBuffer) 6155 decoder := json.NewDecoder(body) 6156 decoder.UseNumber() 6157 code, message, err := restjson.GetErrorInfo(decoder) 6158 if err != nil { 6159 var snapshot bytes.Buffer 6160 io.Copy(&snapshot, ringBuffer) 6161 err = &smithy.DeserializationError{ 6162 Err: fmt.Errorf("failed to decode response body, %w", err), 6163 Snapshot: snapshot.Bytes(), 6164 } 6165 return err 6166 } 6167 6168 errorBody.Seek(0, io.SeekStart) 6169 if len(code) != 0 { 6170 errorCode = restjson.SanitizeErrorCode(code) 6171 } 6172 if len(message) != 0 { 6173 errorMessage = message 6174 } 6175 6176 switch { 6177 case strings.EqualFold("AccessDeniedException", errorCode): 6178 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 6179 6180 case strings.EqualFold("InternalServiceException", errorCode): 6181 return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody) 6182 6183 case strings.EqualFold("InvalidArnException", errorCode): 6184 return awsRestjson1_deserializeErrorInvalidArnException(response, errorBody) 6185 6186 case strings.EqualFold("InvalidNextTokenException", errorCode): 6187 return awsRestjson1_deserializeErrorInvalidNextTokenException(response, errorBody) 6188 6189 case strings.EqualFold("LimitExceededException", errorCode): 6190 return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody) 6191 6192 case strings.EqualFold("ResourceNotFoundException", errorCode): 6193 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 6194 6195 case strings.EqualFold("RetryableConflictException", errorCode): 6196 return awsRestjson1_deserializeErrorRetryableConflictException(response, errorBody) 6197 6198 case strings.EqualFold("ValidationException", errorCode): 6199 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 6200 6201 default: 6202 genericError := &smithy.GenericAPIError{ 6203 Code: errorCode, 6204 Message: errorMessage, 6205 } 6206 return genericError 6207 6208 } 6209} 6210 6211func awsRestjson1_deserializeOpDocumentListFacetNamesOutput(v **ListFacetNamesOutput, value interface{}) error { 6212 if v == nil { 6213 return fmt.Errorf("unexpected nil of type %T", v) 6214 } 6215 if value == nil { 6216 return nil 6217 } 6218 6219 shape, ok := value.(map[string]interface{}) 6220 if !ok { 6221 return fmt.Errorf("unexpected JSON type %v", value) 6222 } 6223 6224 var sv *ListFacetNamesOutput 6225 if *v == nil { 6226 sv = &ListFacetNamesOutput{} 6227 } else { 6228 sv = *v 6229 } 6230 6231 for key, value := range shape { 6232 switch key { 6233 case "FacetNames": 6234 if err := awsRestjson1_deserializeDocumentFacetNameList(&sv.FacetNames, value); err != nil { 6235 return err 6236 } 6237 6238 case "NextToken": 6239 if value != nil { 6240 jtv, ok := value.(string) 6241 if !ok { 6242 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 6243 } 6244 sv.NextToken = ptr.String(jtv) 6245 } 6246 6247 default: 6248 _, _ = key, value 6249 6250 } 6251 } 6252 *v = sv 6253 return nil 6254} 6255 6256type awsRestjson1_deserializeOpListIncomingTypedLinks struct { 6257} 6258 6259func (*awsRestjson1_deserializeOpListIncomingTypedLinks) ID() string { 6260 return "OperationDeserializer" 6261} 6262 6263func (m *awsRestjson1_deserializeOpListIncomingTypedLinks) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6264 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6265) { 6266 out, metadata, err = next.HandleDeserialize(ctx, in) 6267 if err != nil { 6268 return out, metadata, err 6269 } 6270 6271 response, ok := out.RawResponse.(*smithyhttp.Response) 6272 if !ok { 6273 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6274 } 6275 6276 if response.StatusCode < 200 || response.StatusCode >= 300 { 6277 return out, metadata, awsRestjson1_deserializeOpErrorListIncomingTypedLinks(response, &metadata) 6278 } 6279 output := &ListIncomingTypedLinksOutput{} 6280 out.Result = output 6281 6282 var buff [1024]byte 6283 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6284 6285 body := io.TeeReader(response.Body, ringBuffer) 6286 6287 decoder := json.NewDecoder(body) 6288 decoder.UseNumber() 6289 var shape interface{} 6290 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6291 var snapshot bytes.Buffer 6292 io.Copy(&snapshot, ringBuffer) 6293 err = &smithy.DeserializationError{ 6294 Err: fmt.Errorf("failed to decode response body, %w", err), 6295 Snapshot: snapshot.Bytes(), 6296 } 6297 return out, metadata, err 6298 } 6299 6300 err = awsRestjson1_deserializeOpDocumentListIncomingTypedLinksOutput(&output, shape) 6301 if err != nil { 6302 var snapshot bytes.Buffer 6303 io.Copy(&snapshot, ringBuffer) 6304 return out, metadata, &smithy.DeserializationError{ 6305 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 6306 Snapshot: snapshot.Bytes(), 6307 } 6308 } 6309 6310 return out, metadata, err 6311} 6312 6313func awsRestjson1_deserializeOpErrorListIncomingTypedLinks(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6314 var errorBuffer bytes.Buffer 6315 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6316 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6317 } 6318 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6319 6320 errorCode := "UnknownError" 6321 errorMessage := errorCode 6322 6323 code := response.Header.Get("X-Amzn-ErrorType") 6324 if len(code) != 0 { 6325 errorCode = restjson.SanitizeErrorCode(code) 6326 } 6327 6328 var buff [1024]byte 6329 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6330 6331 body := io.TeeReader(errorBody, ringBuffer) 6332 decoder := json.NewDecoder(body) 6333 decoder.UseNumber() 6334 code, message, err := restjson.GetErrorInfo(decoder) 6335 if err != nil { 6336 var snapshot bytes.Buffer 6337 io.Copy(&snapshot, ringBuffer) 6338 err = &smithy.DeserializationError{ 6339 Err: fmt.Errorf("failed to decode response body, %w", err), 6340 Snapshot: snapshot.Bytes(), 6341 } 6342 return err 6343 } 6344 6345 errorBody.Seek(0, io.SeekStart) 6346 if len(code) != 0 { 6347 errorCode = restjson.SanitizeErrorCode(code) 6348 } 6349 if len(message) != 0 { 6350 errorMessage = message 6351 } 6352 6353 switch { 6354 case strings.EqualFold("AccessDeniedException", errorCode): 6355 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 6356 6357 case strings.EqualFold("DirectoryNotEnabledException", errorCode): 6358 return awsRestjson1_deserializeErrorDirectoryNotEnabledException(response, errorBody) 6359 6360 case strings.EqualFold("FacetValidationException", errorCode): 6361 return awsRestjson1_deserializeErrorFacetValidationException(response, errorBody) 6362 6363 case strings.EqualFold("InternalServiceException", errorCode): 6364 return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody) 6365 6366 case strings.EqualFold("InvalidArnException", errorCode): 6367 return awsRestjson1_deserializeErrorInvalidArnException(response, errorBody) 6368 6369 case strings.EqualFold("InvalidNextTokenException", errorCode): 6370 return awsRestjson1_deserializeErrorInvalidNextTokenException(response, errorBody) 6371 6372 case strings.EqualFold("LimitExceededException", errorCode): 6373 return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody) 6374 6375 case strings.EqualFold("ResourceNotFoundException", errorCode): 6376 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 6377 6378 case strings.EqualFold("RetryableConflictException", errorCode): 6379 return awsRestjson1_deserializeErrorRetryableConflictException(response, errorBody) 6380 6381 case strings.EqualFold("ValidationException", errorCode): 6382 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 6383 6384 default: 6385 genericError := &smithy.GenericAPIError{ 6386 Code: errorCode, 6387 Message: errorMessage, 6388 } 6389 return genericError 6390 6391 } 6392} 6393 6394func awsRestjson1_deserializeOpDocumentListIncomingTypedLinksOutput(v **ListIncomingTypedLinksOutput, value interface{}) error { 6395 if v == nil { 6396 return fmt.Errorf("unexpected nil of type %T", v) 6397 } 6398 if value == nil { 6399 return nil 6400 } 6401 6402 shape, ok := value.(map[string]interface{}) 6403 if !ok { 6404 return fmt.Errorf("unexpected JSON type %v", value) 6405 } 6406 6407 var sv *ListIncomingTypedLinksOutput 6408 if *v == nil { 6409 sv = &ListIncomingTypedLinksOutput{} 6410 } else { 6411 sv = *v 6412 } 6413 6414 for key, value := range shape { 6415 switch key { 6416 case "LinkSpecifiers": 6417 if err := awsRestjson1_deserializeDocumentTypedLinkSpecifierList(&sv.LinkSpecifiers, value); err != nil { 6418 return err 6419 } 6420 6421 case "NextToken": 6422 if value != nil { 6423 jtv, ok := value.(string) 6424 if !ok { 6425 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 6426 } 6427 sv.NextToken = ptr.String(jtv) 6428 } 6429 6430 default: 6431 _, _ = key, value 6432 6433 } 6434 } 6435 *v = sv 6436 return nil 6437} 6438 6439type awsRestjson1_deserializeOpListIndex struct { 6440} 6441 6442func (*awsRestjson1_deserializeOpListIndex) ID() string { 6443 return "OperationDeserializer" 6444} 6445 6446func (m *awsRestjson1_deserializeOpListIndex) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6447 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6448) { 6449 out, metadata, err = next.HandleDeserialize(ctx, in) 6450 if err != nil { 6451 return out, metadata, err 6452 } 6453 6454 response, ok := out.RawResponse.(*smithyhttp.Response) 6455 if !ok { 6456 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6457 } 6458 6459 if response.StatusCode < 200 || response.StatusCode >= 300 { 6460 return out, metadata, awsRestjson1_deserializeOpErrorListIndex(response, &metadata) 6461 } 6462 output := &ListIndexOutput{} 6463 out.Result = output 6464 6465 var buff [1024]byte 6466 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6467 6468 body := io.TeeReader(response.Body, ringBuffer) 6469 6470 decoder := json.NewDecoder(body) 6471 decoder.UseNumber() 6472 var shape interface{} 6473 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6474 var snapshot bytes.Buffer 6475 io.Copy(&snapshot, ringBuffer) 6476 err = &smithy.DeserializationError{ 6477 Err: fmt.Errorf("failed to decode response body, %w", err), 6478 Snapshot: snapshot.Bytes(), 6479 } 6480 return out, metadata, err 6481 } 6482 6483 err = awsRestjson1_deserializeOpDocumentListIndexOutput(&output, shape) 6484 if err != nil { 6485 var snapshot bytes.Buffer 6486 io.Copy(&snapshot, ringBuffer) 6487 return out, metadata, &smithy.DeserializationError{ 6488 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 6489 Snapshot: snapshot.Bytes(), 6490 } 6491 } 6492 6493 return out, metadata, err 6494} 6495 6496func awsRestjson1_deserializeOpErrorListIndex(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6497 var errorBuffer bytes.Buffer 6498 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6499 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6500 } 6501 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6502 6503 errorCode := "UnknownError" 6504 errorMessage := errorCode 6505 6506 code := response.Header.Get("X-Amzn-ErrorType") 6507 if len(code) != 0 { 6508 errorCode = restjson.SanitizeErrorCode(code) 6509 } 6510 6511 var buff [1024]byte 6512 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6513 6514 body := io.TeeReader(errorBody, ringBuffer) 6515 decoder := json.NewDecoder(body) 6516 decoder.UseNumber() 6517 code, message, err := restjson.GetErrorInfo(decoder) 6518 if err != nil { 6519 var snapshot bytes.Buffer 6520 io.Copy(&snapshot, ringBuffer) 6521 err = &smithy.DeserializationError{ 6522 Err: fmt.Errorf("failed to decode response body, %w", err), 6523 Snapshot: snapshot.Bytes(), 6524 } 6525 return err 6526 } 6527 6528 errorBody.Seek(0, io.SeekStart) 6529 if len(code) != 0 { 6530 errorCode = restjson.SanitizeErrorCode(code) 6531 } 6532 if len(message) != 0 { 6533 errorMessage = message 6534 } 6535 6536 switch { 6537 case strings.EqualFold("AccessDeniedException", errorCode): 6538 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 6539 6540 case strings.EqualFold("DirectoryNotEnabledException", errorCode): 6541 return awsRestjson1_deserializeErrorDirectoryNotEnabledException(response, errorBody) 6542 6543 case strings.EqualFold("FacetValidationException", errorCode): 6544 return awsRestjson1_deserializeErrorFacetValidationException(response, errorBody) 6545 6546 case strings.EqualFold("InternalServiceException", errorCode): 6547 return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody) 6548 6549 case strings.EqualFold("InvalidArnException", errorCode): 6550 return awsRestjson1_deserializeErrorInvalidArnException(response, errorBody) 6551 6552 case strings.EqualFold("InvalidNextTokenException", errorCode): 6553 return awsRestjson1_deserializeErrorInvalidNextTokenException(response, errorBody) 6554 6555 case strings.EqualFold("LimitExceededException", errorCode): 6556 return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody) 6557 6558 case strings.EqualFold("NotIndexException", errorCode): 6559 return awsRestjson1_deserializeErrorNotIndexException(response, errorBody) 6560 6561 case strings.EqualFold("ResourceNotFoundException", errorCode): 6562 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 6563 6564 case strings.EqualFold("RetryableConflictException", errorCode): 6565 return awsRestjson1_deserializeErrorRetryableConflictException(response, errorBody) 6566 6567 case strings.EqualFold("ValidationException", errorCode): 6568 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 6569 6570 default: 6571 genericError := &smithy.GenericAPIError{ 6572 Code: errorCode, 6573 Message: errorMessage, 6574 } 6575 return genericError 6576 6577 } 6578} 6579 6580func awsRestjson1_deserializeOpDocumentListIndexOutput(v **ListIndexOutput, value interface{}) error { 6581 if v == nil { 6582 return fmt.Errorf("unexpected nil of type %T", v) 6583 } 6584 if value == nil { 6585 return nil 6586 } 6587 6588 shape, ok := value.(map[string]interface{}) 6589 if !ok { 6590 return fmt.Errorf("unexpected JSON type %v", value) 6591 } 6592 6593 var sv *ListIndexOutput 6594 if *v == nil { 6595 sv = &ListIndexOutput{} 6596 } else { 6597 sv = *v 6598 } 6599 6600 for key, value := range shape { 6601 switch key { 6602 case "IndexAttachments": 6603 if err := awsRestjson1_deserializeDocumentIndexAttachmentList(&sv.IndexAttachments, value); err != nil { 6604 return err 6605 } 6606 6607 case "NextToken": 6608 if value != nil { 6609 jtv, ok := value.(string) 6610 if !ok { 6611 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 6612 } 6613 sv.NextToken = ptr.String(jtv) 6614 } 6615 6616 default: 6617 _, _ = key, value 6618 6619 } 6620 } 6621 *v = sv 6622 return nil 6623} 6624 6625type awsRestjson1_deserializeOpListManagedSchemaArns struct { 6626} 6627 6628func (*awsRestjson1_deserializeOpListManagedSchemaArns) ID() string { 6629 return "OperationDeserializer" 6630} 6631 6632func (m *awsRestjson1_deserializeOpListManagedSchemaArns) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6633 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6634) { 6635 out, metadata, err = next.HandleDeserialize(ctx, in) 6636 if err != nil { 6637 return out, metadata, err 6638 } 6639 6640 response, ok := out.RawResponse.(*smithyhttp.Response) 6641 if !ok { 6642 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6643 } 6644 6645 if response.StatusCode < 200 || response.StatusCode >= 300 { 6646 return out, metadata, awsRestjson1_deserializeOpErrorListManagedSchemaArns(response, &metadata) 6647 } 6648 output := &ListManagedSchemaArnsOutput{} 6649 out.Result = output 6650 6651 var buff [1024]byte 6652 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6653 6654 body := io.TeeReader(response.Body, ringBuffer) 6655 6656 decoder := json.NewDecoder(body) 6657 decoder.UseNumber() 6658 var shape interface{} 6659 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6660 var snapshot bytes.Buffer 6661 io.Copy(&snapshot, ringBuffer) 6662 err = &smithy.DeserializationError{ 6663 Err: fmt.Errorf("failed to decode response body, %w", err), 6664 Snapshot: snapshot.Bytes(), 6665 } 6666 return out, metadata, err 6667 } 6668 6669 err = awsRestjson1_deserializeOpDocumentListManagedSchemaArnsOutput(&output, shape) 6670 if err != nil { 6671 var snapshot bytes.Buffer 6672 io.Copy(&snapshot, ringBuffer) 6673 return out, metadata, &smithy.DeserializationError{ 6674 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 6675 Snapshot: snapshot.Bytes(), 6676 } 6677 } 6678 6679 return out, metadata, err 6680} 6681 6682func awsRestjson1_deserializeOpErrorListManagedSchemaArns(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6683 var errorBuffer bytes.Buffer 6684 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6685 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6686 } 6687 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6688 6689 errorCode := "UnknownError" 6690 errorMessage := errorCode 6691 6692 code := response.Header.Get("X-Amzn-ErrorType") 6693 if len(code) != 0 { 6694 errorCode = restjson.SanitizeErrorCode(code) 6695 } 6696 6697 var buff [1024]byte 6698 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6699 6700 body := io.TeeReader(errorBody, ringBuffer) 6701 decoder := json.NewDecoder(body) 6702 decoder.UseNumber() 6703 code, message, err := restjson.GetErrorInfo(decoder) 6704 if err != nil { 6705 var snapshot bytes.Buffer 6706 io.Copy(&snapshot, ringBuffer) 6707 err = &smithy.DeserializationError{ 6708 Err: fmt.Errorf("failed to decode response body, %w", err), 6709 Snapshot: snapshot.Bytes(), 6710 } 6711 return err 6712 } 6713 6714 errorBody.Seek(0, io.SeekStart) 6715 if len(code) != 0 { 6716 errorCode = restjson.SanitizeErrorCode(code) 6717 } 6718 if len(message) != 0 { 6719 errorMessage = message 6720 } 6721 6722 switch { 6723 case strings.EqualFold("AccessDeniedException", errorCode): 6724 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 6725 6726 case strings.EqualFold("InternalServiceException", errorCode): 6727 return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody) 6728 6729 case strings.EqualFold("InvalidArnException", errorCode): 6730 return awsRestjson1_deserializeErrorInvalidArnException(response, errorBody) 6731 6732 case strings.EqualFold("InvalidNextTokenException", errorCode): 6733 return awsRestjson1_deserializeErrorInvalidNextTokenException(response, errorBody) 6734 6735 case strings.EqualFold("ResourceNotFoundException", errorCode): 6736 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 6737 6738 case strings.EqualFold("ValidationException", errorCode): 6739 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 6740 6741 default: 6742 genericError := &smithy.GenericAPIError{ 6743 Code: errorCode, 6744 Message: errorMessage, 6745 } 6746 return genericError 6747 6748 } 6749} 6750 6751func awsRestjson1_deserializeOpDocumentListManagedSchemaArnsOutput(v **ListManagedSchemaArnsOutput, value interface{}) error { 6752 if v == nil { 6753 return fmt.Errorf("unexpected nil of type %T", v) 6754 } 6755 if value == nil { 6756 return nil 6757 } 6758 6759 shape, ok := value.(map[string]interface{}) 6760 if !ok { 6761 return fmt.Errorf("unexpected JSON type %v", value) 6762 } 6763 6764 var sv *ListManagedSchemaArnsOutput 6765 if *v == nil { 6766 sv = &ListManagedSchemaArnsOutput{} 6767 } else { 6768 sv = *v 6769 } 6770 6771 for key, value := range shape { 6772 switch key { 6773 case "NextToken": 6774 if value != nil { 6775 jtv, ok := value.(string) 6776 if !ok { 6777 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 6778 } 6779 sv.NextToken = ptr.String(jtv) 6780 } 6781 6782 case "SchemaArns": 6783 if err := awsRestjson1_deserializeDocumentArns(&sv.SchemaArns, value); err != nil { 6784 return err 6785 } 6786 6787 default: 6788 _, _ = key, value 6789 6790 } 6791 } 6792 *v = sv 6793 return nil 6794} 6795 6796type awsRestjson1_deserializeOpListObjectAttributes struct { 6797} 6798 6799func (*awsRestjson1_deserializeOpListObjectAttributes) ID() string { 6800 return "OperationDeserializer" 6801} 6802 6803func (m *awsRestjson1_deserializeOpListObjectAttributes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6804 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6805) { 6806 out, metadata, err = next.HandleDeserialize(ctx, in) 6807 if err != nil { 6808 return out, metadata, err 6809 } 6810 6811 response, ok := out.RawResponse.(*smithyhttp.Response) 6812 if !ok { 6813 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6814 } 6815 6816 if response.StatusCode < 200 || response.StatusCode >= 300 { 6817 return out, metadata, awsRestjson1_deserializeOpErrorListObjectAttributes(response, &metadata) 6818 } 6819 output := &ListObjectAttributesOutput{} 6820 out.Result = output 6821 6822 var buff [1024]byte 6823 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6824 6825 body := io.TeeReader(response.Body, ringBuffer) 6826 6827 decoder := json.NewDecoder(body) 6828 decoder.UseNumber() 6829 var shape interface{} 6830 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 6831 var snapshot bytes.Buffer 6832 io.Copy(&snapshot, ringBuffer) 6833 err = &smithy.DeserializationError{ 6834 Err: fmt.Errorf("failed to decode response body, %w", err), 6835 Snapshot: snapshot.Bytes(), 6836 } 6837 return out, metadata, err 6838 } 6839 6840 err = awsRestjson1_deserializeOpDocumentListObjectAttributesOutput(&output, shape) 6841 if err != nil { 6842 var snapshot bytes.Buffer 6843 io.Copy(&snapshot, ringBuffer) 6844 return out, metadata, &smithy.DeserializationError{ 6845 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 6846 Snapshot: snapshot.Bytes(), 6847 } 6848 } 6849 6850 return out, metadata, err 6851} 6852 6853func awsRestjson1_deserializeOpErrorListObjectAttributes(response *smithyhttp.Response, metadata *middleware.Metadata) error { 6854 var errorBuffer bytes.Buffer 6855 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 6856 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 6857 } 6858 errorBody := bytes.NewReader(errorBuffer.Bytes()) 6859 6860 errorCode := "UnknownError" 6861 errorMessage := errorCode 6862 6863 code := response.Header.Get("X-Amzn-ErrorType") 6864 if len(code) != 0 { 6865 errorCode = restjson.SanitizeErrorCode(code) 6866 } 6867 6868 var buff [1024]byte 6869 ringBuffer := smithyio.NewRingBuffer(buff[:]) 6870 6871 body := io.TeeReader(errorBody, ringBuffer) 6872 decoder := json.NewDecoder(body) 6873 decoder.UseNumber() 6874 code, message, err := restjson.GetErrorInfo(decoder) 6875 if err != nil { 6876 var snapshot bytes.Buffer 6877 io.Copy(&snapshot, ringBuffer) 6878 err = &smithy.DeserializationError{ 6879 Err: fmt.Errorf("failed to decode response body, %w", err), 6880 Snapshot: snapshot.Bytes(), 6881 } 6882 return err 6883 } 6884 6885 errorBody.Seek(0, io.SeekStart) 6886 if len(code) != 0 { 6887 errorCode = restjson.SanitizeErrorCode(code) 6888 } 6889 if len(message) != 0 { 6890 errorMessage = message 6891 } 6892 6893 switch { 6894 case strings.EqualFold("AccessDeniedException", errorCode): 6895 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 6896 6897 case strings.EqualFold("DirectoryNotEnabledException", errorCode): 6898 return awsRestjson1_deserializeErrorDirectoryNotEnabledException(response, errorBody) 6899 6900 case strings.EqualFold("FacetValidationException", errorCode): 6901 return awsRestjson1_deserializeErrorFacetValidationException(response, errorBody) 6902 6903 case strings.EqualFold("InternalServiceException", errorCode): 6904 return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody) 6905 6906 case strings.EqualFold("InvalidArnException", errorCode): 6907 return awsRestjson1_deserializeErrorInvalidArnException(response, errorBody) 6908 6909 case strings.EqualFold("InvalidNextTokenException", errorCode): 6910 return awsRestjson1_deserializeErrorInvalidNextTokenException(response, errorBody) 6911 6912 case strings.EqualFold("LimitExceededException", errorCode): 6913 return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody) 6914 6915 case strings.EqualFold("ResourceNotFoundException", errorCode): 6916 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 6917 6918 case strings.EqualFold("RetryableConflictException", errorCode): 6919 return awsRestjson1_deserializeErrorRetryableConflictException(response, errorBody) 6920 6921 case strings.EqualFold("ValidationException", errorCode): 6922 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 6923 6924 default: 6925 genericError := &smithy.GenericAPIError{ 6926 Code: errorCode, 6927 Message: errorMessage, 6928 } 6929 return genericError 6930 6931 } 6932} 6933 6934func awsRestjson1_deserializeOpDocumentListObjectAttributesOutput(v **ListObjectAttributesOutput, value interface{}) error { 6935 if v == nil { 6936 return fmt.Errorf("unexpected nil of type %T", v) 6937 } 6938 if value == nil { 6939 return nil 6940 } 6941 6942 shape, ok := value.(map[string]interface{}) 6943 if !ok { 6944 return fmt.Errorf("unexpected JSON type %v", value) 6945 } 6946 6947 var sv *ListObjectAttributesOutput 6948 if *v == nil { 6949 sv = &ListObjectAttributesOutput{} 6950 } else { 6951 sv = *v 6952 } 6953 6954 for key, value := range shape { 6955 switch key { 6956 case "Attributes": 6957 if err := awsRestjson1_deserializeDocumentAttributeKeyAndValueList(&sv.Attributes, value); err != nil { 6958 return err 6959 } 6960 6961 case "NextToken": 6962 if value != nil { 6963 jtv, ok := value.(string) 6964 if !ok { 6965 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 6966 } 6967 sv.NextToken = ptr.String(jtv) 6968 } 6969 6970 default: 6971 _, _ = key, value 6972 6973 } 6974 } 6975 *v = sv 6976 return nil 6977} 6978 6979type awsRestjson1_deserializeOpListObjectChildren struct { 6980} 6981 6982func (*awsRestjson1_deserializeOpListObjectChildren) ID() string { 6983 return "OperationDeserializer" 6984} 6985 6986func (m *awsRestjson1_deserializeOpListObjectChildren) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 6987 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 6988) { 6989 out, metadata, err = next.HandleDeserialize(ctx, in) 6990 if err != nil { 6991 return out, metadata, err 6992 } 6993 6994 response, ok := out.RawResponse.(*smithyhttp.Response) 6995 if !ok { 6996 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 6997 } 6998 6999 if response.StatusCode < 200 || response.StatusCode >= 300 { 7000 return out, metadata, awsRestjson1_deserializeOpErrorListObjectChildren(response, &metadata) 7001 } 7002 output := &ListObjectChildrenOutput{} 7003 out.Result = output 7004 7005 var buff [1024]byte 7006 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7007 7008 body := io.TeeReader(response.Body, ringBuffer) 7009 7010 decoder := json.NewDecoder(body) 7011 decoder.UseNumber() 7012 var shape interface{} 7013 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7014 var snapshot bytes.Buffer 7015 io.Copy(&snapshot, ringBuffer) 7016 err = &smithy.DeserializationError{ 7017 Err: fmt.Errorf("failed to decode response body, %w", err), 7018 Snapshot: snapshot.Bytes(), 7019 } 7020 return out, metadata, err 7021 } 7022 7023 err = awsRestjson1_deserializeOpDocumentListObjectChildrenOutput(&output, shape) 7024 if err != nil { 7025 var snapshot bytes.Buffer 7026 io.Copy(&snapshot, ringBuffer) 7027 return out, metadata, &smithy.DeserializationError{ 7028 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 7029 Snapshot: snapshot.Bytes(), 7030 } 7031 } 7032 7033 return out, metadata, err 7034} 7035 7036func awsRestjson1_deserializeOpErrorListObjectChildren(response *smithyhttp.Response, metadata *middleware.Metadata) error { 7037 var errorBuffer bytes.Buffer 7038 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 7039 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 7040 } 7041 errorBody := bytes.NewReader(errorBuffer.Bytes()) 7042 7043 errorCode := "UnknownError" 7044 errorMessage := errorCode 7045 7046 code := response.Header.Get("X-Amzn-ErrorType") 7047 if len(code) != 0 { 7048 errorCode = restjson.SanitizeErrorCode(code) 7049 } 7050 7051 var buff [1024]byte 7052 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7053 7054 body := io.TeeReader(errorBody, ringBuffer) 7055 decoder := json.NewDecoder(body) 7056 decoder.UseNumber() 7057 code, message, err := restjson.GetErrorInfo(decoder) 7058 if err != nil { 7059 var snapshot bytes.Buffer 7060 io.Copy(&snapshot, ringBuffer) 7061 err = &smithy.DeserializationError{ 7062 Err: fmt.Errorf("failed to decode response body, %w", err), 7063 Snapshot: snapshot.Bytes(), 7064 } 7065 return err 7066 } 7067 7068 errorBody.Seek(0, io.SeekStart) 7069 if len(code) != 0 { 7070 errorCode = restjson.SanitizeErrorCode(code) 7071 } 7072 if len(message) != 0 { 7073 errorMessage = message 7074 } 7075 7076 switch { 7077 case strings.EqualFold("AccessDeniedException", errorCode): 7078 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 7079 7080 case strings.EqualFold("DirectoryNotEnabledException", errorCode): 7081 return awsRestjson1_deserializeErrorDirectoryNotEnabledException(response, errorBody) 7082 7083 case strings.EqualFold("InternalServiceException", errorCode): 7084 return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody) 7085 7086 case strings.EqualFold("InvalidArnException", errorCode): 7087 return awsRestjson1_deserializeErrorInvalidArnException(response, errorBody) 7088 7089 case strings.EqualFold("InvalidNextTokenException", errorCode): 7090 return awsRestjson1_deserializeErrorInvalidNextTokenException(response, errorBody) 7091 7092 case strings.EqualFold("LimitExceededException", errorCode): 7093 return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody) 7094 7095 case strings.EqualFold("NotNodeException", errorCode): 7096 return awsRestjson1_deserializeErrorNotNodeException(response, errorBody) 7097 7098 case strings.EqualFold("ResourceNotFoundException", errorCode): 7099 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 7100 7101 case strings.EqualFold("RetryableConflictException", errorCode): 7102 return awsRestjson1_deserializeErrorRetryableConflictException(response, errorBody) 7103 7104 case strings.EqualFold("ValidationException", errorCode): 7105 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 7106 7107 default: 7108 genericError := &smithy.GenericAPIError{ 7109 Code: errorCode, 7110 Message: errorMessage, 7111 } 7112 return genericError 7113 7114 } 7115} 7116 7117func awsRestjson1_deserializeOpDocumentListObjectChildrenOutput(v **ListObjectChildrenOutput, value interface{}) error { 7118 if v == nil { 7119 return fmt.Errorf("unexpected nil of type %T", v) 7120 } 7121 if value == nil { 7122 return nil 7123 } 7124 7125 shape, ok := value.(map[string]interface{}) 7126 if !ok { 7127 return fmt.Errorf("unexpected JSON type %v", value) 7128 } 7129 7130 var sv *ListObjectChildrenOutput 7131 if *v == nil { 7132 sv = &ListObjectChildrenOutput{} 7133 } else { 7134 sv = *v 7135 } 7136 7137 for key, value := range shape { 7138 switch key { 7139 case "Children": 7140 if err := awsRestjson1_deserializeDocumentLinkNameToObjectIdentifierMap(&sv.Children, value); err != nil { 7141 return err 7142 } 7143 7144 case "NextToken": 7145 if value != nil { 7146 jtv, ok := value.(string) 7147 if !ok { 7148 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 7149 } 7150 sv.NextToken = ptr.String(jtv) 7151 } 7152 7153 default: 7154 _, _ = key, value 7155 7156 } 7157 } 7158 *v = sv 7159 return nil 7160} 7161 7162type awsRestjson1_deserializeOpListObjectParentPaths struct { 7163} 7164 7165func (*awsRestjson1_deserializeOpListObjectParentPaths) ID() string { 7166 return "OperationDeserializer" 7167} 7168 7169func (m *awsRestjson1_deserializeOpListObjectParentPaths) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 7170 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 7171) { 7172 out, metadata, err = next.HandleDeserialize(ctx, in) 7173 if err != nil { 7174 return out, metadata, err 7175 } 7176 7177 response, ok := out.RawResponse.(*smithyhttp.Response) 7178 if !ok { 7179 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 7180 } 7181 7182 if response.StatusCode < 200 || response.StatusCode >= 300 { 7183 return out, metadata, awsRestjson1_deserializeOpErrorListObjectParentPaths(response, &metadata) 7184 } 7185 output := &ListObjectParentPathsOutput{} 7186 out.Result = output 7187 7188 var buff [1024]byte 7189 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7190 7191 body := io.TeeReader(response.Body, ringBuffer) 7192 7193 decoder := json.NewDecoder(body) 7194 decoder.UseNumber() 7195 var shape interface{} 7196 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7197 var snapshot bytes.Buffer 7198 io.Copy(&snapshot, ringBuffer) 7199 err = &smithy.DeserializationError{ 7200 Err: fmt.Errorf("failed to decode response body, %w", err), 7201 Snapshot: snapshot.Bytes(), 7202 } 7203 return out, metadata, err 7204 } 7205 7206 err = awsRestjson1_deserializeOpDocumentListObjectParentPathsOutput(&output, shape) 7207 if err != nil { 7208 var snapshot bytes.Buffer 7209 io.Copy(&snapshot, ringBuffer) 7210 return out, metadata, &smithy.DeserializationError{ 7211 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 7212 Snapshot: snapshot.Bytes(), 7213 } 7214 } 7215 7216 return out, metadata, err 7217} 7218 7219func awsRestjson1_deserializeOpErrorListObjectParentPaths(response *smithyhttp.Response, metadata *middleware.Metadata) error { 7220 var errorBuffer bytes.Buffer 7221 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 7222 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 7223 } 7224 errorBody := bytes.NewReader(errorBuffer.Bytes()) 7225 7226 errorCode := "UnknownError" 7227 errorMessage := errorCode 7228 7229 code := response.Header.Get("X-Amzn-ErrorType") 7230 if len(code) != 0 { 7231 errorCode = restjson.SanitizeErrorCode(code) 7232 } 7233 7234 var buff [1024]byte 7235 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7236 7237 body := io.TeeReader(errorBody, ringBuffer) 7238 decoder := json.NewDecoder(body) 7239 decoder.UseNumber() 7240 code, message, err := restjson.GetErrorInfo(decoder) 7241 if err != nil { 7242 var snapshot bytes.Buffer 7243 io.Copy(&snapshot, ringBuffer) 7244 err = &smithy.DeserializationError{ 7245 Err: fmt.Errorf("failed to decode response body, %w", err), 7246 Snapshot: snapshot.Bytes(), 7247 } 7248 return err 7249 } 7250 7251 errorBody.Seek(0, io.SeekStart) 7252 if len(code) != 0 { 7253 errorCode = restjson.SanitizeErrorCode(code) 7254 } 7255 if len(message) != 0 { 7256 errorMessage = message 7257 } 7258 7259 switch { 7260 case strings.EqualFold("AccessDeniedException", errorCode): 7261 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 7262 7263 case strings.EqualFold("DirectoryNotEnabledException", errorCode): 7264 return awsRestjson1_deserializeErrorDirectoryNotEnabledException(response, errorBody) 7265 7266 case strings.EqualFold("InternalServiceException", errorCode): 7267 return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody) 7268 7269 case strings.EqualFold("InvalidArnException", errorCode): 7270 return awsRestjson1_deserializeErrorInvalidArnException(response, errorBody) 7271 7272 case strings.EqualFold("InvalidNextTokenException", errorCode): 7273 return awsRestjson1_deserializeErrorInvalidNextTokenException(response, errorBody) 7274 7275 case strings.EqualFold("LimitExceededException", errorCode): 7276 return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody) 7277 7278 case strings.EqualFold("ResourceNotFoundException", errorCode): 7279 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 7280 7281 case strings.EqualFold("RetryableConflictException", errorCode): 7282 return awsRestjson1_deserializeErrorRetryableConflictException(response, errorBody) 7283 7284 case strings.EqualFold("ValidationException", errorCode): 7285 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 7286 7287 default: 7288 genericError := &smithy.GenericAPIError{ 7289 Code: errorCode, 7290 Message: errorMessage, 7291 } 7292 return genericError 7293 7294 } 7295} 7296 7297func awsRestjson1_deserializeOpDocumentListObjectParentPathsOutput(v **ListObjectParentPathsOutput, value interface{}) error { 7298 if v == nil { 7299 return fmt.Errorf("unexpected nil of type %T", v) 7300 } 7301 if value == nil { 7302 return nil 7303 } 7304 7305 shape, ok := value.(map[string]interface{}) 7306 if !ok { 7307 return fmt.Errorf("unexpected JSON type %v", value) 7308 } 7309 7310 var sv *ListObjectParentPathsOutput 7311 if *v == nil { 7312 sv = &ListObjectParentPathsOutput{} 7313 } else { 7314 sv = *v 7315 } 7316 7317 for key, value := range shape { 7318 switch key { 7319 case "NextToken": 7320 if value != nil { 7321 jtv, ok := value.(string) 7322 if !ok { 7323 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 7324 } 7325 sv.NextToken = ptr.String(jtv) 7326 } 7327 7328 case "PathToObjectIdentifiersList": 7329 if err := awsRestjson1_deserializeDocumentPathToObjectIdentifiersList(&sv.PathToObjectIdentifiersList, value); err != nil { 7330 return err 7331 } 7332 7333 default: 7334 _, _ = key, value 7335 7336 } 7337 } 7338 *v = sv 7339 return nil 7340} 7341 7342type awsRestjson1_deserializeOpListObjectParents struct { 7343} 7344 7345func (*awsRestjson1_deserializeOpListObjectParents) ID() string { 7346 return "OperationDeserializer" 7347} 7348 7349func (m *awsRestjson1_deserializeOpListObjectParents) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 7350 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 7351) { 7352 out, metadata, err = next.HandleDeserialize(ctx, in) 7353 if err != nil { 7354 return out, metadata, err 7355 } 7356 7357 response, ok := out.RawResponse.(*smithyhttp.Response) 7358 if !ok { 7359 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 7360 } 7361 7362 if response.StatusCode < 200 || response.StatusCode >= 300 { 7363 return out, metadata, awsRestjson1_deserializeOpErrorListObjectParents(response, &metadata) 7364 } 7365 output := &ListObjectParentsOutput{} 7366 out.Result = output 7367 7368 var buff [1024]byte 7369 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7370 7371 body := io.TeeReader(response.Body, ringBuffer) 7372 7373 decoder := json.NewDecoder(body) 7374 decoder.UseNumber() 7375 var shape interface{} 7376 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7377 var snapshot bytes.Buffer 7378 io.Copy(&snapshot, ringBuffer) 7379 err = &smithy.DeserializationError{ 7380 Err: fmt.Errorf("failed to decode response body, %w", err), 7381 Snapshot: snapshot.Bytes(), 7382 } 7383 return out, metadata, err 7384 } 7385 7386 err = awsRestjson1_deserializeOpDocumentListObjectParentsOutput(&output, shape) 7387 if err != nil { 7388 var snapshot bytes.Buffer 7389 io.Copy(&snapshot, ringBuffer) 7390 return out, metadata, &smithy.DeserializationError{ 7391 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 7392 Snapshot: snapshot.Bytes(), 7393 } 7394 } 7395 7396 return out, metadata, err 7397} 7398 7399func awsRestjson1_deserializeOpErrorListObjectParents(response *smithyhttp.Response, metadata *middleware.Metadata) error { 7400 var errorBuffer bytes.Buffer 7401 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 7402 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 7403 } 7404 errorBody := bytes.NewReader(errorBuffer.Bytes()) 7405 7406 errorCode := "UnknownError" 7407 errorMessage := errorCode 7408 7409 code := response.Header.Get("X-Amzn-ErrorType") 7410 if len(code) != 0 { 7411 errorCode = restjson.SanitizeErrorCode(code) 7412 } 7413 7414 var buff [1024]byte 7415 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7416 7417 body := io.TeeReader(errorBody, ringBuffer) 7418 decoder := json.NewDecoder(body) 7419 decoder.UseNumber() 7420 code, message, err := restjson.GetErrorInfo(decoder) 7421 if err != nil { 7422 var snapshot bytes.Buffer 7423 io.Copy(&snapshot, ringBuffer) 7424 err = &smithy.DeserializationError{ 7425 Err: fmt.Errorf("failed to decode response body, %w", err), 7426 Snapshot: snapshot.Bytes(), 7427 } 7428 return err 7429 } 7430 7431 errorBody.Seek(0, io.SeekStart) 7432 if len(code) != 0 { 7433 errorCode = restjson.SanitizeErrorCode(code) 7434 } 7435 if len(message) != 0 { 7436 errorMessage = message 7437 } 7438 7439 switch { 7440 case strings.EqualFold("AccessDeniedException", errorCode): 7441 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 7442 7443 case strings.EqualFold("CannotListParentOfRootException", errorCode): 7444 return awsRestjson1_deserializeErrorCannotListParentOfRootException(response, errorBody) 7445 7446 case strings.EqualFold("DirectoryNotEnabledException", errorCode): 7447 return awsRestjson1_deserializeErrorDirectoryNotEnabledException(response, errorBody) 7448 7449 case strings.EqualFold("InternalServiceException", errorCode): 7450 return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody) 7451 7452 case strings.EqualFold("InvalidArnException", errorCode): 7453 return awsRestjson1_deserializeErrorInvalidArnException(response, errorBody) 7454 7455 case strings.EqualFold("InvalidNextTokenException", errorCode): 7456 return awsRestjson1_deserializeErrorInvalidNextTokenException(response, errorBody) 7457 7458 case strings.EqualFold("LimitExceededException", errorCode): 7459 return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody) 7460 7461 case strings.EqualFold("ResourceNotFoundException", errorCode): 7462 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 7463 7464 case strings.EqualFold("RetryableConflictException", errorCode): 7465 return awsRestjson1_deserializeErrorRetryableConflictException(response, errorBody) 7466 7467 case strings.EqualFold("ValidationException", errorCode): 7468 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 7469 7470 default: 7471 genericError := &smithy.GenericAPIError{ 7472 Code: errorCode, 7473 Message: errorMessage, 7474 } 7475 return genericError 7476 7477 } 7478} 7479 7480func awsRestjson1_deserializeOpDocumentListObjectParentsOutput(v **ListObjectParentsOutput, value interface{}) error { 7481 if v == nil { 7482 return fmt.Errorf("unexpected nil of type %T", v) 7483 } 7484 if value == nil { 7485 return nil 7486 } 7487 7488 shape, ok := value.(map[string]interface{}) 7489 if !ok { 7490 return fmt.Errorf("unexpected JSON type %v", value) 7491 } 7492 7493 var sv *ListObjectParentsOutput 7494 if *v == nil { 7495 sv = &ListObjectParentsOutput{} 7496 } else { 7497 sv = *v 7498 } 7499 7500 for key, value := range shape { 7501 switch key { 7502 case "NextToken": 7503 if value != nil { 7504 jtv, ok := value.(string) 7505 if !ok { 7506 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 7507 } 7508 sv.NextToken = ptr.String(jtv) 7509 } 7510 7511 case "ParentLinks": 7512 if err := awsRestjson1_deserializeDocumentObjectIdentifierAndLinkNameList(&sv.ParentLinks, value); err != nil { 7513 return err 7514 } 7515 7516 case "Parents": 7517 if err := awsRestjson1_deserializeDocumentObjectIdentifierToLinkNameMap(&sv.Parents, value); err != nil { 7518 return err 7519 } 7520 7521 default: 7522 _, _ = key, value 7523 7524 } 7525 } 7526 *v = sv 7527 return nil 7528} 7529 7530type awsRestjson1_deserializeOpListObjectPolicies struct { 7531} 7532 7533func (*awsRestjson1_deserializeOpListObjectPolicies) ID() string { 7534 return "OperationDeserializer" 7535} 7536 7537func (m *awsRestjson1_deserializeOpListObjectPolicies) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 7538 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 7539) { 7540 out, metadata, err = next.HandleDeserialize(ctx, in) 7541 if err != nil { 7542 return out, metadata, err 7543 } 7544 7545 response, ok := out.RawResponse.(*smithyhttp.Response) 7546 if !ok { 7547 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 7548 } 7549 7550 if response.StatusCode < 200 || response.StatusCode >= 300 { 7551 return out, metadata, awsRestjson1_deserializeOpErrorListObjectPolicies(response, &metadata) 7552 } 7553 output := &ListObjectPoliciesOutput{} 7554 out.Result = output 7555 7556 var buff [1024]byte 7557 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7558 7559 body := io.TeeReader(response.Body, ringBuffer) 7560 7561 decoder := json.NewDecoder(body) 7562 decoder.UseNumber() 7563 var shape interface{} 7564 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7565 var snapshot bytes.Buffer 7566 io.Copy(&snapshot, ringBuffer) 7567 err = &smithy.DeserializationError{ 7568 Err: fmt.Errorf("failed to decode response body, %w", err), 7569 Snapshot: snapshot.Bytes(), 7570 } 7571 return out, metadata, err 7572 } 7573 7574 err = awsRestjson1_deserializeOpDocumentListObjectPoliciesOutput(&output, shape) 7575 if err != nil { 7576 var snapshot bytes.Buffer 7577 io.Copy(&snapshot, ringBuffer) 7578 return out, metadata, &smithy.DeserializationError{ 7579 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 7580 Snapshot: snapshot.Bytes(), 7581 } 7582 } 7583 7584 return out, metadata, err 7585} 7586 7587func awsRestjson1_deserializeOpErrorListObjectPolicies(response *smithyhttp.Response, metadata *middleware.Metadata) error { 7588 var errorBuffer bytes.Buffer 7589 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 7590 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 7591 } 7592 errorBody := bytes.NewReader(errorBuffer.Bytes()) 7593 7594 errorCode := "UnknownError" 7595 errorMessage := errorCode 7596 7597 code := response.Header.Get("X-Amzn-ErrorType") 7598 if len(code) != 0 { 7599 errorCode = restjson.SanitizeErrorCode(code) 7600 } 7601 7602 var buff [1024]byte 7603 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7604 7605 body := io.TeeReader(errorBody, ringBuffer) 7606 decoder := json.NewDecoder(body) 7607 decoder.UseNumber() 7608 code, message, err := restjson.GetErrorInfo(decoder) 7609 if err != nil { 7610 var snapshot bytes.Buffer 7611 io.Copy(&snapshot, ringBuffer) 7612 err = &smithy.DeserializationError{ 7613 Err: fmt.Errorf("failed to decode response body, %w", err), 7614 Snapshot: snapshot.Bytes(), 7615 } 7616 return err 7617 } 7618 7619 errorBody.Seek(0, io.SeekStart) 7620 if len(code) != 0 { 7621 errorCode = restjson.SanitizeErrorCode(code) 7622 } 7623 if len(message) != 0 { 7624 errorMessage = message 7625 } 7626 7627 switch { 7628 case strings.EqualFold("AccessDeniedException", errorCode): 7629 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 7630 7631 case strings.EqualFold("DirectoryNotEnabledException", errorCode): 7632 return awsRestjson1_deserializeErrorDirectoryNotEnabledException(response, errorBody) 7633 7634 case strings.EqualFold("InternalServiceException", errorCode): 7635 return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody) 7636 7637 case strings.EqualFold("InvalidArnException", errorCode): 7638 return awsRestjson1_deserializeErrorInvalidArnException(response, errorBody) 7639 7640 case strings.EqualFold("InvalidNextTokenException", errorCode): 7641 return awsRestjson1_deserializeErrorInvalidNextTokenException(response, errorBody) 7642 7643 case strings.EqualFold("LimitExceededException", errorCode): 7644 return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody) 7645 7646 case strings.EqualFold("ResourceNotFoundException", errorCode): 7647 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 7648 7649 case strings.EqualFold("RetryableConflictException", errorCode): 7650 return awsRestjson1_deserializeErrorRetryableConflictException(response, errorBody) 7651 7652 case strings.EqualFold("ValidationException", errorCode): 7653 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 7654 7655 default: 7656 genericError := &smithy.GenericAPIError{ 7657 Code: errorCode, 7658 Message: errorMessage, 7659 } 7660 return genericError 7661 7662 } 7663} 7664 7665func awsRestjson1_deserializeOpDocumentListObjectPoliciesOutput(v **ListObjectPoliciesOutput, value interface{}) error { 7666 if v == nil { 7667 return fmt.Errorf("unexpected nil of type %T", v) 7668 } 7669 if value == nil { 7670 return nil 7671 } 7672 7673 shape, ok := value.(map[string]interface{}) 7674 if !ok { 7675 return fmt.Errorf("unexpected JSON type %v", value) 7676 } 7677 7678 var sv *ListObjectPoliciesOutput 7679 if *v == nil { 7680 sv = &ListObjectPoliciesOutput{} 7681 } else { 7682 sv = *v 7683 } 7684 7685 for key, value := range shape { 7686 switch key { 7687 case "AttachedPolicyIds": 7688 if err := awsRestjson1_deserializeDocumentObjectIdentifierList(&sv.AttachedPolicyIds, value); err != nil { 7689 return err 7690 } 7691 7692 case "NextToken": 7693 if value != nil { 7694 jtv, ok := value.(string) 7695 if !ok { 7696 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 7697 } 7698 sv.NextToken = ptr.String(jtv) 7699 } 7700 7701 default: 7702 _, _ = key, value 7703 7704 } 7705 } 7706 *v = sv 7707 return nil 7708} 7709 7710type awsRestjson1_deserializeOpListOutgoingTypedLinks struct { 7711} 7712 7713func (*awsRestjson1_deserializeOpListOutgoingTypedLinks) ID() string { 7714 return "OperationDeserializer" 7715} 7716 7717func (m *awsRestjson1_deserializeOpListOutgoingTypedLinks) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 7718 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 7719) { 7720 out, metadata, err = next.HandleDeserialize(ctx, in) 7721 if err != nil { 7722 return out, metadata, err 7723 } 7724 7725 response, ok := out.RawResponse.(*smithyhttp.Response) 7726 if !ok { 7727 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 7728 } 7729 7730 if response.StatusCode < 200 || response.StatusCode >= 300 { 7731 return out, metadata, awsRestjson1_deserializeOpErrorListOutgoingTypedLinks(response, &metadata) 7732 } 7733 output := &ListOutgoingTypedLinksOutput{} 7734 out.Result = output 7735 7736 var buff [1024]byte 7737 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7738 7739 body := io.TeeReader(response.Body, ringBuffer) 7740 7741 decoder := json.NewDecoder(body) 7742 decoder.UseNumber() 7743 var shape interface{} 7744 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7745 var snapshot bytes.Buffer 7746 io.Copy(&snapshot, ringBuffer) 7747 err = &smithy.DeserializationError{ 7748 Err: fmt.Errorf("failed to decode response body, %w", err), 7749 Snapshot: snapshot.Bytes(), 7750 } 7751 return out, metadata, err 7752 } 7753 7754 err = awsRestjson1_deserializeOpDocumentListOutgoingTypedLinksOutput(&output, shape) 7755 if err != nil { 7756 var snapshot bytes.Buffer 7757 io.Copy(&snapshot, ringBuffer) 7758 return out, metadata, &smithy.DeserializationError{ 7759 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 7760 Snapshot: snapshot.Bytes(), 7761 } 7762 } 7763 7764 return out, metadata, err 7765} 7766 7767func awsRestjson1_deserializeOpErrorListOutgoingTypedLinks(response *smithyhttp.Response, metadata *middleware.Metadata) error { 7768 var errorBuffer bytes.Buffer 7769 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 7770 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 7771 } 7772 errorBody := bytes.NewReader(errorBuffer.Bytes()) 7773 7774 errorCode := "UnknownError" 7775 errorMessage := errorCode 7776 7777 code := response.Header.Get("X-Amzn-ErrorType") 7778 if len(code) != 0 { 7779 errorCode = restjson.SanitizeErrorCode(code) 7780 } 7781 7782 var buff [1024]byte 7783 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7784 7785 body := io.TeeReader(errorBody, ringBuffer) 7786 decoder := json.NewDecoder(body) 7787 decoder.UseNumber() 7788 code, message, err := restjson.GetErrorInfo(decoder) 7789 if err != nil { 7790 var snapshot bytes.Buffer 7791 io.Copy(&snapshot, ringBuffer) 7792 err = &smithy.DeserializationError{ 7793 Err: fmt.Errorf("failed to decode response body, %w", err), 7794 Snapshot: snapshot.Bytes(), 7795 } 7796 return err 7797 } 7798 7799 errorBody.Seek(0, io.SeekStart) 7800 if len(code) != 0 { 7801 errorCode = restjson.SanitizeErrorCode(code) 7802 } 7803 if len(message) != 0 { 7804 errorMessage = message 7805 } 7806 7807 switch { 7808 case strings.EqualFold("AccessDeniedException", errorCode): 7809 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 7810 7811 case strings.EqualFold("DirectoryNotEnabledException", errorCode): 7812 return awsRestjson1_deserializeErrorDirectoryNotEnabledException(response, errorBody) 7813 7814 case strings.EqualFold("FacetValidationException", errorCode): 7815 return awsRestjson1_deserializeErrorFacetValidationException(response, errorBody) 7816 7817 case strings.EqualFold("InternalServiceException", errorCode): 7818 return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody) 7819 7820 case strings.EqualFold("InvalidArnException", errorCode): 7821 return awsRestjson1_deserializeErrorInvalidArnException(response, errorBody) 7822 7823 case strings.EqualFold("InvalidNextTokenException", errorCode): 7824 return awsRestjson1_deserializeErrorInvalidNextTokenException(response, errorBody) 7825 7826 case strings.EqualFold("LimitExceededException", errorCode): 7827 return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody) 7828 7829 case strings.EqualFold("ResourceNotFoundException", errorCode): 7830 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 7831 7832 case strings.EqualFold("RetryableConflictException", errorCode): 7833 return awsRestjson1_deserializeErrorRetryableConflictException(response, errorBody) 7834 7835 case strings.EqualFold("ValidationException", errorCode): 7836 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 7837 7838 default: 7839 genericError := &smithy.GenericAPIError{ 7840 Code: errorCode, 7841 Message: errorMessage, 7842 } 7843 return genericError 7844 7845 } 7846} 7847 7848func awsRestjson1_deserializeOpDocumentListOutgoingTypedLinksOutput(v **ListOutgoingTypedLinksOutput, value interface{}) error { 7849 if v == nil { 7850 return fmt.Errorf("unexpected nil of type %T", v) 7851 } 7852 if value == nil { 7853 return nil 7854 } 7855 7856 shape, ok := value.(map[string]interface{}) 7857 if !ok { 7858 return fmt.Errorf("unexpected JSON type %v", value) 7859 } 7860 7861 var sv *ListOutgoingTypedLinksOutput 7862 if *v == nil { 7863 sv = &ListOutgoingTypedLinksOutput{} 7864 } else { 7865 sv = *v 7866 } 7867 7868 for key, value := range shape { 7869 switch key { 7870 case "NextToken": 7871 if value != nil { 7872 jtv, ok := value.(string) 7873 if !ok { 7874 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 7875 } 7876 sv.NextToken = ptr.String(jtv) 7877 } 7878 7879 case "TypedLinkSpecifiers": 7880 if err := awsRestjson1_deserializeDocumentTypedLinkSpecifierList(&sv.TypedLinkSpecifiers, value); err != nil { 7881 return err 7882 } 7883 7884 default: 7885 _, _ = key, value 7886 7887 } 7888 } 7889 *v = sv 7890 return nil 7891} 7892 7893type awsRestjson1_deserializeOpListPolicyAttachments struct { 7894} 7895 7896func (*awsRestjson1_deserializeOpListPolicyAttachments) ID() string { 7897 return "OperationDeserializer" 7898} 7899 7900func (m *awsRestjson1_deserializeOpListPolicyAttachments) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 7901 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 7902) { 7903 out, metadata, err = next.HandleDeserialize(ctx, in) 7904 if err != nil { 7905 return out, metadata, err 7906 } 7907 7908 response, ok := out.RawResponse.(*smithyhttp.Response) 7909 if !ok { 7910 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 7911 } 7912 7913 if response.StatusCode < 200 || response.StatusCode >= 300 { 7914 return out, metadata, awsRestjson1_deserializeOpErrorListPolicyAttachments(response, &metadata) 7915 } 7916 output := &ListPolicyAttachmentsOutput{} 7917 out.Result = output 7918 7919 var buff [1024]byte 7920 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7921 7922 body := io.TeeReader(response.Body, ringBuffer) 7923 7924 decoder := json.NewDecoder(body) 7925 decoder.UseNumber() 7926 var shape interface{} 7927 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 7928 var snapshot bytes.Buffer 7929 io.Copy(&snapshot, ringBuffer) 7930 err = &smithy.DeserializationError{ 7931 Err: fmt.Errorf("failed to decode response body, %w", err), 7932 Snapshot: snapshot.Bytes(), 7933 } 7934 return out, metadata, err 7935 } 7936 7937 err = awsRestjson1_deserializeOpDocumentListPolicyAttachmentsOutput(&output, shape) 7938 if err != nil { 7939 var snapshot bytes.Buffer 7940 io.Copy(&snapshot, ringBuffer) 7941 return out, metadata, &smithy.DeserializationError{ 7942 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 7943 Snapshot: snapshot.Bytes(), 7944 } 7945 } 7946 7947 return out, metadata, err 7948} 7949 7950func awsRestjson1_deserializeOpErrorListPolicyAttachments(response *smithyhttp.Response, metadata *middleware.Metadata) error { 7951 var errorBuffer bytes.Buffer 7952 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 7953 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 7954 } 7955 errorBody := bytes.NewReader(errorBuffer.Bytes()) 7956 7957 errorCode := "UnknownError" 7958 errorMessage := errorCode 7959 7960 code := response.Header.Get("X-Amzn-ErrorType") 7961 if len(code) != 0 { 7962 errorCode = restjson.SanitizeErrorCode(code) 7963 } 7964 7965 var buff [1024]byte 7966 ringBuffer := smithyio.NewRingBuffer(buff[:]) 7967 7968 body := io.TeeReader(errorBody, ringBuffer) 7969 decoder := json.NewDecoder(body) 7970 decoder.UseNumber() 7971 code, message, err := restjson.GetErrorInfo(decoder) 7972 if err != nil { 7973 var snapshot bytes.Buffer 7974 io.Copy(&snapshot, ringBuffer) 7975 err = &smithy.DeserializationError{ 7976 Err: fmt.Errorf("failed to decode response body, %w", err), 7977 Snapshot: snapshot.Bytes(), 7978 } 7979 return err 7980 } 7981 7982 errorBody.Seek(0, io.SeekStart) 7983 if len(code) != 0 { 7984 errorCode = restjson.SanitizeErrorCode(code) 7985 } 7986 if len(message) != 0 { 7987 errorMessage = message 7988 } 7989 7990 switch { 7991 case strings.EqualFold("AccessDeniedException", errorCode): 7992 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 7993 7994 case strings.EqualFold("DirectoryNotEnabledException", errorCode): 7995 return awsRestjson1_deserializeErrorDirectoryNotEnabledException(response, errorBody) 7996 7997 case strings.EqualFold("InternalServiceException", errorCode): 7998 return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody) 7999 8000 case strings.EqualFold("InvalidArnException", errorCode): 8001 return awsRestjson1_deserializeErrorInvalidArnException(response, errorBody) 8002 8003 case strings.EqualFold("InvalidNextTokenException", errorCode): 8004 return awsRestjson1_deserializeErrorInvalidNextTokenException(response, errorBody) 8005 8006 case strings.EqualFold("LimitExceededException", errorCode): 8007 return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody) 8008 8009 case strings.EqualFold("NotPolicyException", errorCode): 8010 return awsRestjson1_deserializeErrorNotPolicyException(response, errorBody) 8011 8012 case strings.EqualFold("ResourceNotFoundException", errorCode): 8013 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 8014 8015 case strings.EqualFold("RetryableConflictException", errorCode): 8016 return awsRestjson1_deserializeErrorRetryableConflictException(response, errorBody) 8017 8018 case strings.EqualFold("ValidationException", errorCode): 8019 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 8020 8021 default: 8022 genericError := &smithy.GenericAPIError{ 8023 Code: errorCode, 8024 Message: errorMessage, 8025 } 8026 return genericError 8027 8028 } 8029} 8030 8031func awsRestjson1_deserializeOpDocumentListPolicyAttachmentsOutput(v **ListPolicyAttachmentsOutput, value interface{}) error { 8032 if v == nil { 8033 return fmt.Errorf("unexpected nil of type %T", v) 8034 } 8035 if value == nil { 8036 return nil 8037 } 8038 8039 shape, ok := value.(map[string]interface{}) 8040 if !ok { 8041 return fmt.Errorf("unexpected JSON type %v", value) 8042 } 8043 8044 var sv *ListPolicyAttachmentsOutput 8045 if *v == nil { 8046 sv = &ListPolicyAttachmentsOutput{} 8047 } else { 8048 sv = *v 8049 } 8050 8051 for key, value := range shape { 8052 switch key { 8053 case "NextToken": 8054 if value != nil { 8055 jtv, ok := value.(string) 8056 if !ok { 8057 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 8058 } 8059 sv.NextToken = ptr.String(jtv) 8060 } 8061 8062 case "ObjectIdentifiers": 8063 if err := awsRestjson1_deserializeDocumentObjectIdentifierList(&sv.ObjectIdentifiers, value); err != nil { 8064 return err 8065 } 8066 8067 default: 8068 _, _ = key, value 8069 8070 } 8071 } 8072 *v = sv 8073 return nil 8074} 8075 8076type awsRestjson1_deserializeOpListPublishedSchemaArns struct { 8077} 8078 8079func (*awsRestjson1_deserializeOpListPublishedSchemaArns) ID() string { 8080 return "OperationDeserializer" 8081} 8082 8083func (m *awsRestjson1_deserializeOpListPublishedSchemaArns) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 8084 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 8085) { 8086 out, metadata, err = next.HandleDeserialize(ctx, in) 8087 if err != nil { 8088 return out, metadata, err 8089 } 8090 8091 response, ok := out.RawResponse.(*smithyhttp.Response) 8092 if !ok { 8093 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 8094 } 8095 8096 if response.StatusCode < 200 || response.StatusCode >= 300 { 8097 return out, metadata, awsRestjson1_deserializeOpErrorListPublishedSchemaArns(response, &metadata) 8098 } 8099 output := &ListPublishedSchemaArnsOutput{} 8100 out.Result = output 8101 8102 var buff [1024]byte 8103 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8104 8105 body := io.TeeReader(response.Body, ringBuffer) 8106 8107 decoder := json.NewDecoder(body) 8108 decoder.UseNumber() 8109 var shape interface{} 8110 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 8111 var snapshot bytes.Buffer 8112 io.Copy(&snapshot, ringBuffer) 8113 err = &smithy.DeserializationError{ 8114 Err: fmt.Errorf("failed to decode response body, %w", err), 8115 Snapshot: snapshot.Bytes(), 8116 } 8117 return out, metadata, err 8118 } 8119 8120 err = awsRestjson1_deserializeOpDocumentListPublishedSchemaArnsOutput(&output, shape) 8121 if err != nil { 8122 var snapshot bytes.Buffer 8123 io.Copy(&snapshot, ringBuffer) 8124 return out, metadata, &smithy.DeserializationError{ 8125 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 8126 Snapshot: snapshot.Bytes(), 8127 } 8128 } 8129 8130 return out, metadata, err 8131} 8132 8133func awsRestjson1_deserializeOpErrorListPublishedSchemaArns(response *smithyhttp.Response, metadata *middleware.Metadata) error { 8134 var errorBuffer bytes.Buffer 8135 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 8136 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 8137 } 8138 errorBody := bytes.NewReader(errorBuffer.Bytes()) 8139 8140 errorCode := "UnknownError" 8141 errorMessage := errorCode 8142 8143 code := response.Header.Get("X-Amzn-ErrorType") 8144 if len(code) != 0 { 8145 errorCode = restjson.SanitizeErrorCode(code) 8146 } 8147 8148 var buff [1024]byte 8149 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8150 8151 body := io.TeeReader(errorBody, ringBuffer) 8152 decoder := json.NewDecoder(body) 8153 decoder.UseNumber() 8154 code, message, err := restjson.GetErrorInfo(decoder) 8155 if err != nil { 8156 var snapshot bytes.Buffer 8157 io.Copy(&snapshot, ringBuffer) 8158 err = &smithy.DeserializationError{ 8159 Err: fmt.Errorf("failed to decode response body, %w", err), 8160 Snapshot: snapshot.Bytes(), 8161 } 8162 return err 8163 } 8164 8165 errorBody.Seek(0, io.SeekStart) 8166 if len(code) != 0 { 8167 errorCode = restjson.SanitizeErrorCode(code) 8168 } 8169 if len(message) != 0 { 8170 errorMessage = message 8171 } 8172 8173 switch { 8174 case strings.EqualFold("AccessDeniedException", errorCode): 8175 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 8176 8177 case strings.EqualFold("InternalServiceException", errorCode): 8178 return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody) 8179 8180 case strings.EqualFold("InvalidArnException", errorCode): 8181 return awsRestjson1_deserializeErrorInvalidArnException(response, errorBody) 8182 8183 case strings.EqualFold("InvalidNextTokenException", errorCode): 8184 return awsRestjson1_deserializeErrorInvalidNextTokenException(response, errorBody) 8185 8186 case strings.EqualFold("LimitExceededException", errorCode): 8187 return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody) 8188 8189 case strings.EqualFold("ResourceNotFoundException", errorCode): 8190 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 8191 8192 case strings.EqualFold("RetryableConflictException", errorCode): 8193 return awsRestjson1_deserializeErrorRetryableConflictException(response, errorBody) 8194 8195 case strings.EqualFold("ValidationException", errorCode): 8196 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 8197 8198 default: 8199 genericError := &smithy.GenericAPIError{ 8200 Code: errorCode, 8201 Message: errorMessage, 8202 } 8203 return genericError 8204 8205 } 8206} 8207 8208func awsRestjson1_deserializeOpDocumentListPublishedSchemaArnsOutput(v **ListPublishedSchemaArnsOutput, value interface{}) error { 8209 if v == nil { 8210 return fmt.Errorf("unexpected nil of type %T", v) 8211 } 8212 if value == nil { 8213 return nil 8214 } 8215 8216 shape, ok := value.(map[string]interface{}) 8217 if !ok { 8218 return fmt.Errorf("unexpected JSON type %v", value) 8219 } 8220 8221 var sv *ListPublishedSchemaArnsOutput 8222 if *v == nil { 8223 sv = &ListPublishedSchemaArnsOutput{} 8224 } else { 8225 sv = *v 8226 } 8227 8228 for key, value := range shape { 8229 switch key { 8230 case "NextToken": 8231 if value != nil { 8232 jtv, ok := value.(string) 8233 if !ok { 8234 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 8235 } 8236 sv.NextToken = ptr.String(jtv) 8237 } 8238 8239 case "SchemaArns": 8240 if err := awsRestjson1_deserializeDocumentArns(&sv.SchemaArns, value); err != nil { 8241 return err 8242 } 8243 8244 default: 8245 _, _ = key, value 8246 8247 } 8248 } 8249 *v = sv 8250 return nil 8251} 8252 8253type awsRestjson1_deserializeOpListTagsForResource struct { 8254} 8255 8256func (*awsRestjson1_deserializeOpListTagsForResource) ID() string { 8257 return "OperationDeserializer" 8258} 8259 8260func (m *awsRestjson1_deserializeOpListTagsForResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 8261 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 8262) { 8263 out, metadata, err = next.HandleDeserialize(ctx, in) 8264 if err != nil { 8265 return out, metadata, err 8266 } 8267 8268 response, ok := out.RawResponse.(*smithyhttp.Response) 8269 if !ok { 8270 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 8271 } 8272 8273 if response.StatusCode < 200 || response.StatusCode >= 300 { 8274 return out, metadata, awsRestjson1_deserializeOpErrorListTagsForResource(response, &metadata) 8275 } 8276 output := &ListTagsForResourceOutput{} 8277 out.Result = output 8278 8279 var buff [1024]byte 8280 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8281 8282 body := io.TeeReader(response.Body, ringBuffer) 8283 8284 decoder := json.NewDecoder(body) 8285 decoder.UseNumber() 8286 var shape interface{} 8287 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 8288 var snapshot bytes.Buffer 8289 io.Copy(&snapshot, ringBuffer) 8290 err = &smithy.DeserializationError{ 8291 Err: fmt.Errorf("failed to decode response body, %w", err), 8292 Snapshot: snapshot.Bytes(), 8293 } 8294 return out, metadata, err 8295 } 8296 8297 err = awsRestjson1_deserializeOpDocumentListTagsForResourceOutput(&output, shape) 8298 if err != nil { 8299 var snapshot bytes.Buffer 8300 io.Copy(&snapshot, ringBuffer) 8301 return out, metadata, &smithy.DeserializationError{ 8302 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 8303 Snapshot: snapshot.Bytes(), 8304 } 8305 } 8306 8307 return out, metadata, err 8308} 8309 8310func awsRestjson1_deserializeOpErrorListTagsForResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 8311 var errorBuffer bytes.Buffer 8312 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 8313 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 8314 } 8315 errorBody := bytes.NewReader(errorBuffer.Bytes()) 8316 8317 errorCode := "UnknownError" 8318 errorMessage := errorCode 8319 8320 code := response.Header.Get("X-Amzn-ErrorType") 8321 if len(code) != 0 { 8322 errorCode = restjson.SanitizeErrorCode(code) 8323 } 8324 8325 var buff [1024]byte 8326 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8327 8328 body := io.TeeReader(errorBody, ringBuffer) 8329 decoder := json.NewDecoder(body) 8330 decoder.UseNumber() 8331 code, message, err := restjson.GetErrorInfo(decoder) 8332 if err != nil { 8333 var snapshot bytes.Buffer 8334 io.Copy(&snapshot, ringBuffer) 8335 err = &smithy.DeserializationError{ 8336 Err: fmt.Errorf("failed to decode response body, %w", err), 8337 Snapshot: snapshot.Bytes(), 8338 } 8339 return err 8340 } 8341 8342 errorBody.Seek(0, io.SeekStart) 8343 if len(code) != 0 { 8344 errorCode = restjson.SanitizeErrorCode(code) 8345 } 8346 if len(message) != 0 { 8347 errorMessage = message 8348 } 8349 8350 switch { 8351 case strings.EqualFold("AccessDeniedException", errorCode): 8352 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 8353 8354 case strings.EqualFold("InternalServiceException", errorCode): 8355 return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody) 8356 8357 case strings.EqualFold("InvalidArnException", errorCode): 8358 return awsRestjson1_deserializeErrorInvalidArnException(response, errorBody) 8359 8360 case strings.EqualFold("InvalidTaggingRequestException", errorCode): 8361 return awsRestjson1_deserializeErrorInvalidTaggingRequestException(response, errorBody) 8362 8363 case strings.EqualFold("LimitExceededException", errorCode): 8364 return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody) 8365 8366 case strings.EqualFold("ResourceNotFoundException", errorCode): 8367 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 8368 8369 case strings.EqualFold("RetryableConflictException", errorCode): 8370 return awsRestjson1_deserializeErrorRetryableConflictException(response, errorBody) 8371 8372 case strings.EqualFold("ValidationException", errorCode): 8373 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 8374 8375 default: 8376 genericError := &smithy.GenericAPIError{ 8377 Code: errorCode, 8378 Message: errorMessage, 8379 } 8380 return genericError 8381 8382 } 8383} 8384 8385func awsRestjson1_deserializeOpDocumentListTagsForResourceOutput(v **ListTagsForResourceOutput, value interface{}) error { 8386 if v == nil { 8387 return fmt.Errorf("unexpected nil of type %T", v) 8388 } 8389 if value == nil { 8390 return nil 8391 } 8392 8393 shape, ok := value.(map[string]interface{}) 8394 if !ok { 8395 return fmt.Errorf("unexpected JSON type %v", value) 8396 } 8397 8398 var sv *ListTagsForResourceOutput 8399 if *v == nil { 8400 sv = &ListTagsForResourceOutput{} 8401 } else { 8402 sv = *v 8403 } 8404 8405 for key, value := range shape { 8406 switch key { 8407 case "NextToken": 8408 if value != nil { 8409 jtv, ok := value.(string) 8410 if !ok { 8411 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 8412 } 8413 sv.NextToken = ptr.String(jtv) 8414 } 8415 8416 case "Tags": 8417 if err := awsRestjson1_deserializeDocumentTagList(&sv.Tags, value); err != nil { 8418 return err 8419 } 8420 8421 default: 8422 _, _ = key, value 8423 8424 } 8425 } 8426 *v = sv 8427 return nil 8428} 8429 8430type awsRestjson1_deserializeOpListTypedLinkFacetAttributes struct { 8431} 8432 8433func (*awsRestjson1_deserializeOpListTypedLinkFacetAttributes) ID() string { 8434 return "OperationDeserializer" 8435} 8436 8437func (m *awsRestjson1_deserializeOpListTypedLinkFacetAttributes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 8438 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 8439) { 8440 out, metadata, err = next.HandleDeserialize(ctx, in) 8441 if err != nil { 8442 return out, metadata, err 8443 } 8444 8445 response, ok := out.RawResponse.(*smithyhttp.Response) 8446 if !ok { 8447 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 8448 } 8449 8450 if response.StatusCode < 200 || response.StatusCode >= 300 { 8451 return out, metadata, awsRestjson1_deserializeOpErrorListTypedLinkFacetAttributes(response, &metadata) 8452 } 8453 output := &ListTypedLinkFacetAttributesOutput{} 8454 out.Result = output 8455 8456 var buff [1024]byte 8457 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8458 8459 body := io.TeeReader(response.Body, ringBuffer) 8460 8461 decoder := json.NewDecoder(body) 8462 decoder.UseNumber() 8463 var shape interface{} 8464 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 8465 var snapshot bytes.Buffer 8466 io.Copy(&snapshot, ringBuffer) 8467 err = &smithy.DeserializationError{ 8468 Err: fmt.Errorf("failed to decode response body, %w", err), 8469 Snapshot: snapshot.Bytes(), 8470 } 8471 return out, metadata, err 8472 } 8473 8474 err = awsRestjson1_deserializeOpDocumentListTypedLinkFacetAttributesOutput(&output, shape) 8475 if err != nil { 8476 var snapshot bytes.Buffer 8477 io.Copy(&snapshot, ringBuffer) 8478 return out, metadata, &smithy.DeserializationError{ 8479 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 8480 Snapshot: snapshot.Bytes(), 8481 } 8482 } 8483 8484 return out, metadata, err 8485} 8486 8487func awsRestjson1_deserializeOpErrorListTypedLinkFacetAttributes(response *smithyhttp.Response, metadata *middleware.Metadata) error { 8488 var errorBuffer bytes.Buffer 8489 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 8490 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 8491 } 8492 errorBody := bytes.NewReader(errorBuffer.Bytes()) 8493 8494 errorCode := "UnknownError" 8495 errorMessage := errorCode 8496 8497 code := response.Header.Get("X-Amzn-ErrorType") 8498 if len(code) != 0 { 8499 errorCode = restjson.SanitizeErrorCode(code) 8500 } 8501 8502 var buff [1024]byte 8503 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8504 8505 body := io.TeeReader(errorBody, ringBuffer) 8506 decoder := json.NewDecoder(body) 8507 decoder.UseNumber() 8508 code, message, err := restjson.GetErrorInfo(decoder) 8509 if err != nil { 8510 var snapshot bytes.Buffer 8511 io.Copy(&snapshot, ringBuffer) 8512 err = &smithy.DeserializationError{ 8513 Err: fmt.Errorf("failed to decode response body, %w", err), 8514 Snapshot: snapshot.Bytes(), 8515 } 8516 return err 8517 } 8518 8519 errorBody.Seek(0, io.SeekStart) 8520 if len(code) != 0 { 8521 errorCode = restjson.SanitizeErrorCode(code) 8522 } 8523 if len(message) != 0 { 8524 errorMessage = message 8525 } 8526 8527 switch { 8528 case strings.EqualFold("AccessDeniedException", errorCode): 8529 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 8530 8531 case strings.EqualFold("FacetNotFoundException", errorCode): 8532 return awsRestjson1_deserializeErrorFacetNotFoundException(response, errorBody) 8533 8534 case strings.EqualFold("InternalServiceException", errorCode): 8535 return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody) 8536 8537 case strings.EqualFold("InvalidArnException", errorCode): 8538 return awsRestjson1_deserializeErrorInvalidArnException(response, errorBody) 8539 8540 case strings.EqualFold("InvalidNextTokenException", errorCode): 8541 return awsRestjson1_deserializeErrorInvalidNextTokenException(response, errorBody) 8542 8543 case strings.EqualFold("LimitExceededException", errorCode): 8544 return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody) 8545 8546 case strings.EqualFold("ResourceNotFoundException", errorCode): 8547 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 8548 8549 case strings.EqualFold("RetryableConflictException", errorCode): 8550 return awsRestjson1_deserializeErrorRetryableConflictException(response, errorBody) 8551 8552 case strings.EqualFold("ValidationException", errorCode): 8553 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 8554 8555 default: 8556 genericError := &smithy.GenericAPIError{ 8557 Code: errorCode, 8558 Message: errorMessage, 8559 } 8560 return genericError 8561 8562 } 8563} 8564 8565func awsRestjson1_deserializeOpDocumentListTypedLinkFacetAttributesOutput(v **ListTypedLinkFacetAttributesOutput, value interface{}) error { 8566 if v == nil { 8567 return fmt.Errorf("unexpected nil of type %T", v) 8568 } 8569 if value == nil { 8570 return nil 8571 } 8572 8573 shape, ok := value.(map[string]interface{}) 8574 if !ok { 8575 return fmt.Errorf("unexpected JSON type %v", value) 8576 } 8577 8578 var sv *ListTypedLinkFacetAttributesOutput 8579 if *v == nil { 8580 sv = &ListTypedLinkFacetAttributesOutput{} 8581 } else { 8582 sv = *v 8583 } 8584 8585 for key, value := range shape { 8586 switch key { 8587 case "Attributes": 8588 if err := awsRestjson1_deserializeDocumentTypedLinkAttributeDefinitionList(&sv.Attributes, value); err != nil { 8589 return err 8590 } 8591 8592 case "NextToken": 8593 if value != nil { 8594 jtv, ok := value.(string) 8595 if !ok { 8596 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 8597 } 8598 sv.NextToken = ptr.String(jtv) 8599 } 8600 8601 default: 8602 _, _ = key, value 8603 8604 } 8605 } 8606 *v = sv 8607 return nil 8608} 8609 8610type awsRestjson1_deserializeOpListTypedLinkFacetNames struct { 8611} 8612 8613func (*awsRestjson1_deserializeOpListTypedLinkFacetNames) ID() string { 8614 return "OperationDeserializer" 8615} 8616 8617func (m *awsRestjson1_deserializeOpListTypedLinkFacetNames) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 8618 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 8619) { 8620 out, metadata, err = next.HandleDeserialize(ctx, in) 8621 if err != nil { 8622 return out, metadata, err 8623 } 8624 8625 response, ok := out.RawResponse.(*smithyhttp.Response) 8626 if !ok { 8627 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 8628 } 8629 8630 if response.StatusCode < 200 || response.StatusCode >= 300 { 8631 return out, metadata, awsRestjson1_deserializeOpErrorListTypedLinkFacetNames(response, &metadata) 8632 } 8633 output := &ListTypedLinkFacetNamesOutput{} 8634 out.Result = output 8635 8636 var buff [1024]byte 8637 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8638 8639 body := io.TeeReader(response.Body, ringBuffer) 8640 8641 decoder := json.NewDecoder(body) 8642 decoder.UseNumber() 8643 var shape interface{} 8644 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 8645 var snapshot bytes.Buffer 8646 io.Copy(&snapshot, ringBuffer) 8647 err = &smithy.DeserializationError{ 8648 Err: fmt.Errorf("failed to decode response body, %w", err), 8649 Snapshot: snapshot.Bytes(), 8650 } 8651 return out, metadata, err 8652 } 8653 8654 err = awsRestjson1_deserializeOpDocumentListTypedLinkFacetNamesOutput(&output, shape) 8655 if err != nil { 8656 var snapshot bytes.Buffer 8657 io.Copy(&snapshot, ringBuffer) 8658 return out, metadata, &smithy.DeserializationError{ 8659 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 8660 Snapshot: snapshot.Bytes(), 8661 } 8662 } 8663 8664 return out, metadata, err 8665} 8666 8667func awsRestjson1_deserializeOpErrorListTypedLinkFacetNames(response *smithyhttp.Response, metadata *middleware.Metadata) error { 8668 var errorBuffer bytes.Buffer 8669 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 8670 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 8671 } 8672 errorBody := bytes.NewReader(errorBuffer.Bytes()) 8673 8674 errorCode := "UnknownError" 8675 errorMessage := errorCode 8676 8677 code := response.Header.Get("X-Amzn-ErrorType") 8678 if len(code) != 0 { 8679 errorCode = restjson.SanitizeErrorCode(code) 8680 } 8681 8682 var buff [1024]byte 8683 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8684 8685 body := io.TeeReader(errorBody, ringBuffer) 8686 decoder := json.NewDecoder(body) 8687 decoder.UseNumber() 8688 code, message, err := restjson.GetErrorInfo(decoder) 8689 if err != nil { 8690 var snapshot bytes.Buffer 8691 io.Copy(&snapshot, ringBuffer) 8692 err = &smithy.DeserializationError{ 8693 Err: fmt.Errorf("failed to decode response body, %w", err), 8694 Snapshot: snapshot.Bytes(), 8695 } 8696 return err 8697 } 8698 8699 errorBody.Seek(0, io.SeekStart) 8700 if len(code) != 0 { 8701 errorCode = restjson.SanitizeErrorCode(code) 8702 } 8703 if len(message) != 0 { 8704 errorMessage = message 8705 } 8706 8707 switch { 8708 case strings.EqualFold("AccessDeniedException", errorCode): 8709 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 8710 8711 case strings.EqualFold("InternalServiceException", errorCode): 8712 return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody) 8713 8714 case strings.EqualFold("InvalidArnException", errorCode): 8715 return awsRestjson1_deserializeErrorInvalidArnException(response, errorBody) 8716 8717 case strings.EqualFold("InvalidNextTokenException", errorCode): 8718 return awsRestjson1_deserializeErrorInvalidNextTokenException(response, errorBody) 8719 8720 case strings.EqualFold("LimitExceededException", errorCode): 8721 return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody) 8722 8723 case strings.EqualFold("ResourceNotFoundException", errorCode): 8724 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 8725 8726 case strings.EqualFold("RetryableConflictException", errorCode): 8727 return awsRestjson1_deserializeErrorRetryableConflictException(response, errorBody) 8728 8729 case strings.EqualFold("ValidationException", errorCode): 8730 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 8731 8732 default: 8733 genericError := &smithy.GenericAPIError{ 8734 Code: errorCode, 8735 Message: errorMessage, 8736 } 8737 return genericError 8738 8739 } 8740} 8741 8742func awsRestjson1_deserializeOpDocumentListTypedLinkFacetNamesOutput(v **ListTypedLinkFacetNamesOutput, value interface{}) error { 8743 if v == nil { 8744 return fmt.Errorf("unexpected nil of type %T", v) 8745 } 8746 if value == nil { 8747 return nil 8748 } 8749 8750 shape, ok := value.(map[string]interface{}) 8751 if !ok { 8752 return fmt.Errorf("unexpected JSON type %v", value) 8753 } 8754 8755 var sv *ListTypedLinkFacetNamesOutput 8756 if *v == nil { 8757 sv = &ListTypedLinkFacetNamesOutput{} 8758 } else { 8759 sv = *v 8760 } 8761 8762 for key, value := range shape { 8763 switch key { 8764 case "FacetNames": 8765 if err := awsRestjson1_deserializeDocumentTypedLinkNameList(&sv.FacetNames, value); err != nil { 8766 return err 8767 } 8768 8769 case "NextToken": 8770 if value != nil { 8771 jtv, ok := value.(string) 8772 if !ok { 8773 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 8774 } 8775 sv.NextToken = ptr.String(jtv) 8776 } 8777 8778 default: 8779 _, _ = key, value 8780 8781 } 8782 } 8783 *v = sv 8784 return nil 8785} 8786 8787type awsRestjson1_deserializeOpLookupPolicy struct { 8788} 8789 8790func (*awsRestjson1_deserializeOpLookupPolicy) ID() string { 8791 return "OperationDeserializer" 8792} 8793 8794func (m *awsRestjson1_deserializeOpLookupPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 8795 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 8796) { 8797 out, metadata, err = next.HandleDeserialize(ctx, in) 8798 if err != nil { 8799 return out, metadata, err 8800 } 8801 8802 response, ok := out.RawResponse.(*smithyhttp.Response) 8803 if !ok { 8804 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 8805 } 8806 8807 if response.StatusCode < 200 || response.StatusCode >= 300 { 8808 return out, metadata, awsRestjson1_deserializeOpErrorLookupPolicy(response, &metadata) 8809 } 8810 output := &LookupPolicyOutput{} 8811 out.Result = output 8812 8813 var buff [1024]byte 8814 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8815 8816 body := io.TeeReader(response.Body, ringBuffer) 8817 8818 decoder := json.NewDecoder(body) 8819 decoder.UseNumber() 8820 var shape interface{} 8821 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 8822 var snapshot bytes.Buffer 8823 io.Copy(&snapshot, ringBuffer) 8824 err = &smithy.DeserializationError{ 8825 Err: fmt.Errorf("failed to decode response body, %w", err), 8826 Snapshot: snapshot.Bytes(), 8827 } 8828 return out, metadata, err 8829 } 8830 8831 err = awsRestjson1_deserializeOpDocumentLookupPolicyOutput(&output, shape) 8832 if err != nil { 8833 var snapshot bytes.Buffer 8834 io.Copy(&snapshot, ringBuffer) 8835 return out, metadata, &smithy.DeserializationError{ 8836 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 8837 Snapshot: snapshot.Bytes(), 8838 } 8839 } 8840 8841 return out, metadata, err 8842} 8843 8844func awsRestjson1_deserializeOpErrorLookupPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error { 8845 var errorBuffer bytes.Buffer 8846 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 8847 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 8848 } 8849 errorBody := bytes.NewReader(errorBuffer.Bytes()) 8850 8851 errorCode := "UnknownError" 8852 errorMessage := errorCode 8853 8854 code := response.Header.Get("X-Amzn-ErrorType") 8855 if len(code) != 0 { 8856 errorCode = restjson.SanitizeErrorCode(code) 8857 } 8858 8859 var buff [1024]byte 8860 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8861 8862 body := io.TeeReader(errorBody, ringBuffer) 8863 decoder := json.NewDecoder(body) 8864 decoder.UseNumber() 8865 code, message, err := restjson.GetErrorInfo(decoder) 8866 if err != nil { 8867 var snapshot bytes.Buffer 8868 io.Copy(&snapshot, ringBuffer) 8869 err = &smithy.DeserializationError{ 8870 Err: fmt.Errorf("failed to decode response body, %w", err), 8871 Snapshot: snapshot.Bytes(), 8872 } 8873 return err 8874 } 8875 8876 errorBody.Seek(0, io.SeekStart) 8877 if len(code) != 0 { 8878 errorCode = restjson.SanitizeErrorCode(code) 8879 } 8880 if len(message) != 0 { 8881 errorMessage = message 8882 } 8883 8884 switch { 8885 case strings.EqualFold("AccessDeniedException", errorCode): 8886 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 8887 8888 case strings.EqualFold("DirectoryNotEnabledException", errorCode): 8889 return awsRestjson1_deserializeErrorDirectoryNotEnabledException(response, errorBody) 8890 8891 case strings.EqualFold("InternalServiceException", errorCode): 8892 return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody) 8893 8894 case strings.EqualFold("InvalidArnException", errorCode): 8895 return awsRestjson1_deserializeErrorInvalidArnException(response, errorBody) 8896 8897 case strings.EqualFold("InvalidNextTokenException", errorCode): 8898 return awsRestjson1_deserializeErrorInvalidNextTokenException(response, errorBody) 8899 8900 case strings.EqualFold("LimitExceededException", errorCode): 8901 return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody) 8902 8903 case strings.EqualFold("ResourceNotFoundException", errorCode): 8904 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 8905 8906 case strings.EqualFold("RetryableConflictException", errorCode): 8907 return awsRestjson1_deserializeErrorRetryableConflictException(response, errorBody) 8908 8909 case strings.EqualFold("ValidationException", errorCode): 8910 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 8911 8912 default: 8913 genericError := &smithy.GenericAPIError{ 8914 Code: errorCode, 8915 Message: errorMessage, 8916 } 8917 return genericError 8918 8919 } 8920} 8921 8922func awsRestjson1_deserializeOpDocumentLookupPolicyOutput(v **LookupPolicyOutput, value interface{}) error { 8923 if v == nil { 8924 return fmt.Errorf("unexpected nil of type %T", v) 8925 } 8926 if value == nil { 8927 return nil 8928 } 8929 8930 shape, ok := value.(map[string]interface{}) 8931 if !ok { 8932 return fmt.Errorf("unexpected JSON type %v", value) 8933 } 8934 8935 var sv *LookupPolicyOutput 8936 if *v == nil { 8937 sv = &LookupPolicyOutput{} 8938 } else { 8939 sv = *v 8940 } 8941 8942 for key, value := range shape { 8943 switch key { 8944 case "NextToken": 8945 if value != nil { 8946 jtv, ok := value.(string) 8947 if !ok { 8948 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 8949 } 8950 sv.NextToken = ptr.String(jtv) 8951 } 8952 8953 case "PolicyToPathList": 8954 if err := awsRestjson1_deserializeDocumentPolicyToPathList(&sv.PolicyToPathList, value); err != nil { 8955 return err 8956 } 8957 8958 default: 8959 _, _ = key, value 8960 8961 } 8962 } 8963 *v = sv 8964 return nil 8965} 8966 8967type awsRestjson1_deserializeOpPublishSchema struct { 8968} 8969 8970func (*awsRestjson1_deserializeOpPublishSchema) ID() string { 8971 return "OperationDeserializer" 8972} 8973 8974func (m *awsRestjson1_deserializeOpPublishSchema) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 8975 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 8976) { 8977 out, metadata, err = next.HandleDeserialize(ctx, in) 8978 if err != nil { 8979 return out, metadata, err 8980 } 8981 8982 response, ok := out.RawResponse.(*smithyhttp.Response) 8983 if !ok { 8984 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 8985 } 8986 8987 if response.StatusCode < 200 || response.StatusCode >= 300 { 8988 return out, metadata, awsRestjson1_deserializeOpErrorPublishSchema(response, &metadata) 8989 } 8990 output := &PublishSchemaOutput{} 8991 out.Result = output 8992 8993 var buff [1024]byte 8994 ringBuffer := smithyio.NewRingBuffer(buff[:]) 8995 8996 body := io.TeeReader(response.Body, ringBuffer) 8997 8998 decoder := json.NewDecoder(body) 8999 decoder.UseNumber() 9000 var shape interface{} 9001 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 9002 var snapshot bytes.Buffer 9003 io.Copy(&snapshot, ringBuffer) 9004 err = &smithy.DeserializationError{ 9005 Err: fmt.Errorf("failed to decode response body, %w", err), 9006 Snapshot: snapshot.Bytes(), 9007 } 9008 return out, metadata, err 9009 } 9010 9011 err = awsRestjson1_deserializeOpDocumentPublishSchemaOutput(&output, shape) 9012 if err != nil { 9013 var snapshot bytes.Buffer 9014 io.Copy(&snapshot, ringBuffer) 9015 return out, metadata, &smithy.DeserializationError{ 9016 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 9017 Snapshot: snapshot.Bytes(), 9018 } 9019 } 9020 9021 return out, metadata, err 9022} 9023 9024func awsRestjson1_deserializeOpErrorPublishSchema(response *smithyhttp.Response, metadata *middleware.Metadata) error { 9025 var errorBuffer bytes.Buffer 9026 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 9027 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 9028 } 9029 errorBody := bytes.NewReader(errorBuffer.Bytes()) 9030 9031 errorCode := "UnknownError" 9032 errorMessage := errorCode 9033 9034 code := response.Header.Get("X-Amzn-ErrorType") 9035 if len(code) != 0 { 9036 errorCode = restjson.SanitizeErrorCode(code) 9037 } 9038 9039 var buff [1024]byte 9040 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9041 9042 body := io.TeeReader(errorBody, ringBuffer) 9043 decoder := json.NewDecoder(body) 9044 decoder.UseNumber() 9045 code, message, err := restjson.GetErrorInfo(decoder) 9046 if err != nil { 9047 var snapshot bytes.Buffer 9048 io.Copy(&snapshot, ringBuffer) 9049 err = &smithy.DeserializationError{ 9050 Err: fmt.Errorf("failed to decode response body, %w", err), 9051 Snapshot: snapshot.Bytes(), 9052 } 9053 return err 9054 } 9055 9056 errorBody.Seek(0, io.SeekStart) 9057 if len(code) != 0 { 9058 errorCode = restjson.SanitizeErrorCode(code) 9059 } 9060 if len(message) != 0 { 9061 errorMessage = message 9062 } 9063 9064 switch { 9065 case strings.EqualFold("AccessDeniedException", errorCode): 9066 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 9067 9068 case strings.EqualFold("InternalServiceException", errorCode): 9069 return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody) 9070 9071 case strings.EqualFold("InvalidArnException", errorCode): 9072 return awsRestjson1_deserializeErrorInvalidArnException(response, errorBody) 9073 9074 case strings.EqualFold("LimitExceededException", errorCode): 9075 return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody) 9076 9077 case strings.EqualFold("ResourceNotFoundException", errorCode): 9078 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 9079 9080 case strings.EqualFold("RetryableConflictException", errorCode): 9081 return awsRestjson1_deserializeErrorRetryableConflictException(response, errorBody) 9082 9083 case strings.EqualFold("SchemaAlreadyPublishedException", errorCode): 9084 return awsRestjson1_deserializeErrorSchemaAlreadyPublishedException(response, errorBody) 9085 9086 case strings.EqualFold("ValidationException", errorCode): 9087 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 9088 9089 default: 9090 genericError := &smithy.GenericAPIError{ 9091 Code: errorCode, 9092 Message: errorMessage, 9093 } 9094 return genericError 9095 9096 } 9097} 9098 9099func awsRestjson1_deserializeOpDocumentPublishSchemaOutput(v **PublishSchemaOutput, value interface{}) error { 9100 if v == nil { 9101 return fmt.Errorf("unexpected nil of type %T", v) 9102 } 9103 if value == nil { 9104 return nil 9105 } 9106 9107 shape, ok := value.(map[string]interface{}) 9108 if !ok { 9109 return fmt.Errorf("unexpected JSON type %v", value) 9110 } 9111 9112 var sv *PublishSchemaOutput 9113 if *v == nil { 9114 sv = &PublishSchemaOutput{} 9115 } else { 9116 sv = *v 9117 } 9118 9119 for key, value := range shape { 9120 switch key { 9121 case "PublishedSchemaArn": 9122 if value != nil { 9123 jtv, ok := value.(string) 9124 if !ok { 9125 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 9126 } 9127 sv.PublishedSchemaArn = ptr.String(jtv) 9128 } 9129 9130 default: 9131 _, _ = key, value 9132 9133 } 9134 } 9135 *v = sv 9136 return nil 9137} 9138 9139type awsRestjson1_deserializeOpPutSchemaFromJson struct { 9140} 9141 9142func (*awsRestjson1_deserializeOpPutSchemaFromJson) ID() string { 9143 return "OperationDeserializer" 9144} 9145 9146func (m *awsRestjson1_deserializeOpPutSchemaFromJson) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 9147 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 9148) { 9149 out, metadata, err = next.HandleDeserialize(ctx, in) 9150 if err != nil { 9151 return out, metadata, err 9152 } 9153 9154 response, ok := out.RawResponse.(*smithyhttp.Response) 9155 if !ok { 9156 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 9157 } 9158 9159 if response.StatusCode < 200 || response.StatusCode >= 300 { 9160 return out, metadata, awsRestjson1_deserializeOpErrorPutSchemaFromJson(response, &metadata) 9161 } 9162 output := &PutSchemaFromJsonOutput{} 9163 out.Result = output 9164 9165 var buff [1024]byte 9166 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9167 9168 body := io.TeeReader(response.Body, ringBuffer) 9169 9170 decoder := json.NewDecoder(body) 9171 decoder.UseNumber() 9172 var shape interface{} 9173 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 9174 var snapshot bytes.Buffer 9175 io.Copy(&snapshot, ringBuffer) 9176 err = &smithy.DeserializationError{ 9177 Err: fmt.Errorf("failed to decode response body, %w", err), 9178 Snapshot: snapshot.Bytes(), 9179 } 9180 return out, metadata, err 9181 } 9182 9183 err = awsRestjson1_deserializeOpDocumentPutSchemaFromJsonOutput(&output, shape) 9184 if err != nil { 9185 var snapshot bytes.Buffer 9186 io.Copy(&snapshot, ringBuffer) 9187 return out, metadata, &smithy.DeserializationError{ 9188 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 9189 Snapshot: snapshot.Bytes(), 9190 } 9191 } 9192 9193 return out, metadata, err 9194} 9195 9196func awsRestjson1_deserializeOpErrorPutSchemaFromJson(response *smithyhttp.Response, metadata *middleware.Metadata) error { 9197 var errorBuffer bytes.Buffer 9198 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 9199 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 9200 } 9201 errorBody := bytes.NewReader(errorBuffer.Bytes()) 9202 9203 errorCode := "UnknownError" 9204 errorMessage := errorCode 9205 9206 code := response.Header.Get("X-Amzn-ErrorType") 9207 if len(code) != 0 { 9208 errorCode = restjson.SanitizeErrorCode(code) 9209 } 9210 9211 var buff [1024]byte 9212 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9213 9214 body := io.TeeReader(errorBody, ringBuffer) 9215 decoder := json.NewDecoder(body) 9216 decoder.UseNumber() 9217 code, message, err := restjson.GetErrorInfo(decoder) 9218 if err != nil { 9219 var snapshot bytes.Buffer 9220 io.Copy(&snapshot, ringBuffer) 9221 err = &smithy.DeserializationError{ 9222 Err: fmt.Errorf("failed to decode response body, %w", err), 9223 Snapshot: snapshot.Bytes(), 9224 } 9225 return err 9226 } 9227 9228 errorBody.Seek(0, io.SeekStart) 9229 if len(code) != 0 { 9230 errorCode = restjson.SanitizeErrorCode(code) 9231 } 9232 if len(message) != 0 { 9233 errorMessage = message 9234 } 9235 9236 switch { 9237 case strings.EqualFold("AccessDeniedException", errorCode): 9238 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 9239 9240 case strings.EqualFold("InternalServiceException", errorCode): 9241 return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody) 9242 9243 case strings.EqualFold("InvalidArnException", errorCode): 9244 return awsRestjson1_deserializeErrorInvalidArnException(response, errorBody) 9245 9246 case strings.EqualFold("InvalidRuleException", errorCode): 9247 return awsRestjson1_deserializeErrorInvalidRuleException(response, errorBody) 9248 9249 case strings.EqualFold("InvalidSchemaDocException", errorCode): 9250 return awsRestjson1_deserializeErrorInvalidSchemaDocException(response, errorBody) 9251 9252 case strings.EqualFold("LimitExceededException", errorCode): 9253 return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody) 9254 9255 case strings.EqualFold("RetryableConflictException", errorCode): 9256 return awsRestjson1_deserializeErrorRetryableConflictException(response, errorBody) 9257 9258 case strings.EqualFold("ValidationException", errorCode): 9259 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 9260 9261 default: 9262 genericError := &smithy.GenericAPIError{ 9263 Code: errorCode, 9264 Message: errorMessage, 9265 } 9266 return genericError 9267 9268 } 9269} 9270 9271func awsRestjson1_deserializeOpDocumentPutSchemaFromJsonOutput(v **PutSchemaFromJsonOutput, value interface{}) error { 9272 if v == nil { 9273 return fmt.Errorf("unexpected nil of type %T", v) 9274 } 9275 if value == nil { 9276 return nil 9277 } 9278 9279 shape, ok := value.(map[string]interface{}) 9280 if !ok { 9281 return fmt.Errorf("unexpected JSON type %v", value) 9282 } 9283 9284 var sv *PutSchemaFromJsonOutput 9285 if *v == nil { 9286 sv = &PutSchemaFromJsonOutput{} 9287 } else { 9288 sv = *v 9289 } 9290 9291 for key, value := range shape { 9292 switch key { 9293 case "Arn": 9294 if value != nil { 9295 jtv, ok := value.(string) 9296 if !ok { 9297 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 9298 } 9299 sv.Arn = ptr.String(jtv) 9300 } 9301 9302 default: 9303 _, _ = key, value 9304 9305 } 9306 } 9307 *v = sv 9308 return nil 9309} 9310 9311type awsRestjson1_deserializeOpRemoveFacetFromObject struct { 9312} 9313 9314func (*awsRestjson1_deserializeOpRemoveFacetFromObject) ID() string { 9315 return "OperationDeserializer" 9316} 9317 9318func (m *awsRestjson1_deserializeOpRemoveFacetFromObject) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 9319 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 9320) { 9321 out, metadata, err = next.HandleDeserialize(ctx, in) 9322 if err != nil { 9323 return out, metadata, err 9324 } 9325 9326 response, ok := out.RawResponse.(*smithyhttp.Response) 9327 if !ok { 9328 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 9329 } 9330 9331 if response.StatusCode < 200 || response.StatusCode >= 300 { 9332 return out, metadata, awsRestjson1_deserializeOpErrorRemoveFacetFromObject(response, &metadata) 9333 } 9334 output := &RemoveFacetFromObjectOutput{} 9335 out.Result = output 9336 9337 return out, metadata, err 9338} 9339 9340func awsRestjson1_deserializeOpErrorRemoveFacetFromObject(response *smithyhttp.Response, metadata *middleware.Metadata) error { 9341 var errorBuffer bytes.Buffer 9342 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 9343 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 9344 } 9345 errorBody := bytes.NewReader(errorBuffer.Bytes()) 9346 9347 errorCode := "UnknownError" 9348 errorMessage := errorCode 9349 9350 code := response.Header.Get("X-Amzn-ErrorType") 9351 if len(code) != 0 { 9352 errorCode = restjson.SanitizeErrorCode(code) 9353 } 9354 9355 var buff [1024]byte 9356 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9357 9358 body := io.TeeReader(errorBody, ringBuffer) 9359 decoder := json.NewDecoder(body) 9360 decoder.UseNumber() 9361 code, message, err := restjson.GetErrorInfo(decoder) 9362 if err != nil { 9363 var snapshot bytes.Buffer 9364 io.Copy(&snapshot, ringBuffer) 9365 err = &smithy.DeserializationError{ 9366 Err: fmt.Errorf("failed to decode response body, %w", err), 9367 Snapshot: snapshot.Bytes(), 9368 } 9369 return err 9370 } 9371 9372 errorBody.Seek(0, io.SeekStart) 9373 if len(code) != 0 { 9374 errorCode = restjson.SanitizeErrorCode(code) 9375 } 9376 if len(message) != 0 { 9377 errorMessage = message 9378 } 9379 9380 switch { 9381 case strings.EqualFold("AccessDeniedException", errorCode): 9382 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 9383 9384 case strings.EqualFold("DirectoryNotEnabledException", errorCode): 9385 return awsRestjson1_deserializeErrorDirectoryNotEnabledException(response, errorBody) 9386 9387 case strings.EqualFold("FacetValidationException", errorCode): 9388 return awsRestjson1_deserializeErrorFacetValidationException(response, errorBody) 9389 9390 case strings.EqualFold("InternalServiceException", errorCode): 9391 return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody) 9392 9393 case strings.EqualFold("InvalidArnException", errorCode): 9394 return awsRestjson1_deserializeErrorInvalidArnException(response, errorBody) 9395 9396 case strings.EqualFold("LimitExceededException", errorCode): 9397 return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody) 9398 9399 case strings.EqualFold("ResourceNotFoundException", errorCode): 9400 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 9401 9402 case strings.EqualFold("RetryableConflictException", errorCode): 9403 return awsRestjson1_deserializeErrorRetryableConflictException(response, errorBody) 9404 9405 case strings.EqualFold("ValidationException", errorCode): 9406 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 9407 9408 default: 9409 genericError := &smithy.GenericAPIError{ 9410 Code: errorCode, 9411 Message: errorMessage, 9412 } 9413 return genericError 9414 9415 } 9416} 9417 9418type awsRestjson1_deserializeOpTagResource struct { 9419} 9420 9421func (*awsRestjson1_deserializeOpTagResource) ID() string { 9422 return "OperationDeserializer" 9423} 9424 9425func (m *awsRestjson1_deserializeOpTagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 9426 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 9427) { 9428 out, metadata, err = next.HandleDeserialize(ctx, in) 9429 if err != nil { 9430 return out, metadata, err 9431 } 9432 9433 response, ok := out.RawResponse.(*smithyhttp.Response) 9434 if !ok { 9435 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 9436 } 9437 9438 if response.StatusCode < 200 || response.StatusCode >= 300 { 9439 return out, metadata, awsRestjson1_deserializeOpErrorTagResource(response, &metadata) 9440 } 9441 output := &TagResourceOutput{} 9442 out.Result = output 9443 9444 return out, metadata, err 9445} 9446 9447func awsRestjson1_deserializeOpErrorTagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 9448 var errorBuffer bytes.Buffer 9449 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 9450 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 9451 } 9452 errorBody := bytes.NewReader(errorBuffer.Bytes()) 9453 9454 errorCode := "UnknownError" 9455 errorMessage := errorCode 9456 9457 code := response.Header.Get("X-Amzn-ErrorType") 9458 if len(code) != 0 { 9459 errorCode = restjson.SanitizeErrorCode(code) 9460 } 9461 9462 var buff [1024]byte 9463 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9464 9465 body := io.TeeReader(errorBody, ringBuffer) 9466 decoder := json.NewDecoder(body) 9467 decoder.UseNumber() 9468 code, message, err := restjson.GetErrorInfo(decoder) 9469 if err != nil { 9470 var snapshot bytes.Buffer 9471 io.Copy(&snapshot, ringBuffer) 9472 err = &smithy.DeserializationError{ 9473 Err: fmt.Errorf("failed to decode response body, %w", err), 9474 Snapshot: snapshot.Bytes(), 9475 } 9476 return err 9477 } 9478 9479 errorBody.Seek(0, io.SeekStart) 9480 if len(code) != 0 { 9481 errorCode = restjson.SanitizeErrorCode(code) 9482 } 9483 if len(message) != 0 { 9484 errorMessage = message 9485 } 9486 9487 switch { 9488 case strings.EqualFold("AccessDeniedException", errorCode): 9489 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 9490 9491 case strings.EqualFold("InternalServiceException", errorCode): 9492 return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody) 9493 9494 case strings.EqualFold("InvalidArnException", errorCode): 9495 return awsRestjson1_deserializeErrorInvalidArnException(response, errorBody) 9496 9497 case strings.EqualFold("InvalidTaggingRequestException", errorCode): 9498 return awsRestjson1_deserializeErrorInvalidTaggingRequestException(response, errorBody) 9499 9500 case strings.EqualFold("LimitExceededException", errorCode): 9501 return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody) 9502 9503 case strings.EqualFold("ResourceNotFoundException", errorCode): 9504 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 9505 9506 case strings.EqualFold("RetryableConflictException", errorCode): 9507 return awsRestjson1_deserializeErrorRetryableConflictException(response, errorBody) 9508 9509 case strings.EqualFold("ValidationException", errorCode): 9510 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 9511 9512 default: 9513 genericError := &smithy.GenericAPIError{ 9514 Code: errorCode, 9515 Message: errorMessage, 9516 } 9517 return genericError 9518 9519 } 9520} 9521 9522type awsRestjson1_deserializeOpUntagResource struct { 9523} 9524 9525func (*awsRestjson1_deserializeOpUntagResource) ID() string { 9526 return "OperationDeserializer" 9527} 9528 9529func (m *awsRestjson1_deserializeOpUntagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 9530 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 9531) { 9532 out, metadata, err = next.HandleDeserialize(ctx, in) 9533 if err != nil { 9534 return out, metadata, err 9535 } 9536 9537 response, ok := out.RawResponse.(*smithyhttp.Response) 9538 if !ok { 9539 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 9540 } 9541 9542 if response.StatusCode < 200 || response.StatusCode >= 300 { 9543 return out, metadata, awsRestjson1_deserializeOpErrorUntagResource(response, &metadata) 9544 } 9545 output := &UntagResourceOutput{} 9546 out.Result = output 9547 9548 return out, metadata, err 9549} 9550 9551func awsRestjson1_deserializeOpErrorUntagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error { 9552 var errorBuffer bytes.Buffer 9553 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 9554 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 9555 } 9556 errorBody := bytes.NewReader(errorBuffer.Bytes()) 9557 9558 errorCode := "UnknownError" 9559 errorMessage := errorCode 9560 9561 code := response.Header.Get("X-Amzn-ErrorType") 9562 if len(code) != 0 { 9563 errorCode = restjson.SanitizeErrorCode(code) 9564 } 9565 9566 var buff [1024]byte 9567 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9568 9569 body := io.TeeReader(errorBody, ringBuffer) 9570 decoder := json.NewDecoder(body) 9571 decoder.UseNumber() 9572 code, message, err := restjson.GetErrorInfo(decoder) 9573 if err != nil { 9574 var snapshot bytes.Buffer 9575 io.Copy(&snapshot, ringBuffer) 9576 err = &smithy.DeserializationError{ 9577 Err: fmt.Errorf("failed to decode response body, %w", err), 9578 Snapshot: snapshot.Bytes(), 9579 } 9580 return err 9581 } 9582 9583 errorBody.Seek(0, io.SeekStart) 9584 if len(code) != 0 { 9585 errorCode = restjson.SanitizeErrorCode(code) 9586 } 9587 if len(message) != 0 { 9588 errorMessage = message 9589 } 9590 9591 switch { 9592 case strings.EqualFold("AccessDeniedException", errorCode): 9593 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 9594 9595 case strings.EqualFold("InternalServiceException", errorCode): 9596 return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody) 9597 9598 case strings.EqualFold("InvalidArnException", errorCode): 9599 return awsRestjson1_deserializeErrorInvalidArnException(response, errorBody) 9600 9601 case strings.EqualFold("InvalidTaggingRequestException", errorCode): 9602 return awsRestjson1_deserializeErrorInvalidTaggingRequestException(response, errorBody) 9603 9604 case strings.EqualFold("LimitExceededException", errorCode): 9605 return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody) 9606 9607 case strings.EqualFold("ResourceNotFoundException", errorCode): 9608 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 9609 9610 case strings.EqualFold("RetryableConflictException", errorCode): 9611 return awsRestjson1_deserializeErrorRetryableConflictException(response, errorBody) 9612 9613 case strings.EqualFold("ValidationException", errorCode): 9614 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 9615 9616 default: 9617 genericError := &smithy.GenericAPIError{ 9618 Code: errorCode, 9619 Message: errorMessage, 9620 } 9621 return genericError 9622 9623 } 9624} 9625 9626type awsRestjson1_deserializeOpUpdateFacet struct { 9627} 9628 9629func (*awsRestjson1_deserializeOpUpdateFacet) ID() string { 9630 return "OperationDeserializer" 9631} 9632 9633func (m *awsRestjson1_deserializeOpUpdateFacet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 9634 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 9635) { 9636 out, metadata, err = next.HandleDeserialize(ctx, in) 9637 if err != nil { 9638 return out, metadata, err 9639 } 9640 9641 response, ok := out.RawResponse.(*smithyhttp.Response) 9642 if !ok { 9643 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 9644 } 9645 9646 if response.StatusCode < 200 || response.StatusCode >= 300 { 9647 return out, metadata, awsRestjson1_deserializeOpErrorUpdateFacet(response, &metadata) 9648 } 9649 output := &UpdateFacetOutput{} 9650 out.Result = output 9651 9652 return out, metadata, err 9653} 9654 9655func awsRestjson1_deserializeOpErrorUpdateFacet(response *smithyhttp.Response, metadata *middleware.Metadata) error { 9656 var errorBuffer bytes.Buffer 9657 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 9658 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 9659 } 9660 errorBody := bytes.NewReader(errorBuffer.Bytes()) 9661 9662 errorCode := "UnknownError" 9663 errorMessage := errorCode 9664 9665 code := response.Header.Get("X-Amzn-ErrorType") 9666 if len(code) != 0 { 9667 errorCode = restjson.SanitizeErrorCode(code) 9668 } 9669 9670 var buff [1024]byte 9671 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9672 9673 body := io.TeeReader(errorBody, ringBuffer) 9674 decoder := json.NewDecoder(body) 9675 decoder.UseNumber() 9676 code, message, err := restjson.GetErrorInfo(decoder) 9677 if err != nil { 9678 var snapshot bytes.Buffer 9679 io.Copy(&snapshot, ringBuffer) 9680 err = &smithy.DeserializationError{ 9681 Err: fmt.Errorf("failed to decode response body, %w", err), 9682 Snapshot: snapshot.Bytes(), 9683 } 9684 return err 9685 } 9686 9687 errorBody.Seek(0, io.SeekStart) 9688 if len(code) != 0 { 9689 errorCode = restjson.SanitizeErrorCode(code) 9690 } 9691 if len(message) != 0 { 9692 errorMessage = message 9693 } 9694 9695 switch { 9696 case strings.EqualFold("AccessDeniedException", errorCode): 9697 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 9698 9699 case strings.EqualFold("FacetNotFoundException", errorCode): 9700 return awsRestjson1_deserializeErrorFacetNotFoundException(response, errorBody) 9701 9702 case strings.EqualFold("FacetValidationException", errorCode): 9703 return awsRestjson1_deserializeErrorFacetValidationException(response, errorBody) 9704 9705 case strings.EqualFold("InternalServiceException", errorCode): 9706 return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody) 9707 9708 case strings.EqualFold("InvalidArnException", errorCode): 9709 return awsRestjson1_deserializeErrorInvalidArnException(response, errorBody) 9710 9711 case strings.EqualFold("InvalidFacetUpdateException", errorCode): 9712 return awsRestjson1_deserializeErrorInvalidFacetUpdateException(response, errorBody) 9713 9714 case strings.EqualFold("InvalidRuleException", errorCode): 9715 return awsRestjson1_deserializeErrorInvalidRuleException(response, errorBody) 9716 9717 case strings.EqualFold("LimitExceededException", errorCode): 9718 return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody) 9719 9720 case strings.EqualFold("ResourceNotFoundException", errorCode): 9721 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 9722 9723 case strings.EqualFold("RetryableConflictException", errorCode): 9724 return awsRestjson1_deserializeErrorRetryableConflictException(response, errorBody) 9725 9726 case strings.EqualFold("ValidationException", errorCode): 9727 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 9728 9729 default: 9730 genericError := &smithy.GenericAPIError{ 9731 Code: errorCode, 9732 Message: errorMessage, 9733 } 9734 return genericError 9735 9736 } 9737} 9738 9739type awsRestjson1_deserializeOpUpdateLinkAttributes struct { 9740} 9741 9742func (*awsRestjson1_deserializeOpUpdateLinkAttributes) ID() string { 9743 return "OperationDeserializer" 9744} 9745 9746func (m *awsRestjson1_deserializeOpUpdateLinkAttributes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 9747 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 9748) { 9749 out, metadata, err = next.HandleDeserialize(ctx, in) 9750 if err != nil { 9751 return out, metadata, err 9752 } 9753 9754 response, ok := out.RawResponse.(*smithyhttp.Response) 9755 if !ok { 9756 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 9757 } 9758 9759 if response.StatusCode < 200 || response.StatusCode >= 300 { 9760 return out, metadata, awsRestjson1_deserializeOpErrorUpdateLinkAttributes(response, &metadata) 9761 } 9762 output := &UpdateLinkAttributesOutput{} 9763 out.Result = output 9764 9765 return out, metadata, err 9766} 9767 9768func awsRestjson1_deserializeOpErrorUpdateLinkAttributes(response *smithyhttp.Response, metadata *middleware.Metadata) error { 9769 var errorBuffer bytes.Buffer 9770 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 9771 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 9772 } 9773 errorBody := bytes.NewReader(errorBuffer.Bytes()) 9774 9775 errorCode := "UnknownError" 9776 errorMessage := errorCode 9777 9778 code := response.Header.Get("X-Amzn-ErrorType") 9779 if len(code) != 0 { 9780 errorCode = restjson.SanitizeErrorCode(code) 9781 } 9782 9783 var buff [1024]byte 9784 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9785 9786 body := io.TeeReader(errorBody, ringBuffer) 9787 decoder := json.NewDecoder(body) 9788 decoder.UseNumber() 9789 code, message, err := restjson.GetErrorInfo(decoder) 9790 if err != nil { 9791 var snapshot bytes.Buffer 9792 io.Copy(&snapshot, ringBuffer) 9793 err = &smithy.DeserializationError{ 9794 Err: fmt.Errorf("failed to decode response body, %w", err), 9795 Snapshot: snapshot.Bytes(), 9796 } 9797 return err 9798 } 9799 9800 errorBody.Seek(0, io.SeekStart) 9801 if len(code) != 0 { 9802 errorCode = restjson.SanitizeErrorCode(code) 9803 } 9804 if len(message) != 0 { 9805 errorMessage = message 9806 } 9807 9808 switch { 9809 case strings.EqualFold("AccessDeniedException", errorCode): 9810 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 9811 9812 case strings.EqualFold("DirectoryNotEnabledException", errorCode): 9813 return awsRestjson1_deserializeErrorDirectoryNotEnabledException(response, errorBody) 9814 9815 case strings.EqualFold("FacetValidationException", errorCode): 9816 return awsRestjson1_deserializeErrorFacetValidationException(response, errorBody) 9817 9818 case strings.EqualFold("InternalServiceException", errorCode): 9819 return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody) 9820 9821 case strings.EqualFold("InvalidArnException", errorCode): 9822 return awsRestjson1_deserializeErrorInvalidArnException(response, errorBody) 9823 9824 case strings.EqualFold("LimitExceededException", errorCode): 9825 return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody) 9826 9827 case strings.EqualFold("ResourceNotFoundException", errorCode): 9828 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 9829 9830 case strings.EqualFold("RetryableConflictException", errorCode): 9831 return awsRestjson1_deserializeErrorRetryableConflictException(response, errorBody) 9832 9833 case strings.EqualFold("ValidationException", errorCode): 9834 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 9835 9836 default: 9837 genericError := &smithy.GenericAPIError{ 9838 Code: errorCode, 9839 Message: errorMessage, 9840 } 9841 return genericError 9842 9843 } 9844} 9845 9846type awsRestjson1_deserializeOpUpdateObjectAttributes struct { 9847} 9848 9849func (*awsRestjson1_deserializeOpUpdateObjectAttributes) ID() string { 9850 return "OperationDeserializer" 9851} 9852 9853func (m *awsRestjson1_deserializeOpUpdateObjectAttributes) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 9854 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 9855) { 9856 out, metadata, err = next.HandleDeserialize(ctx, in) 9857 if err != nil { 9858 return out, metadata, err 9859 } 9860 9861 response, ok := out.RawResponse.(*smithyhttp.Response) 9862 if !ok { 9863 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 9864 } 9865 9866 if response.StatusCode < 200 || response.StatusCode >= 300 { 9867 return out, metadata, awsRestjson1_deserializeOpErrorUpdateObjectAttributes(response, &metadata) 9868 } 9869 output := &UpdateObjectAttributesOutput{} 9870 out.Result = output 9871 9872 var buff [1024]byte 9873 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9874 9875 body := io.TeeReader(response.Body, ringBuffer) 9876 9877 decoder := json.NewDecoder(body) 9878 decoder.UseNumber() 9879 var shape interface{} 9880 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 9881 var snapshot bytes.Buffer 9882 io.Copy(&snapshot, ringBuffer) 9883 err = &smithy.DeserializationError{ 9884 Err: fmt.Errorf("failed to decode response body, %w", err), 9885 Snapshot: snapshot.Bytes(), 9886 } 9887 return out, metadata, err 9888 } 9889 9890 err = awsRestjson1_deserializeOpDocumentUpdateObjectAttributesOutput(&output, shape) 9891 if err != nil { 9892 var snapshot bytes.Buffer 9893 io.Copy(&snapshot, ringBuffer) 9894 return out, metadata, &smithy.DeserializationError{ 9895 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 9896 Snapshot: snapshot.Bytes(), 9897 } 9898 } 9899 9900 return out, metadata, err 9901} 9902 9903func awsRestjson1_deserializeOpErrorUpdateObjectAttributes(response *smithyhttp.Response, metadata *middleware.Metadata) error { 9904 var errorBuffer bytes.Buffer 9905 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 9906 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 9907 } 9908 errorBody := bytes.NewReader(errorBuffer.Bytes()) 9909 9910 errorCode := "UnknownError" 9911 errorMessage := errorCode 9912 9913 code := response.Header.Get("X-Amzn-ErrorType") 9914 if len(code) != 0 { 9915 errorCode = restjson.SanitizeErrorCode(code) 9916 } 9917 9918 var buff [1024]byte 9919 ringBuffer := smithyio.NewRingBuffer(buff[:]) 9920 9921 body := io.TeeReader(errorBody, ringBuffer) 9922 decoder := json.NewDecoder(body) 9923 decoder.UseNumber() 9924 code, message, err := restjson.GetErrorInfo(decoder) 9925 if err != nil { 9926 var snapshot bytes.Buffer 9927 io.Copy(&snapshot, ringBuffer) 9928 err = &smithy.DeserializationError{ 9929 Err: fmt.Errorf("failed to decode response body, %w", err), 9930 Snapshot: snapshot.Bytes(), 9931 } 9932 return err 9933 } 9934 9935 errorBody.Seek(0, io.SeekStart) 9936 if len(code) != 0 { 9937 errorCode = restjson.SanitizeErrorCode(code) 9938 } 9939 if len(message) != 0 { 9940 errorMessage = message 9941 } 9942 9943 switch { 9944 case strings.EqualFold("AccessDeniedException", errorCode): 9945 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 9946 9947 case strings.EqualFold("DirectoryNotEnabledException", errorCode): 9948 return awsRestjson1_deserializeErrorDirectoryNotEnabledException(response, errorBody) 9949 9950 case strings.EqualFold("FacetValidationException", errorCode): 9951 return awsRestjson1_deserializeErrorFacetValidationException(response, errorBody) 9952 9953 case strings.EqualFold("InternalServiceException", errorCode): 9954 return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody) 9955 9956 case strings.EqualFold("InvalidArnException", errorCode): 9957 return awsRestjson1_deserializeErrorInvalidArnException(response, errorBody) 9958 9959 case strings.EqualFold("LimitExceededException", errorCode): 9960 return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody) 9961 9962 case strings.EqualFold("LinkNameAlreadyInUseException", errorCode): 9963 return awsRestjson1_deserializeErrorLinkNameAlreadyInUseException(response, errorBody) 9964 9965 case strings.EqualFold("ResourceNotFoundException", errorCode): 9966 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 9967 9968 case strings.EqualFold("RetryableConflictException", errorCode): 9969 return awsRestjson1_deserializeErrorRetryableConflictException(response, errorBody) 9970 9971 case strings.EqualFold("ValidationException", errorCode): 9972 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 9973 9974 default: 9975 genericError := &smithy.GenericAPIError{ 9976 Code: errorCode, 9977 Message: errorMessage, 9978 } 9979 return genericError 9980 9981 } 9982} 9983 9984func awsRestjson1_deserializeOpDocumentUpdateObjectAttributesOutput(v **UpdateObjectAttributesOutput, value interface{}) error { 9985 if v == nil { 9986 return fmt.Errorf("unexpected nil of type %T", v) 9987 } 9988 if value == nil { 9989 return nil 9990 } 9991 9992 shape, ok := value.(map[string]interface{}) 9993 if !ok { 9994 return fmt.Errorf("unexpected JSON type %v", value) 9995 } 9996 9997 var sv *UpdateObjectAttributesOutput 9998 if *v == nil { 9999 sv = &UpdateObjectAttributesOutput{} 10000 } else { 10001 sv = *v 10002 } 10003 10004 for key, value := range shape { 10005 switch key { 10006 case "ObjectIdentifier": 10007 if value != nil { 10008 jtv, ok := value.(string) 10009 if !ok { 10010 return fmt.Errorf("expected ObjectIdentifier to be of type string, got %T instead", value) 10011 } 10012 sv.ObjectIdentifier = ptr.String(jtv) 10013 } 10014 10015 default: 10016 _, _ = key, value 10017 10018 } 10019 } 10020 *v = sv 10021 return nil 10022} 10023 10024type awsRestjson1_deserializeOpUpdateSchema struct { 10025} 10026 10027func (*awsRestjson1_deserializeOpUpdateSchema) ID() string { 10028 return "OperationDeserializer" 10029} 10030 10031func (m *awsRestjson1_deserializeOpUpdateSchema) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 10032 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 10033) { 10034 out, metadata, err = next.HandleDeserialize(ctx, in) 10035 if err != nil { 10036 return out, metadata, err 10037 } 10038 10039 response, ok := out.RawResponse.(*smithyhttp.Response) 10040 if !ok { 10041 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 10042 } 10043 10044 if response.StatusCode < 200 || response.StatusCode >= 300 { 10045 return out, metadata, awsRestjson1_deserializeOpErrorUpdateSchema(response, &metadata) 10046 } 10047 output := &UpdateSchemaOutput{} 10048 out.Result = output 10049 10050 var buff [1024]byte 10051 ringBuffer := smithyio.NewRingBuffer(buff[:]) 10052 10053 body := io.TeeReader(response.Body, ringBuffer) 10054 10055 decoder := json.NewDecoder(body) 10056 decoder.UseNumber() 10057 var shape interface{} 10058 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 10059 var snapshot bytes.Buffer 10060 io.Copy(&snapshot, ringBuffer) 10061 err = &smithy.DeserializationError{ 10062 Err: fmt.Errorf("failed to decode response body, %w", err), 10063 Snapshot: snapshot.Bytes(), 10064 } 10065 return out, metadata, err 10066 } 10067 10068 err = awsRestjson1_deserializeOpDocumentUpdateSchemaOutput(&output, shape) 10069 if err != nil { 10070 var snapshot bytes.Buffer 10071 io.Copy(&snapshot, ringBuffer) 10072 return out, metadata, &smithy.DeserializationError{ 10073 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 10074 Snapshot: snapshot.Bytes(), 10075 } 10076 } 10077 10078 return out, metadata, err 10079} 10080 10081func awsRestjson1_deserializeOpErrorUpdateSchema(response *smithyhttp.Response, metadata *middleware.Metadata) error { 10082 var errorBuffer bytes.Buffer 10083 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 10084 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 10085 } 10086 errorBody := bytes.NewReader(errorBuffer.Bytes()) 10087 10088 errorCode := "UnknownError" 10089 errorMessage := errorCode 10090 10091 code := response.Header.Get("X-Amzn-ErrorType") 10092 if len(code) != 0 { 10093 errorCode = restjson.SanitizeErrorCode(code) 10094 } 10095 10096 var buff [1024]byte 10097 ringBuffer := smithyio.NewRingBuffer(buff[:]) 10098 10099 body := io.TeeReader(errorBody, ringBuffer) 10100 decoder := json.NewDecoder(body) 10101 decoder.UseNumber() 10102 code, message, err := restjson.GetErrorInfo(decoder) 10103 if err != nil { 10104 var snapshot bytes.Buffer 10105 io.Copy(&snapshot, ringBuffer) 10106 err = &smithy.DeserializationError{ 10107 Err: fmt.Errorf("failed to decode response body, %w", err), 10108 Snapshot: snapshot.Bytes(), 10109 } 10110 return err 10111 } 10112 10113 errorBody.Seek(0, io.SeekStart) 10114 if len(code) != 0 { 10115 errorCode = restjson.SanitizeErrorCode(code) 10116 } 10117 if len(message) != 0 { 10118 errorMessage = message 10119 } 10120 10121 switch { 10122 case strings.EqualFold("AccessDeniedException", errorCode): 10123 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 10124 10125 case strings.EqualFold("InternalServiceException", errorCode): 10126 return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody) 10127 10128 case strings.EqualFold("InvalidArnException", errorCode): 10129 return awsRestjson1_deserializeErrorInvalidArnException(response, errorBody) 10130 10131 case strings.EqualFold("LimitExceededException", errorCode): 10132 return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody) 10133 10134 case strings.EqualFold("ResourceNotFoundException", errorCode): 10135 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 10136 10137 case strings.EqualFold("RetryableConflictException", errorCode): 10138 return awsRestjson1_deserializeErrorRetryableConflictException(response, errorBody) 10139 10140 case strings.EqualFold("ValidationException", errorCode): 10141 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 10142 10143 default: 10144 genericError := &smithy.GenericAPIError{ 10145 Code: errorCode, 10146 Message: errorMessage, 10147 } 10148 return genericError 10149 10150 } 10151} 10152 10153func awsRestjson1_deserializeOpDocumentUpdateSchemaOutput(v **UpdateSchemaOutput, value interface{}) error { 10154 if v == nil { 10155 return fmt.Errorf("unexpected nil of type %T", v) 10156 } 10157 if value == nil { 10158 return nil 10159 } 10160 10161 shape, ok := value.(map[string]interface{}) 10162 if !ok { 10163 return fmt.Errorf("unexpected JSON type %v", value) 10164 } 10165 10166 var sv *UpdateSchemaOutput 10167 if *v == nil { 10168 sv = &UpdateSchemaOutput{} 10169 } else { 10170 sv = *v 10171 } 10172 10173 for key, value := range shape { 10174 switch key { 10175 case "SchemaArn": 10176 if value != nil { 10177 jtv, ok := value.(string) 10178 if !ok { 10179 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 10180 } 10181 sv.SchemaArn = ptr.String(jtv) 10182 } 10183 10184 default: 10185 _, _ = key, value 10186 10187 } 10188 } 10189 *v = sv 10190 return nil 10191} 10192 10193type awsRestjson1_deserializeOpUpdateTypedLinkFacet struct { 10194} 10195 10196func (*awsRestjson1_deserializeOpUpdateTypedLinkFacet) ID() string { 10197 return "OperationDeserializer" 10198} 10199 10200func (m *awsRestjson1_deserializeOpUpdateTypedLinkFacet) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 10201 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 10202) { 10203 out, metadata, err = next.HandleDeserialize(ctx, in) 10204 if err != nil { 10205 return out, metadata, err 10206 } 10207 10208 response, ok := out.RawResponse.(*smithyhttp.Response) 10209 if !ok { 10210 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 10211 } 10212 10213 if response.StatusCode < 200 || response.StatusCode >= 300 { 10214 return out, metadata, awsRestjson1_deserializeOpErrorUpdateTypedLinkFacet(response, &metadata) 10215 } 10216 output := &UpdateTypedLinkFacetOutput{} 10217 out.Result = output 10218 10219 return out, metadata, err 10220} 10221 10222func awsRestjson1_deserializeOpErrorUpdateTypedLinkFacet(response *smithyhttp.Response, metadata *middleware.Metadata) error { 10223 var errorBuffer bytes.Buffer 10224 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 10225 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 10226 } 10227 errorBody := bytes.NewReader(errorBuffer.Bytes()) 10228 10229 errorCode := "UnknownError" 10230 errorMessage := errorCode 10231 10232 code := response.Header.Get("X-Amzn-ErrorType") 10233 if len(code) != 0 { 10234 errorCode = restjson.SanitizeErrorCode(code) 10235 } 10236 10237 var buff [1024]byte 10238 ringBuffer := smithyio.NewRingBuffer(buff[:]) 10239 10240 body := io.TeeReader(errorBody, ringBuffer) 10241 decoder := json.NewDecoder(body) 10242 decoder.UseNumber() 10243 code, message, err := restjson.GetErrorInfo(decoder) 10244 if err != nil { 10245 var snapshot bytes.Buffer 10246 io.Copy(&snapshot, ringBuffer) 10247 err = &smithy.DeserializationError{ 10248 Err: fmt.Errorf("failed to decode response body, %w", err), 10249 Snapshot: snapshot.Bytes(), 10250 } 10251 return err 10252 } 10253 10254 errorBody.Seek(0, io.SeekStart) 10255 if len(code) != 0 { 10256 errorCode = restjson.SanitizeErrorCode(code) 10257 } 10258 if len(message) != 0 { 10259 errorMessage = message 10260 } 10261 10262 switch { 10263 case strings.EqualFold("AccessDeniedException", errorCode): 10264 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 10265 10266 case strings.EqualFold("FacetNotFoundException", errorCode): 10267 return awsRestjson1_deserializeErrorFacetNotFoundException(response, errorBody) 10268 10269 case strings.EqualFold("FacetValidationException", errorCode): 10270 return awsRestjson1_deserializeErrorFacetValidationException(response, errorBody) 10271 10272 case strings.EqualFold("InternalServiceException", errorCode): 10273 return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody) 10274 10275 case strings.EqualFold("InvalidArnException", errorCode): 10276 return awsRestjson1_deserializeErrorInvalidArnException(response, errorBody) 10277 10278 case strings.EqualFold("InvalidFacetUpdateException", errorCode): 10279 return awsRestjson1_deserializeErrorInvalidFacetUpdateException(response, errorBody) 10280 10281 case strings.EqualFold("InvalidRuleException", errorCode): 10282 return awsRestjson1_deserializeErrorInvalidRuleException(response, errorBody) 10283 10284 case strings.EqualFold("LimitExceededException", errorCode): 10285 return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody) 10286 10287 case strings.EqualFold("ResourceNotFoundException", errorCode): 10288 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 10289 10290 case strings.EqualFold("RetryableConflictException", errorCode): 10291 return awsRestjson1_deserializeErrorRetryableConflictException(response, errorBody) 10292 10293 case strings.EqualFold("ValidationException", errorCode): 10294 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 10295 10296 default: 10297 genericError := &smithy.GenericAPIError{ 10298 Code: errorCode, 10299 Message: errorMessage, 10300 } 10301 return genericError 10302 10303 } 10304} 10305 10306type awsRestjson1_deserializeOpUpgradeAppliedSchema struct { 10307} 10308 10309func (*awsRestjson1_deserializeOpUpgradeAppliedSchema) ID() string { 10310 return "OperationDeserializer" 10311} 10312 10313func (m *awsRestjson1_deserializeOpUpgradeAppliedSchema) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 10314 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 10315) { 10316 out, metadata, err = next.HandleDeserialize(ctx, in) 10317 if err != nil { 10318 return out, metadata, err 10319 } 10320 10321 response, ok := out.RawResponse.(*smithyhttp.Response) 10322 if !ok { 10323 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 10324 } 10325 10326 if response.StatusCode < 200 || response.StatusCode >= 300 { 10327 return out, metadata, awsRestjson1_deserializeOpErrorUpgradeAppliedSchema(response, &metadata) 10328 } 10329 output := &UpgradeAppliedSchemaOutput{} 10330 out.Result = output 10331 10332 var buff [1024]byte 10333 ringBuffer := smithyio.NewRingBuffer(buff[:]) 10334 10335 body := io.TeeReader(response.Body, ringBuffer) 10336 10337 decoder := json.NewDecoder(body) 10338 decoder.UseNumber() 10339 var shape interface{} 10340 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 10341 var snapshot bytes.Buffer 10342 io.Copy(&snapshot, ringBuffer) 10343 err = &smithy.DeserializationError{ 10344 Err: fmt.Errorf("failed to decode response body, %w", err), 10345 Snapshot: snapshot.Bytes(), 10346 } 10347 return out, metadata, err 10348 } 10349 10350 err = awsRestjson1_deserializeOpDocumentUpgradeAppliedSchemaOutput(&output, shape) 10351 if err != nil { 10352 var snapshot bytes.Buffer 10353 io.Copy(&snapshot, ringBuffer) 10354 return out, metadata, &smithy.DeserializationError{ 10355 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 10356 Snapshot: snapshot.Bytes(), 10357 } 10358 } 10359 10360 return out, metadata, err 10361} 10362 10363func awsRestjson1_deserializeOpErrorUpgradeAppliedSchema(response *smithyhttp.Response, metadata *middleware.Metadata) error { 10364 var errorBuffer bytes.Buffer 10365 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 10366 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 10367 } 10368 errorBody := bytes.NewReader(errorBuffer.Bytes()) 10369 10370 errorCode := "UnknownError" 10371 errorMessage := errorCode 10372 10373 code := response.Header.Get("X-Amzn-ErrorType") 10374 if len(code) != 0 { 10375 errorCode = restjson.SanitizeErrorCode(code) 10376 } 10377 10378 var buff [1024]byte 10379 ringBuffer := smithyio.NewRingBuffer(buff[:]) 10380 10381 body := io.TeeReader(errorBody, ringBuffer) 10382 decoder := json.NewDecoder(body) 10383 decoder.UseNumber() 10384 code, message, err := restjson.GetErrorInfo(decoder) 10385 if err != nil { 10386 var snapshot bytes.Buffer 10387 io.Copy(&snapshot, ringBuffer) 10388 err = &smithy.DeserializationError{ 10389 Err: fmt.Errorf("failed to decode response body, %w", err), 10390 Snapshot: snapshot.Bytes(), 10391 } 10392 return err 10393 } 10394 10395 errorBody.Seek(0, io.SeekStart) 10396 if len(code) != 0 { 10397 errorCode = restjson.SanitizeErrorCode(code) 10398 } 10399 if len(message) != 0 { 10400 errorMessage = message 10401 } 10402 10403 switch { 10404 case strings.EqualFold("AccessDeniedException", errorCode): 10405 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 10406 10407 case strings.EqualFold("IncompatibleSchemaException", errorCode): 10408 return awsRestjson1_deserializeErrorIncompatibleSchemaException(response, errorBody) 10409 10410 case strings.EqualFold("InternalServiceException", errorCode): 10411 return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody) 10412 10413 case strings.EqualFold("InvalidArnException", errorCode): 10414 return awsRestjson1_deserializeErrorInvalidArnException(response, errorBody) 10415 10416 case strings.EqualFold("InvalidAttachmentException", errorCode): 10417 return awsRestjson1_deserializeErrorInvalidAttachmentException(response, errorBody) 10418 10419 case strings.EqualFold("ResourceNotFoundException", errorCode): 10420 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 10421 10422 case strings.EqualFold("RetryableConflictException", errorCode): 10423 return awsRestjson1_deserializeErrorRetryableConflictException(response, errorBody) 10424 10425 case strings.EqualFold("SchemaAlreadyExistsException", errorCode): 10426 return awsRestjson1_deserializeErrorSchemaAlreadyExistsException(response, errorBody) 10427 10428 case strings.EqualFold("ValidationException", errorCode): 10429 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 10430 10431 default: 10432 genericError := &smithy.GenericAPIError{ 10433 Code: errorCode, 10434 Message: errorMessage, 10435 } 10436 return genericError 10437 10438 } 10439} 10440 10441func awsRestjson1_deserializeOpDocumentUpgradeAppliedSchemaOutput(v **UpgradeAppliedSchemaOutput, value interface{}) error { 10442 if v == nil { 10443 return fmt.Errorf("unexpected nil of type %T", v) 10444 } 10445 if value == nil { 10446 return nil 10447 } 10448 10449 shape, ok := value.(map[string]interface{}) 10450 if !ok { 10451 return fmt.Errorf("unexpected JSON type %v", value) 10452 } 10453 10454 var sv *UpgradeAppliedSchemaOutput 10455 if *v == nil { 10456 sv = &UpgradeAppliedSchemaOutput{} 10457 } else { 10458 sv = *v 10459 } 10460 10461 for key, value := range shape { 10462 switch key { 10463 case "DirectoryArn": 10464 if value != nil { 10465 jtv, ok := value.(string) 10466 if !ok { 10467 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 10468 } 10469 sv.DirectoryArn = ptr.String(jtv) 10470 } 10471 10472 case "UpgradedSchemaArn": 10473 if value != nil { 10474 jtv, ok := value.(string) 10475 if !ok { 10476 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 10477 } 10478 sv.UpgradedSchemaArn = ptr.String(jtv) 10479 } 10480 10481 default: 10482 _, _ = key, value 10483 10484 } 10485 } 10486 *v = sv 10487 return nil 10488} 10489 10490type awsRestjson1_deserializeOpUpgradePublishedSchema struct { 10491} 10492 10493func (*awsRestjson1_deserializeOpUpgradePublishedSchema) ID() string { 10494 return "OperationDeserializer" 10495} 10496 10497func (m *awsRestjson1_deserializeOpUpgradePublishedSchema) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 10498 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 10499) { 10500 out, metadata, err = next.HandleDeserialize(ctx, in) 10501 if err != nil { 10502 return out, metadata, err 10503 } 10504 10505 response, ok := out.RawResponse.(*smithyhttp.Response) 10506 if !ok { 10507 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 10508 } 10509 10510 if response.StatusCode < 200 || response.StatusCode >= 300 { 10511 return out, metadata, awsRestjson1_deserializeOpErrorUpgradePublishedSchema(response, &metadata) 10512 } 10513 output := &UpgradePublishedSchemaOutput{} 10514 out.Result = output 10515 10516 var buff [1024]byte 10517 ringBuffer := smithyio.NewRingBuffer(buff[:]) 10518 10519 body := io.TeeReader(response.Body, ringBuffer) 10520 10521 decoder := json.NewDecoder(body) 10522 decoder.UseNumber() 10523 var shape interface{} 10524 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 10525 var snapshot bytes.Buffer 10526 io.Copy(&snapshot, ringBuffer) 10527 err = &smithy.DeserializationError{ 10528 Err: fmt.Errorf("failed to decode response body, %w", err), 10529 Snapshot: snapshot.Bytes(), 10530 } 10531 return out, metadata, err 10532 } 10533 10534 err = awsRestjson1_deserializeOpDocumentUpgradePublishedSchemaOutput(&output, shape) 10535 if err != nil { 10536 var snapshot bytes.Buffer 10537 io.Copy(&snapshot, ringBuffer) 10538 return out, metadata, &smithy.DeserializationError{ 10539 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 10540 Snapshot: snapshot.Bytes(), 10541 } 10542 } 10543 10544 return out, metadata, err 10545} 10546 10547func awsRestjson1_deserializeOpErrorUpgradePublishedSchema(response *smithyhttp.Response, metadata *middleware.Metadata) error { 10548 var errorBuffer bytes.Buffer 10549 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 10550 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 10551 } 10552 errorBody := bytes.NewReader(errorBuffer.Bytes()) 10553 10554 errorCode := "UnknownError" 10555 errorMessage := errorCode 10556 10557 code := response.Header.Get("X-Amzn-ErrorType") 10558 if len(code) != 0 { 10559 errorCode = restjson.SanitizeErrorCode(code) 10560 } 10561 10562 var buff [1024]byte 10563 ringBuffer := smithyio.NewRingBuffer(buff[:]) 10564 10565 body := io.TeeReader(errorBody, ringBuffer) 10566 decoder := json.NewDecoder(body) 10567 decoder.UseNumber() 10568 code, message, err := restjson.GetErrorInfo(decoder) 10569 if err != nil { 10570 var snapshot bytes.Buffer 10571 io.Copy(&snapshot, ringBuffer) 10572 err = &smithy.DeserializationError{ 10573 Err: fmt.Errorf("failed to decode response body, %w", err), 10574 Snapshot: snapshot.Bytes(), 10575 } 10576 return err 10577 } 10578 10579 errorBody.Seek(0, io.SeekStart) 10580 if len(code) != 0 { 10581 errorCode = restjson.SanitizeErrorCode(code) 10582 } 10583 if len(message) != 0 { 10584 errorMessage = message 10585 } 10586 10587 switch { 10588 case strings.EqualFold("AccessDeniedException", errorCode): 10589 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody) 10590 10591 case strings.EqualFold("IncompatibleSchemaException", errorCode): 10592 return awsRestjson1_deserializeErrorIncompatibleSchemaException(response, errorBody) 10593 10594 case strings.EqualFold("InternalServiceException", errorCode): 10595 return awsRestjson1_deserializeErrorInternalServiceException(response, errorBody) 10596 10597 case strings.EqualFold("InvalidArnException", errorCode): 10598 return awsRestjson1_deserializeErrorInvalidArnException(response, errorBody) 10599 10600 case strings.EqualFold("InvalidAttachmentException", errorCode): 10601 return awsRestjson1_deserializeErrorInvalidAttachmentException(response, errorBody) 10602 10603 case strings.EqualFold("LimitExceededException", errorCode): 10604 return awsRestjson1_deserializeErrorLimitExceededException(response, errorBody) 10605 10606 case strings.EqualFold("ResourceNotFoundException", errorCode): 10607 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody) 10608 10609 case strings.EqualFold("RetryableConflictException", errorCode): 10610 return awsRestjson1_deserializeErrorRetryableConflictException(response, errorBody) 10611 10612 case strings.EqualFold("ValidationException", errorCode): 10613 return awsRestjson1_deserializeErrorValidationException(response, errorBody) 10614 10615 default: 10616 genericError := &smithy.GenericAPIError{ 10617 Code: errorCode, 10618 Message: errorMessage, 10619 } 10620 return genericError 10621 10622 } 10623} 10624 10625func awsRestjson1_deserializeOpDocumentUpgradePublishedSchemaOutput(v **UpgradePublishedSchemaOutput, value interface{}) error { 10626 if v == nil { 10627 return fmt.Errorf("unexpected nil of type %T", v) 10628 } 10629 if value == nil { 10630 return nil 10631 } 10632 10633 shape, ok := value.(map[string]interface{}) 10634 if !ok { 10635 return fmt.Errorf("unexpected JSON type %v", value) 10636 } 10637 10638 var sv *UpgradePublishedSchemaOutput 10639 if *v == nil { 10640 sv = &UpgradePublishedSchemaOutput{} 10641 } else { 10642 sv = *v 10643 } 10644 10645 for key, value := range shape { 10646 switch key { 10647 case "UpgradedSchemaArn": 10648 if value != nil { 10649 jtv, ok := value.(string) 10650 if !ok { 10651 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 10652 } 10653 sv.UpgradedSchemaArn = ptr.String(jtv) 10654 } 10655 10656 default: 10657 _, _ = key, value 10658 10659 } 10660 } 10661 *v = sv 10662 return nil 10663} 10664 10665func awsRestjson1_deserializeErrorAccessDeniedException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 10666 output := &types.AccessDeniedException{} 10667 var buff [1024]byte 10668 ringBuffer := smithyio.NewRingBuffer(buff[:]) 10669 10670 body := io.TeeReader(errorBody, ringBuffer) 10671 decoder := json.NewDecoder(body) 10672 decoder.UseNumber() 10673 var shape interface{} 10674 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 10675 var snapshot bytes.Buffer 10676 io.Copy(&snapshot, ringBuffer) 10677 err = &smithy.DeserializationError{ 10678 Err: fmt.Errorf("failed to decode response body, %w", err), 10679 Snapshot: snapshot.Bytes(), 10680 } 10681 return err 10682 } 10683 10684 err := awsRestjson1_deserializeDocumentAccessDeniedException(&output, shape) 10685 10686 if err != nil { 10687 var snapshot bytes.Buffer 10688 io.Copy(&snapshot, ringBuffer) 10689 err = &smithy.DeserializationError{ 10690 Err: fmt.Errorf("failed to decode response body, %w", err), 10691 Snapshot: snapshot.Bytes(), 10692 } 10693 return err 10694 } 10695 10696 errorBody.Seek(0, io.SeekStart) 10697 10698 return output 10699} 10700 10701func awsRestjson1_deserializeErrorBatchWriteException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 10702 output := &types.BatchWriteException{} 10703 var buff [1024]byte 10704 ringBuffer := smithyio.NewRingBuffer(buff[:]) 10705 10706 body := io.TeeReader(errorBody, ringBuffer) 10707 decoder := json.NewDecoder(body) 10708 decoder.UseNumber() 10709 var shape interface{} 10710 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 10711 var snapshot bytes.Buffer 10712 io.Copy(&snapshot, ringBuffer) 10713 err = &smithy.DeserializationError{ 10714 Err: fmt.Errorf("failed to decode response body, %w", err), 10715 Snapshot: snapshot.Bytes(), 10716 } 10717 return err 10718 } 10719 10720 err := awsRestjson1_deserializeDocumentBatchWriteException(&output, shape) 10721 10722 if err != nil { 10723 var snapshot bytes.Buffer 10724 io.Copy(&snapshot, ringBuffer) 10725 err = &smithy.DeserializationError{ 10726 Err: fmt.Errorf("failed to decode response body, %w", err), 10727 Snapshot: snapshot.Bytes(), 10728 } 10729 return err 10730 } 10731 10732 errorBody.Seek(0, io.SeekStart) 10733 10734 return output 10735} 10736 10737func awsRestjson1_deserializeErrorCannotListParentOfRootException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 10738 output := &types.CannotListParentOfRootException{} 10739 var buff [1024]byte 10740 ringBuffer := smithyio.NewRingBuffer(buff[:]) 10741 10742 body := io.TeeReader(errorBody, ringBuffer) 10743 decoder := json.NewDecoder(body) 10744 decoder.UseNumber() 10745 var shape interface{} 10746 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 10747 var snapshot bytes.Buffer 10748 io.Copy(&snapshot, ringBuffer) 10749 err = &smithy.DeserializationError{ 10750 Err: fmt.Errorf("failed to decode response body, %w", err), 10751 Snapshot: snapshot.Bytes(), 10752 } 10753 return err 10754 } 10755 10756 err := awsRestjson1_deserializeDocumentCannotListParentOfRootException(&output, shape) 10757 10758 if err != nil { 10759 var snapshot bytes.Buffer 10760 io.Copy(&snapshot, ringBuffer) 10761 err = &smithy.DeserializationError{ 10762 Err: fmt.Errorf("failed to decode response body, %w", err), 10763 Snapshot: snapshot.Bytes(), 10764 } 10765 return err 10766 } 10767 10768 errorBody.Seek(0, io.SeekStart) 10769 10770 return output 10771} 10772 10773func awsRestjson1_deserializeErrorDirectoryAlreadyExistsException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 10774 output := &types.DirectoryAlreadyExistsException{} 10775 var buff [1024]byte 10776 ringBuffer := smithyio.NewRingBuffer(buff[:]) 10777 10778 body := io.TeeReader(errorBody, ringBuffer) 10779 decoder := json.NewDecoder(body) 10780 decoder.UseNumber() 10781 var shape interface{} 10782 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 10783 var snapshot bytes.Buffer 10784 io.Copy(&snapshot, ringBuffer) 10785 err = &smithy.DeserializationError{ 10786 Err: fmt.Errorf("failed to decode response body, %w", err), 10787 Snapshot: snapshot.Bytes(), 10788 } 10789 return err 10790 } 10791 10792 err := awsRestjson1_deserializeDocumentDirectoryAlreadyExistsException(&output, shape) 10793 10794 if err != nil { 10795 var snapshot bytes.Buffer 10796 io.Copy(&snapshot, ringBuffer) 10797 err = &smithy.DeserializationError{ 10798 Err: fmt.Errorf("failed to decode response body, %w", err), 10799 Snapshot: snapshot.Bytes(), 10800 } 10801 return err 10802 } 10803 10804 errorBody.Seek(0, io.SeekStart) 10805 10806 return output 10807} 10808 10809func awsRestjson1_deserializeErrorDirectoryDeletedException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 10810 output := &types.DirectoryDeletedException{} 10811 var buff [1024]byte 10812 ringBuffer := smithyio.NewRingBuffer(buff[:]) 10813 10814 body := io.TeeReader(errorBody, ringBuffer) 10815 decoder := json.NewDecoder(body) 10816 decoder.UseNumber() 10817 var shape interface{} 10818 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 10819 var snapshot bytes.Buffer 10820 io.Copy(&snapshot, ringBuffer) 10821 err = &smithy.DeserializationError{ 10822 Err: fmt.Errorf("failed to decode response body, %w", err), 10823 Snapshot: snapshot.Bytes(), 10824 } 10825 return err 10826 } 10827 10828 err := awsRestjson1_deserializeDocumentDirectoryDeletedException(&output, shape) 10829 10830 if err != nil { 10831 var snapshot bytes.Buffer 10832 io.Copy(&snapshot, ringBuffer) 10833 err = &smithy.DeserializationError{ 10834 Err: fmt.Errorf("failed to decode response body, %w", err), 10835 Snapshot: snapshot.Bytes(), 10836 } 10837 return err 10838 } 10839 10840 errorBody.Seek(0, io.SeekStart) 10841 10842 return output 10843} 10844 10845func awsRestjson1_deserializeErrorDirectoryNotDisabledException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 10846 output := &types.DirectoryNotDisabledException{} 10847 var buff [1024]byte 10848 ringBuffer := smithyio.NewRingBuffer(buff[:]) 10849 10850 body := io.TeeReader(errorBody, ringBuffer) 10851 decoder := json.NewDecoder(body) 10852 decoder.UseNumber() 10853 var shape interface{} 10854 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 10855 var snapshot bytes.Buffer 10856 io.Copy(&snapshot, ringBuffer) 10857 err = &smithy.DeserializationError{ 10858 Err: fmt.Errorf("failed to decode response body, %w", err), 10859 Snapshot: snapshot.Bytes(), 10860 } 10861 return err 10862 } 10863 10864 err := awsRestjson1_deserializeDocumentDirectoryNotDisabledException(&output, shape) 10865 10866 if err != nil { 10867 var snapshot bytes.Buffer 10868 io.Copy(&snapshot, ringBuffer) 10869 err = &smithy.DeserializationError{ 10870 Err: fmt.Errorf("failed to decode response body, %w", err), 10871 Snapshot: snapshot.Bytes(), 10872 } 10873 return err 10874 } 10875 10876 errorBody.Seek(0, io.SeekStart) 10877 10878 return output 10879} 10880 10881func awsRestjson1_deserializeErrorDirectoryNotEnabledException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 10882 output := &types.DirectoryNotEnabledException{} 10883 var buff [1024]byte 10884 ringBuffer := smithyio.NewRingBuffer(buff[:]) 10885 10886 body := io.TeeReader(errorBody, ringBuffer) 10887 decoder := json.NewDecoder(body) 10888 decoder.UseNumber() 10889 var shape interface{} 10890 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 10891 var snapshot bytes.Buffer 10892 io.Copy(&snapshot, ringBuffer) 10893 err = &smithy.DeserializationError{ 10894 Err: fmt.Errorf("failed to decode response body, %w", err), 10895 Snapshot: snapshot.Bytes(), 10896 } 10897 return err 10898 } 10899 10900 err := awsRestjson1_deserializeDocumentDirectoryNotEnabledException(&output, shape) 10901 10902 if err != nil { 10903 var snapshot bytes.Buffer 10904 io.Copy(&snapshot, ringBuffer) 10905 err = &smithy.DeserializationError{ 10906 Err: fmt.Errorf("failed to decode response body, %w", err), 10907 Snapshot: snapshot.Bytes(), 10908 } 10909 return err 10910 } 10911 10912 errorBody.Seek(0, io.SeekStart) 10913 10914 return output 10915} 10916 10917func awsRestjson1_deserializeErrorFacetAlreadyExistsException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 10918 output := &types.FacetAlreadyExistsException{} 10919 var buff [1024]byte 10920 ringBuffer := smithyio.NewRingBuffer(buff[:]) 10921 10922 body := io.TeeReader(errorBody, ringBuffer) 10923 decoder := json.NewDecoder(body) 10924 decoder.UseNumber() 10925 var shape interface{} 10926 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 10927 var snapshot bytes.Buffer 10928 io.Copy(&snapshot, ringBuffer) 10929 err = &smithy.DeserializationError{ 10930 Err: fmt.Errorf("failed to decode response body, %w", err), 10931 Snapshot: snapshot.Bytes(), 10932 } 10933 return err 10934 } 10935 10936 err := awsRestjson1_deserializeDocumentFacetAlreadyExistsException(&output, shape) 10937 10938 if err != nil { 10939 var snapshot bytes.Buffer 10940 io.Copy(&snapshot, ringBuffer) 10941 err = &smithy.DeserializationError{ 10942 Err: fmt.Errorf("failed to decode response body, %w", err), 10943 Snapshot: snapshot.Bytes(), 10944 } 10945 return err 10946 } 10947 10948 errorBody.Seek(0, io.SeekStart) 10949 10950 return output 10951} 10952 10953func awsRestjson1_deserializeErrorFacetInUseException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 10954 output := &types.FacetInUseException{} 10955 var buff [1024]byte 10956 ringBuffer := smithyio.NewRingBuffer(buff[:]) 10957 10958 body := io.TeeReader(errorBody, ringBuffer) 10959 decoder := json.NewDecoder(body) 10960 decoder.UseNumber() 10961 var shape interface{} 10962 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 10963 var snapshot bytes.Buffer 10964 io.Copy(&snapshot, ringBuffer) 10965 err = &smithy.DeserializationError{ 10966 Err: fmt.Errorf("failed to decode response body, %w", err), 10967 Snapshot: snapshot.Bytes(), 10968 } 10969 return err 10970 } 10971 10972 err := awsRestjson1_deserializeDocumentFacetInUseException(&output, shape) 10973 10974 if err != nil { 10975 var snapshot bytes.Buffer 10976 io.Copy(&snapshot, ringBuffer) 10977 err = &smithy.DeserializationError{ 10978 Err: fmt.Errorf("failed to decode response body, %w", err), 10979 Snapshot: snapshot.Bytes(), 10980 } 10981 return err 10982 } 10983 10984 errorBody.Seek(0, io.SeekStart) 10985 10986 return output 10987} 10988 10989func awsRestjson1_deserializeErrorFacetNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 10990 output := &types.FacetNotFoundException{} 10991 var buff [1024]byte 10992 ringBuffer := smithyio.NewRingBuffer(buff[:]) 10993 10994 body := io.TeeReader(errorBody, ringBuffer) 10995 decoder := json.NewDecoder(body) 10996 decoder.UseNumber() 10997 var shape interface{} 10998 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 10999 var snapshot bytes.Buffer 11000 io.Copy(&snapshot, ringBuffer) 11001 err = &smithy.DeserializationError{ 11002 Err: fmt.Errorf("failed to decode response body, %w", err), 11003 Snapshot: snapshot.Bytes(), 11004 } 11005 return err 11006 } 11007 11008 err := awsRestjson1_deserializeDocumentFacetNotFoundException(&output, shape) 11009 11010 if err != nil { 11011 var snapshot bytes.Buffer 11012 io.Copy(&snapshot, ringBuffer) 11013 err = &smithy.DeserializationError{ 11014 Err: fmt.Errorf("failed to decode response body, %w", err), 11015 Snapshot: snapshot.Bytes(), 11016 } 11017 return err 11018 } 11019 11020 errorBody.Seek(0, io.SeekStart) 11021 11022 return output 11023} 11024 11025func awsRestjson1_deserializeErrorFacetValidationException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11026 output := &types.FacetValidationException{} 11027 var buff [1024]byte 11028 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11029 11030 body := io.TeeReader(errorBody, ringBuffer) 11031 decoder := json.NewDecoder(body) 11032 decoder.UseNumber() 11033 var shape interface{} 11034 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 11035 var snapshot bytes.Buffer 11036 io.Copy(&snapshot, ringBuffer) 11037 err = &smithy.DeserializationError{ 11038 Err: fmt.Errorf("failed to decode response body, %w", err), 11039 Snapshot: snapshot.Bytes(), 11040 } 11041 return err 11042 } 11043 11044 err := awsRestjson1_deserializeDocumentFacetValidationException(&output, shape) 11045 11046 if err != nil { 11047 var snapshot bytes.Buffer 11048 io.Copy(&snapshot, ringBuffer) 11049 err = &smithy.DeserializationError{ 11050 Err: fmt.Errorf("failed to decode response body, %w", err), 11051 Snapshot: snapshot.Bytes(), 11052 } 11053 return err 11054 } 11055 11056 errorBody.Seek(0, io.SeekStart) 11057 11058 return output 11059} 11060 11061func awsRestjson1_deserializeErrorIncompatibleSchemaException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11062 output := &types.IncompatibleSchemaException{} 11063 var buff [1024]byte 11064 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11065 11066 body := io.TeeReader(errorBody, ringBuffer) 11067 decoder := json.NewDecoder(body) 11068 decoder.UseNumber() 11069 var shape interface{} 11070 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 11071 var snapshot bytes.Buffer 11072 io.Copy(&snapshot, ringBuffer) 11073 err = &smithy.DeserializationError{ 11074 Err: fmt.Errorf("failed to decode response body, %w", err), 11075 Snapshot: snapshot.Bytes(), 11076 } 11077 return err 11078 } 11079 11080 err := awsRestjson1_deserializeDocumentIncompatibleSchemaException(&output, shape) 11081 11082 if err != nil { 11083 var snapshot bytes.Buffer 11084 io.Copy(&snapshot, ringBuffer) 11085 err = &smithy.DeserializationError{ 11086 Err: fmt.Errorf("failed to decode response body, %w", err), 11087 Snapshot: snapshot.Bytes(), 11088 } 11089 return err 11090 } 11091 11092 errorBody.Seek(0, io.SeekStart) 11093 11094 return output 11095} 11096 11097func awsRestjson1_deserializeErrorIndexedAttributeMissingException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11098 output := &types.IndexedAttributeMissingException{} 11099 var buff [1024]byte 11100 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11101 11102 body := io.TeeReader(errorBody, ringBuffer) 11103 decoder := json.NewDecoder(body) 11104 decoder.UseNumber() 11105 var shape interface{} 11106 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 11107 var snapshot bytes.Buffer 11108 io.Copy(&snapshot, ringBuffer) 11109 err = &smithy.DeserializationError{ 11110 Err: fmt.Errorf("failed to decode response body, %w", err), 11111 Snapshot: snapshot.Bytes(), 11112 } 11113 return err 11114 } 11115 11116 err := awsRestjson1_deserializeDocumentIndexedAttributeMissingException(&output, shape) 11117 11118 if err != nil { 11119 var snapshot bytes.Buffer 11120 io.Copy(&snapshot, ringBuffer) 11121 err = &smithy.DeserializationError{ 11122 Err: fmt.Errorf("failed to decode response body, %w", err), 11123 Snapshot: snapshot.Bytes(), 11124 } 11125 return err 11126 } 11127 11128 errorBody.Seek(0, io.SeekStart) 11129 11130 return output 11131} 11132 11133func awsRestjson1_deserializeErrorInternalServiceException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11134 output := &types.InternalServiceException{} 11135 var buff [1024]byte 11136 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11137 11138 body := io.TeeReader(errorBody, ringBuffer) 11139 decoder := json.NewDecoder(body) 11140 decoder.UseNumber() 11141 var shape interface{} 11142 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 11143 var snapshot bytes.Buffer 11144 io.Copy(&snapshot, ringBuffer) 11145 err = &smithy.DeserializationError{ 11146 Err: fmt.Errorf("failed to decode response body, %w", err), 11147 Snapshot: snapshot.Bytes(), 11148 } 11149 return err 11150 } 11151 11152 err := awsRestjson1_deserializeDocumentInternalServiceException(&output, shape) 11153 11154 if err != nil { 11155 var snapshot bytes.Buffer 11156 io.Copy(&snapshot, ringBuffer) 11157 err = &smithy.DeserializationError{ 11158 Err: fmt.Errorf("failed to decode response body, %w", err), 11159 Snapshot: snapshot.Bytes(), 11160 } 11161 return err 11162 } 11163 11164 errorBody.Seek(0, io.SeekStart) 11165 11166 return output 11167} 11168 11169func awsRestjson1_deserializeErrorInvalidArnException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11170 output := &types.InvalidArnException{} 11171 var buff [1024]byte 11172 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11173 11174 body := io.TeeReader(errorBody, ringBuffer) 11175 decoder := json.NewDecoder(body) 11176 decoder.UseNumber() 11177 var shape interface{} 11178 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 11179 var snapshot bytes.Buffer 11180 io.Copy(&snapshot, ringBuffer) 11181 err = &smithy.DeserializationError{ 11182 Err: fmt.Errorf("failed to decode response body, %w", err), 11183 Snapshot: snapshot.Bytes(), 11184 } 11185 return err 11186 } 11187 11188 err := awsRestjson1_deserializeDocumentInvalidArnException(&output, shape) 11189 11190 if err != nil { 11191 var snapshot bytes.Buffer 11192 io.Copy(&snapshot, ringBuffer) 11193 err = &smithy.DeserializationError{ 11194 Err: fmt.Errorf("failed to decode response body, %w", err), 11195 Snapshot: snapshot.Bytes(), 11196 } 11197 return err 11198 } 11199 11200 errorBody.Seek(0, io.SeekStart) 11201 11202 return output 11203} 11204 11205func awsRestjson1_deserializeErrorInvalidAttachmentException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11206 output := &types.InvalidAttachmentException{} 11207 var buff [1024]byte 11208 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11209 11210 body := io.TeeReader(errorBody, ringBuffer) 11211 decoder := json.NewDecoder(body) 11212 decoder.UseNumber() 11213 var shape interface{} 11214 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 11215 var snapshot bytes.Buffer 11216 io.Copy(&snapshot, ringBuffer) 11217 err = &smithy.DeserializationError{ 11218 Err: fmt.Errorf("failed to decode response body, %w", err), 11219 Snapshot: snapshot.Bytes(), 11220 } 11221 return err 11222 } 11223 11224 err := awsRestjson1_deserializeDocumentInvalidAttachmentException(&output, shape) 11225 11226 if err != nil { 11227 var snapshot bytes.Buffer 11228 io.Copy(&snapshot, ringBuffer) 11229 err = &smithy.DeserializationError{ 11230 Err: fmt.Errorf("failed to decode response body, %w", err), 11231 Snapshot: snapshot.Bytes(), 11232 } 11233 return err 11234 } 11235 11236 errorBody.Seek(0, io.SeekStart) 11237 11238 return output 11239} 11240 11241func awsRestjson1_deserializeErrorInvalidFacetUpdateException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11242 output := &types.InvalidFacetUpdateException{} 11243 var buff [1024]byte 11244 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11245 11246 body := io.TeeReader(errorBody, ringBuffer) 11247 decoder := json.NewDecoder(body) 11248 decoder.UseNumber() 11249 var shape interface{} 11250 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 11251 var snapshot bytes.Buffer 11252 io.Copy(&snapshot, ringBuffer) 11253 err = &smithy.DeserializationError{ 11254 Err: fmt.Errorf("failed to decode response body, %w", err), 11255 Snapshot: snapshot.Bytes(), 11256 } 11257 return err 11258 } 11259 11260 err := awsRestjson1_deserializeDocumentInvalidFacetUpdateException(&output, shape) 11261 11262 if err != nil { 11263 var snapshot bytes.Buffer 11264 io.Copy(&snapshot, ringBuffer) 11265 err = &smithy.DeserializationError{ 11266 Err: fmt.Errorf("failed to decode response body, %w", err), 11267 Snapshot: snapshot.Bytes(), 11268 } 11269 return err 11270 } 11271 11272 errorBody.Seek(0, io.SeekStart) 11273 11274 return output 11275} 11276 11277func awsRestjson1_deserializeErrorInvalidNextTokenException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11278 output := &types.InvalidNextTokenException{} 11279 var buff [1024]byte 11280 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11281 11282 body := io.TeeReader(errorBody, ringBuffer) 11283 decoder := json.NewDecoder(body) 11284 decoder.UseNumber() 11285 var shape interface{} 11286 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 11287 var snapshot bytes.Buffer 11288 io.Copy(&snapshot, ringBuffer) 11289 err = &smithy.DeserializationError{ 11290 Err: fmt.Errorf("failed to decode response body, %w", err), 11291 Snapshot: snapshot.Bytes(), 11292 } 11293 return err 11294 } 11295 11296 err := awsRestjson1_deserializeDocumentInvalidNextTokenException(&output, shape) 11297 11298 if err != nil { 11299 var snapshot bytes.Buffer 11300 io.Copy(&snapshot, ringBuffer) 11301 err = &smithy.DeserializationError{ 11302 Err: fmt.Errorf("failed to decode response body, %w", err), 11303 Snapshot: snapshot.Bytes(), 11304 } 11305 return err 11306 } 11307 11308 errorBody.Seek(0, io.SeekStart) 11309 11310 return output 11311} 11312 11313func awsRestjson1_deserializeErrorInvalidRuleException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11314 output := &types.InvalidRuleException{} 11315 var buff [1024]byte 11316 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11317 11318 body := io.TeeReader(errorBody, ringBuffer) 11319 decoder := json.NewDecoder(body) 11320 decoder.UseNumber() 11321 var shape interface{} 11322 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 11323 var snapshot bytes.Buffer 11324 io.Copy(&snapshot, ringBuffer) 11325 err = &smithy.DeserializationError{ 11326 Err: fmt.Errorf("failed to decode response body, %w", err), 11327 Snapshot: snapshot.Bytes(), 11328 } 11329 return err 11330 } 11331 11332 err := awsRestjson1_deserializeDocumentInvalidRuleException(&output, shape) 11333 11334 if err != nil { 11335 var snapshot bytes.Buffer 11336 io.Copy(&snapshot, ringBuffer) 11337 err = &smithy.DeserializationError{ 11338 Err: fmt.Errorf("failed to decode response body, %w", err), 11339 Snapshot: snapshot.Bytes(), 11340 } 11341 return err 11342 } 11343 11344 errorBody.Seek(0, io.SeekStart) 11345 11346 return output 11347} 11348 11349func awsRestjson1_deserializeErrorInvalidSchemaDocException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11350 output := &types.InvalidSchemaDocException{} 11351 var buff [1024]byte 11352 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11353 11354 body := io.TeeReader(errorBody, ringBuffer) 11355 decoder := json.NewDecoder(body) 11356 decoder.UseNumber() 11357 var shape interface{} 11358 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 11359 var snapshot bytes.Buffer 11360 io.Copy(&snapshot, ringBuffer) 11361 err = &smithy.DeserializationError{ 11362 Err: fmt.Errorf("failed to decode response body, %w", err), 11363 Snapshot: snapshot.Bytes(), 11364 } 11365 return err 11366 } 11367 11368 err := awsRestjson1_deserializeDocumentInvalidSchemaDocException(&output, shape) 11369 11370 if err != nil { 11371 var snapshot bytes.Buffer 11372 io.Copy(&snapshot, ringBuffer) 11373 err = &smithy.DeserializationError{ 11374 Err: fmt.Errorf("failed to decode response body, %w", err), 11375 Snapshot: snapshot.Bytes(), 11376 } 11377 return err 11378 } 11379 11380 errorBody.Seek(0, io.SeekStart) 11381 11382 return output 11383} 11384 11385func awsRestjson1_deserializeErrorInvalidTaggingRequestException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11386 output := &types.InvalidTaggingRequestException{} 11387 var buff [1024]byte 11388 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11389 11390 body := io.TeeReader(errorBody, ringBuffer) 11391 decoder := json.NewDecoder(body) 11392 decoder.UseNumber() 11393 var shape interface{} 11394 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 11395 var snapshot bytes.Buffer 11396 io.Copy(&snapshot, ringBuffer) 11397 err = &smithy.DeserializationError{ 11398 Err: fmt.Errorf("failed to decode response body, %w", err), 11399 Snapshot: snapshot.Bytes(), 11400 } 11401 return err 11402 } 11403 11404 err := awsRestjson1_deserializeDocumentInvalidTaggingRequestException(&output, shape) 11405 11406 if err != nil { 11407 var snapshot bytes.Buffer 11408 io.Copy(&snapshot, ringBuffer) 11409 err = &smithy.DeserializationError{ 11410 Err: fmt.Errorf("failed to decode response body, %w", err), 11411 Snapshot: snapshot.Bytes(), 11412 } 11413 return err 11414 } 11415 11416 errorBody.Seek(0, io.SeekStart) 11417 11418 return output 11419} 11420 11421func awsRestjson1_deserializeErrorLimitExceededException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11422 output := &types.LimitExceededException{} 11423 var buff [1024]byte 11424 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11425 11426 body := io.TeeReader(errorBody, ringBuffer) 11427 decoder := json.NewDecoder(body) 11428 decoder.UseNumber() 11429 var shape interface{} 11430 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 11431 var snapshot bytes.Buffer 11432 io.Copy(&snapshot, ringBuffer) 11433 err = &smithy.DeserializationError{ 11434 Err: fmt.Errorf("failed to decode response body, %w", err), 11435 Snapshot: snapshot.Bytes(), 11436 } 11437 return err 11438 } 11439 11440 err := awsRestjson1_deserializeDocumentLimitExceededException(&output, shape) 11441 11442 if err != nil { 11443 var snapshot bytes.Buffer 11444 io.Copy(&snapshot, ringBuffer) 11445 err = &smithy.DeserializationError{ 11446 Err: fmt.Errorf("failed to decode response body, %w", err), 11447 Snapshot: snapshot.Bytes(), 11448 } 11449 return err 11450 } 11451 11452 errorBody.Seek(0, io.SeekStart) 11453 11454 return output 11455} 11456 11457func awsRestjson1_deserializeErrorLinkNameAlreadyInUseException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11458 output := &types.LinkNameAlreadyInUseException{} 11459 var buff [1024]byte 11460 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11461 11462 body := io.TeeReader(errorBody, ringBuffer) 11463 decoder := json.NewDecoder(body) 11464 decoder.UseNumber() 11465 var shape interface{} 11466 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 11467 var snapshot bytes.Buffer 11468 io.Copy(&snapshot, ringBuffer) 11469 err = &smithy.DeserializationError{ 11470 Err: fmt.Errorf("failed to decode response body, %w", err), 11471 Snapshot: snapshot.Bytes(), 11472 } 11473 return err 11474 } 11475 11476 err := awsRestjson1_deserializeDocumentLinkNameAlreadyInUseException(&output, shape) 11477 11478 if err != nil { 11479 var snapshot bytes.Buffer 11480 io.Copy(&snapshot, ringBuffer) 11481 err = &smithy.DeserializationError{ 11482 Err: fmt.Errorf("failed to decode response body, %w", err), 11483 Snapshot: snapshot.Bytes(), 11484 } 11485 return err 11486 } 11487 11488 errorBody.Seek(0, io.SeekStart) 11489 11490 return output 11491} 11492 11493func awsRestjson1_deserializeErrorNotIndexException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11494 output := &types.NotIndexException{} 11495 var buff [1024]byte 11496 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11497 11498 body := io.TeeReader(errorBody, ringBuffer) 11499 decoder := json.NewDecoder(body) 11500 decoder.UseNumber() 11501 var shape interface{} 11502 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 11503 var snapshot bytes.Buffer 11504 io.Copy(&snapshot, ringBuffer) 11505 err = &smithy.DeserializationError{ 11506 Err: fmt.Errorf("failed to decode response body, %w", err), 11507 Snapshot: snapshot.Bytes(), 11508 } 11509 return err 11510 } 11511 11512 err := awsRestjson1_deserializeDocumentNotIndexException(&output, shape) 11513 11514 if err != nil { 11515 var snapshot bytes.Buffer 11516 io.Copy(&snapshot, ringBuffer) 11517 err = &smithy.DeserializationError{ 11518 Err: fmt.Errorf("failed to decode response body, %w", err), 11519 Snapshot: snapshot.Bytes(), 11520 } 11521 return err 11522 } 11523 11524 errorBody.Seek(0, io.SeekStart) 11525 11526 return output 11527} 11528 11529func awsRestjson1_deserializeErrorNotNodeException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11530 output := &types.NotNodeException{} 11531 var buff [1024]byte 11532 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11533 11534 body := io.TeeReader(errorBody, ringBuffer) 11535 decoder := json.NewDecoder(body) 11536 decoder.UseNumber() 11537 var shape interface{} 11538 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 11539 var snapshot bytes.Buffer 11540 io.Copy(&snapshot, ringBuffer) 11541 err = &smithy.DeserializationError{ 11542 Err: fmt.Errorf("failed to decode response body, %w", err), 11543 Snapshot: snapshot.Bytes(), 11544 } 11545 return err 11546 } 11547 11548 err := awsRestjson1_deserializeDocumentNotNodeException(&output, shape) 11549 11550 if err != nil { 11551 var snapshot bytes.Buffer 11552 io.Copy(&snapshot, ringBuffer) 11553 err = &smithy.DeserializationError{ 11554 Err: fmt.Errorf("failed to decode response body, %w", err), 11555 Snapshot: snapshot.Bytes(), 11556 } 11557 return err 11558 } 11559 11560 errorBody.Seek(0, io.SeekStart) 11561 11562 return output 11563} 11564 11565func awsRestjson1_deserializeErrorNotPolicyException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11566 output := &types.NotPolicyException{} 11567 var buff [1024]byte 11568 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11569 11570 body := io.TeeReader(errorBody, ringBuffer) 11571 decoder := json.NewDecoder(body) 11572 decoder.UseNumber() 11573 var shape interface{} 11574 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 11575 var snapshot bytes.Buffer 11576 io.Copy(&snapshot, ringBuffer) 11577 err = &smithy.DeserializationError{ 11578 Err: fmt.Errorf("failed to decode response body, %w", err), 11579 Snapshot: snapshot.Bytes(), 11580 } 11581 return err 11582 } 11583 11584 err := awsRestjson1_deserializeDocumentNotPolicyException(&output, shape) 11585 11586 if err != nil { 11587 var snapshot bytes.Buffer 11588 io.Copy(&snapshot, ringBuffer) 11589 err = &smithy.DeserializationError{ 11590 Err: fmt.Errorf("failed to decode response body, %w", err), 11591 Snapshot: snapshot.Bytes(), 11592 } 11593 return err 11594 } 11595 11596 errorBody.Seek(0, io.SeekStart) 11597 11598 return output 11599} 11600 11601func awsRestjson1_deserializeErrorObjectAlreadyDetachedException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11602 output := &types.ObjectAlreadyDetachedException{} 11603 var buff [1024]byte 11604 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11605 11606 body := io.TeeReader(errorBody, ringBuffer) 11607 decoder := json.NewDecoder(body) 11608 decoder.UseNumber() 11609 var shape interface{} 11610 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 11611 var snapshot bytes.Buffer 11612 io.Copy(&snapshot, ringBuffer) 11613 err = &smithy.DeserializationError{ 11614 Err: fmt.Errorf("failed to decode response body, %w", err), 11615 Snapshot: snapshot.Bytes(), 11616 } 11617 return err 11618 } 11619 11620 err := awsRestjson1_deserializeDocumentObjectAlreadyDetachedException(&output, shape) 11621 11622 if err != nil { 11623 var snapshot bytes.Buffer 11624 io.Copy(&snapshot, ringBuffer) 11625 err = &smithy.DeserializationError{ 11626 Err: fmt.Errorf("failed to decode response body, %w", err), 11627 Snapshot: snapshot.Bytes(), 11628 } 11629 return err 11630 } 11631 11632 errorBody.Seek(0, io.SeekStart) 11633 11634 return output 11635} 11636 11637func awsRestjson1_deserializeErrorObjectNotDetachedException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11638 output := &types.ObjectNotDetachedException{} 11639 var buff [1024]byte 11640 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11641 11642 body := io.TeeReader(errorBody, ringBuffer) 11643 decoder := json.NewDecoder(body) 11644 decoder.UseNumber() 11645 var shape interface{} 11646 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 11647 var snapshot bytes.Buffer 11648 io.Copy(&snapshot, ringBuffer) 11649 err = &smithy.DeserializationError{ 11650 Err: fmt.Errorf("failed to decode response body, %w", err), 11651 Snapshot: snapshot.Bytes(), 11652 } 11653 return err 11654 } 11655 11656 err := awsRestjson1_deserializeDocumentObjectNotDetachedException(&output, shape) 11657 11658 if err != nil { 11659 var snapshot bytes.Buffer 11660 io.Copy(&snapshot, ringBuffer) 11661 err = &smithy.DeserializationError{ 11662 Err: fmt.Errorf("failed to decode response body, %w", err), 11663 Snapshot: snapshot.Bytes(), 11664 } 11665 return err 11666 } 11667 11668 errorBody.Seek(0, io.SeekStart) 11669 11670 return output 11671} 11672 11673func awsRestjson1_deserializeErrorResourceNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11674 output := &types.ResourceNotFoundException{} 11675 var buff [1024]byte 11676 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11677 11678 body := io.TeeReader(errorBody, ringBuffer) 11679 decoder := json.NewDecoder(body) 11680 decoder.UseNumber() 11681 var shape interface{} 11682 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 11683 var snapshot bytes.Buffer 11684 io.Copy(&snapshot, ringBuffer) 11685 err = &smithy.DeserializationError{ 11686 Err: fmt.Errorf("failed to decode response body, %w", err), 11687 Snapshot: snapshot.Bytes(), 11688 } 11689 return err 11690 } 11691 11692 err := awsRestjson1_deserializeDocumentResourceNotFoundException(&output, shape) 11693 11694 if err != nil { 11695 var snapshot bytes.Buffer 11696 io.Copy(&snapshot, ringBuffer) 11697 err = &smithy.DeserializationError{ 11698 Err: fmt.Errorf("failed to decode response body, %w", err), 11699 Snapshot: snapshot.Bytes(), 11700 } 11701 return err 11702 } 11703 11704 errorBody.Seek(0, io.SeekStart) 11705 11706 return output 11707} 11708 11709func awsRestjson1_deserializeErrorRetryableConflictException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11710 output := &types.RetryableConflictException{} 11711 var buff [1024]byte 11712 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11713 11714 body := io.TeeReader(errorBody, ringBuffer) 11715 decoder := json.NewDecoder(body) 11716 decoder.UseNumber() 11717 var shape interface{} 11718 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 11719 var snapshot bytes.Buffer 11720 io.Copy(&snapshot, ringBuffer) 11721 err = &smithy.DeserializationError{ 11722 Err: fmt.Errorf("failed to decode response body, %w", err), 11723 Snapshot: snapshot.Bytes(), 11724 } 11725 return err 11726 } 11727 11728 err := awsRestjson1_deserializeDocumentRetryableConflictException(&output, shape) 11729 11730 if err != nil { 11731 var snapshot bytes.Buffer 11732 io.Copy(&snapshot, ringBuffer) 11733 err = &smithy.DeserializationError{ 11734 Err: fmt.Errorf("failed to decode response body, %w", err), 11735 Snapshot: snapshot.Bytes(), 11736 } 11737 return err 11738 } 11739 11740 errorBody.Seek(0, io.SeekStart) 11741 11742 return output 11743} 11744 11745func awsRestjson1_deserializeErrorSchemaAlreadyExistsException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11746 output := &types.SchemaAlreadyExistsException{} 11747 var buff [1024]byte 11748 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11749 11750 body := io.TeeReader(errorBody, ringBuffer) 11751 decoder := json.NewDecoder(body) 11752 decoder.UseNumber() 11753 var shape interface{} 11754 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 11755 var snapshot bytes.Buffer 11756 io.Copy(&snapshot, ringBuffer) 11757 err = &smithy.DeserializationError{ 11758 Err: fmt.Errorf("failed to decode response body, %w", err), 11759 Snapshot: snapshot.Bytes(), 11760 } 11761 return err 11762 } 11763 11764 err := awsRestjson1_deserializeDocumentSchemaAlreadyExistsException(&output, shape) 11765 11766 if err != nil { 11767 var snapshot bytes.Buffer 11768 io.Copy(&snapshot, ringBuffer) 11769 err = &smithy.DeserializationError{ 11770 Err: fmt.Errorf("failed to decode response body, %w", err), 11771 Snapshot: snapshot.Bytes(), 11772 } 11773 return err 11774 } 11775 11776 errorBody.Seek(0, io.SeekStart) 11777 11778 return output 11779} 11780 11781func awsRestjson1_deserializeErrorSchemaAlreadyPublishedException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11782 output := &types.SchemaAlreadyPublishedException{} 11783 var buff [1024]byte 11784 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11785 11786 body := io.TeeReader(errorBody, ringBuffer) 11787 decoder := json.NewDecoder(body) 11788 decoder.UseNumber() 11789 var shape interface{} 11790 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 11791 var snapshot bytes.Buffer 11792 io.Copy(&snapshot, ringBuffer) 11793 err = &smithy.DeserializationError{ 11794 Err: fmt.Errorf("failed to decode response body, %w", err), 11795 Snapshot: snapshot.Bytes(), 11796 } 11797 return err 11798 } 11799 11800 err := awsRestjson1_deserializeDocumentSchemaAlreadyPublishedException(&output, shape) 11801 11802 if err != nil { 11803 var snapshot bytes.Buffer 11804 io.Copy(&snapshot, ringBuffer) 11805 err = &smithy.DeserializationError{ 11806 Err: fmt.Errorf("failed to decode response body, %w", err), 11807 Snapshot: snapshot.Bytes(), 11808 } 11809 return err 11810 } 11811 11812 errorBody.Seek(0, io.SeekStart) 11813 11814 return output 11815} 11816 11817func awsRestjson1_deserializeErrorStillContainsLinksException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11818 output := &types.StillContainsLinksException{} 11819 var buff [1024]byte 11820 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11821 11822 body := io.TeeReader(errorBody, ringBuffer) 11823 decoder := json.NewDecoder(body) 11824 decoder.UseNumber() 11825 var shape interface{} 11826 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 11827 var snapshot bytes.Buffer 11828 io.Copy(&snapshot, ringBuffer) 11829 err = &smithy.DeserializationError{ 11830 Err: fmt.Errorf("failed to decode response body, %w", err), 11831 Snapshot: snapshot.Bytes(), 11832 } 11833 return err 11834 } 11835 11836 err := awsRestjson1_deserializeDocumentStillContainsLinksException(&output, shape) 11837 11838 if err != nil { 11839 var snapshot bytes.Buffer 11840 io.Copy(&snapshot, ringBuffer) 11841 err = &smithy.DeserializationError{ 11842 Err: fmt.Errorf("failed to decode response body, %w", err), 11843 Snapshot: snapshot.Bytes(), 11844 } 11845 return err 11846 } 11847 11848 errorBody.Seek(0, io.SeekStart) 11849 11850 return output 11851} 11852 11853func awsRestjson1_deserializeErrorUnsupportedIndexTypeException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11854 output := &types.UnsupportedIndexTypeException{} 11855 var buff [1024]byte 11856 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11857 11858 body := io.TeeReader(errorBody, ringBuffer) 11859 decoder := json.NewDecoder(body) 11860 decoder.UseNumber() 11861 var shape interface{} 11862 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 11863 var snapshot bytes.Buffer 11864 io.Copy(&snapshot, ringBuffer) 11865 err = &smithy.DeserializationError{ 11866 Err: fmt.Errorf("failed to decode response body, %w", err), 11867 Snapshot: snapshot.Bytes(), 11868 } 11869 return err 11870 } 11871 11872 err := awsRestjson1_deserializeDocumentUnsupportedIndexTypeException(&output, shape) 11873 11874 if err != nil { 11875 var snapshot bytes.Buffer 11876 io.Copy(&snapshot, ringBuffer) 11877 err = &smithy.DeserializationError{ 11878 Err: fmt.Errorf("failed to decode response body, %w", err), 11879 Snapshot: snapshot.Bytes(), 11880 } 11881 return err 11882 } 11883 11884 errorBody.Seek(0, io.SeekStart) 11885 11886 return output 11887} 11888 11889func awsRestjson1_deserializeErrorValidationException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 11890 output := &types.ValidationException{} 11891 var buff [1024]byte 11892 ringBuffer := smithyio.NewRingBuffer(buff[:]) 11893 11894 body := io.TeeReader(errorBody, ringBuffer) 11895 decoder := json.NewDecoder(body) 11896 decoder.UseNumber() 11897 var shape interface{} 11898 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 11899 var snapshot bytes.Buffer 11900 io.Copy(&snapshot, ringBuffer) 11901 err = &smithy.DeserializationError{ 11902 Err: fmt.Errorf("failed to decode response body, %w", err), 11903 Snapshot: snapshot.Bytes(), 11904 } 11905 return err 11906 } 11907 11908 err := awsRestjson1_deserializeDocumentValidationException(&output, shape) 11909 11910 if err != nil { 11911 var snapshot bytes.Buffer 11912 io.Copy(&snapshot, ringBuffer) 11913 err = &smithy.DeserializationError{ 11914 Err: fmt.Errorf("failed to decode response body, %w", err), 11915 Snapshot: snapshot.Bytes(), 11916 } 11917 return err 11918 } 11919 11920 errorBody.Seek(0, io.SeekStart) 11921 11922 return output 11923} 11924 11925func awsRestjson1_deserializeDocumentAccessDeniedException(v **types.AccessDeniedException, value interface{}) error { 11926 if v == nil { 11927 return fmt.Errorf("unexpected nil of type %T", v) 11928 } 11929 if value == nil { 11930 return nil 11931 } 11932 11933 shape, ok := value.(map[string]interface{}) 11934 if !ok { 11935 return fmt.Errorf("unexpected JSON type %v", value) 11936 } 11937 11938 var sv *types.AccessDeniedException 11939 if *v == nil { 11940 sv = &types.AccessDeniedException{} 11941 } else { 11942 sv = *v 11943 } 11944 11945 for key, value := range shape { 11946 switch key { 11947 case "Message": 11948 if value != nil { 11949 jtv, ok := value.(string) 11950 if !ok { 11951 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 11952 } 11953 sv.Message = ptr.String(jtv) 11954 } 11955 11956 default: 11957 _, _ = key, value 11958 11959 } 11960 } 11961 *v = sv 11962 return nil 11963} 11964 11965func awsRestjson1_deserializeDocumentArns(v *[]string, value interface{}) error { 11966 if v == nil { 11967 return fmt.Errorf("unexpected nil of type %T", v) 11968 } 11969 if value == nil { 11970 return nil 11971 } 11972 11973 shape, ok := value.([]interface{}) 11974 if !ok { 11975 return fmt.Errorf("unexpected JSON type %v", value) 11976 } 11977 11978 var cv []string 11979 if *v == nil { 11980 cv = []string{} 11981 } else { 11982 cv = *v 11983 } 11984 11985 for _, value := range shape { 11986 var col string 11987 if value != nil { 11988 jtv, ok := value.(string) 11989 if !ok { 11990 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 11991 } 11992 col = jtv 11993 } 11994 cv = append(cv, col) 11995 11996 } 11997 *v = cv 11998 return nil 11999} 12000 12001func awsRestjson1_deserializeDocumentAttributeKey(v **types.AttributeKey, value interface{}) error { 12002 if v == nil { 12003 return fmt.Errorf("unexpected nil of type %T", v) 12004 } 12005 if value == nil { 12006 return nil 12007 } 12008 12009 shape, ok := value.(map[string]interface{}) 12010 if !ok { 12011 return fmt.Errorf("unexpected JSON type %v", value) 12012 } 12013 12014 var sv *types.AttributeKey 12015 if *v == nil { 12016 sv = &types.AttributeKey{} 12017 } else { 12018 sv = *v 12019 } 12020 12021 for key, value := range shape { 12022 switch key { 12023 case "FacetName": 12024 if value != nil { 12025 jtv, ok := value.(string) 12026 if !ok { 12027 return fmt.Errorf("expected FacetName to be of type string, got %T instead", value) 12028 } 12029 sv.FacetName = ptr.String(jtv) 12030 } 12031 12032 case "Name": 12033 if value != nil { 12034 jtv, ok := value.(string) 12035 if !ok { 12036 return fmt.Errorf("expected AttributeName to be of type string, got %T instead", value) 12037 } 12038 sv.Name = ptr.String(jtv) 12039 } 12040 12041 case "SchemaArn": 12042 if value != nil { 12043 jtv, ok := value.(string) 12044 if !ok { 12045 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 12046 } 12047 sv.SchemaArn = ptr.String(jtv) 12048 } 12049 12050 default: 12051 _, _ = key, value 12052 12053 } 12054 } 12055 *v = sv 12056 return nil 12057} 12058 12059func awsRestjson1_deserializeDocumentAttributeKeyAndValue(v **types.AttributeKeyAndValue, value interface{}) error { 12060 if v == nil { 12061 return fmt.Errorf("unexpected nil of type %T", v) 12062 } 12063 if value == nil { 12064 return nil 12065 } 12066 12067 shape, ok := value.(map[string]interface{}) 12068 if !ok { 12069 return fmt.Errorf("unexpected JSON type %v", value) 12070 } 12071 12072 var sv *types.AttributeKeyAndValue 12073 if *v == nil { 12074 sv = &types.AttributeKeyAndValue{} 12075 } else { 12076 sv = *v 12077 } 12078 12079 for key, value := range shape { 12080 switch key { 12081 case "Key": 12082 if err := awsRestjson1_deserializeDocumentAttributeKey(&sv.Key, value); err != nil { 12083 return err 12084 } 12085 12086 case "Value": 12087 if err := awsRestjson1_deserializeDocumentTypedAttributeValue(&sv.Value, value); err != nil { 12088 return err 12089 } 12090 12091 default: 12092 _, _ = key, value 12093 12094 } 12095 } 12096 *v = sv 12097 return nil 12098} 12099 12100func awsRestjson1_deserializeDocumentAttributeKeyAndValueList(v *[]types.AttributeKeyAndValue, value interface{}) error { 12101 if v == nil { 12102 return fmt.Errorf("unexpected nil of type %T", v) 12103 } 12104 if value == nil { 12105 return nil 12106 } 12107 12108 shape, ok := value.([]interface{}) 12109 if !ok { 12110 return fmt.Errorf("unexpected JSON type %v", value) 12111 } 12112 12113 var cv []types.AttributeKeyAndValue 12114 if *v == nil { 12115 cv = []types.AttributeKeyAndValue{} 12116 } else { 12117 cv = *v 12118 } 12119 12120 for _, value := range shape { 12121 var col types.AttributeKeyAndValue 12122 destAddr := &col 12123 if err := awsRestjson1_deserializeDocumentAttributeKeyAndValue(&destAddr, value); err != nil { 12124 return err 12125 } 12126 col = *destAddr 12127 cv = append(cv, col) 12128 12129 } 12130 *v = cv 12131 return nil 12132} 12133 12134func awsRestjson1_deserializeDocumentAttributeNameAndValue(v **types.AttributeNameAndValue, value interface{}) error { 12135 if v == nil { 12136 return fmt.Errorf("unexpected nil of type %T", v) 12137 } 12138 if value == nil { 12139 return nil 12140 } 12141 12142 shape, ok := value.(map[string]interface{}) 12143 if !ok { 12144 return fmt.Errorf("unexpected JSON type %v", value) 12145 } 12146 12147 var sv *types.AttributeNameAndValue 12148 if *v == nil { 12149 sv = &types.AttributeNameAndValue{} 12150 } else { 12151 sv = *v 12152 } 12153 12154 for key, value := range shape { 12155 switch key { 12156 case "AttributeName": 12157 if value != nil { 12158 jtv, ok := value.(string) 12159 if !ok { 12160 return fmt.Errorf("expected AttributeName to be of type string, got %T instead", value) 12161 } 12162 sv.AttributeName = ptr.String(jtv) 12163 } 12164 12165 case "Value": 12166 if err := awsRestjson1_deserializeDocumentTypedAttributeValue(&sv.Value, value); err != nil { 12167 return err 12168 } 12169 12170 default: 12171 _, _ = key, value 12172 12173 } 12174 } 12175 *v = sv 12176 return nil 12177} 12178 12179func awsRestjson1_deserializeDocumentAttributeNameAndValueList(v *[]types.AttributeNameAndValue, value interface{}) error { 12180 if v == nil { 12181 return fmt.Errorf("unexpected nil of type %T", v) 12182 } 12183 if value == nil { 12184 return nil 12185 } 12186 12187 shape, ok := value.([]interface{}) 12188 if !ok { 12189 return fmt.Errorf("unexpected JSON type %v", value) 12190 } 12191 12192 var cv []types.AttributeNameAndValue 12193 if *v == nil { 12194 cv = []types.AttributeNameAndValue{} 12195 } else { 12196 cv = *v 12197 } 12198 12199 for _, value := range shape { 12200 var col types.AttributeNameAndValue 12201 destAddr := &col 12202 if err := awsRestjson1_deserializeDocumentAttributeNameAndValue(&destAddr, value); err != nil { 12203 return err 12204 } 12205 col = *destAddr 12206 cv = append(cv, col) 12207 12208 } 12209 *v = cv 12210 return nil 12211} 12212 12213func awsRestjson1_deserializeDocumentAttributeNameList(v *[]string, value interface{}) error { 12214 if v == nil { 12215 return fmt.Errorf("unexpected nil of type %T", v) 12216 } 12217 if value == nil { 12218 return nil 12219 } 12220 12221 shape, ok := value.([]interface{}) 12222 if !ok { 12223 return fmt.Errorf("unexpected JSON type %v", value) 12224 } 12225 12226 var cv []string 12227 if *v == nil { 12228 cv = []string{} 12229 } else { 12230 cv = *v 12231 } 12232 12233 for _, value := range shape { 12234 var col string 12235 if value != nil { 12236 jtv, ok := value.(string) 12237 if !ok { 12238 return fmt.Errorf("expected AttributeName to be of type string, got %T instead", value) 12239 } 12240 col = jtv 12241 } 12242 cv = append(cv, col) 12243 12244 } 12245 *v = cv 12246 return nil 12247} 12248 12249func awsRestjson1_deserializeDocumentBatchAddFacetToObjectResponse(v **types.BatchAddFacetToObjectResponse, value interface{}) error { 12250 if v == nil { 12251 return fmt.Errorf("unexpected nil of type %T", v) 12252 } 12253 if value == nil { 12254 return nil 12255 } 12256 12257 shape, ok := value.(map[string]interface{}) 12258 if !ok { 12259 return fmt.Errorf("unexpected JSON type %v", value) 12260 } 12261 12262 var sv *types.BatchAddFacetToObjectResponse 12263 if *v == nil { 12264 sv = &types.BatchAddFacetToObjectResponse{} 12265 } else { 12266 sv = *v 12267 } 12268 12269 for key, value := range shape { 12270 switch key { 12271 default: 12272 _, _ = key, value 12273 12274 } 12275 } 12276 *v = sv 12277 return nil 12278} 12279 12280func awsRestjson1_deserializeDocumentBatchAttachObjectResponse(v **types.BatchAttachObjectResponse, value interface{}) error { 12281 if v == nil { 12282 return fmt.Errorf("unexpected nil of type %T", v) 12283 } 12284 if value == nil { 12285 return nil 12286 } 12287 12288 shape, ok := value.(map[string]interface{}) 12289 if !ok { 12290 return fmt.Errorf("unexpected JSON type %v", value) 12291 } 12292 12293 var sv *types.BatchAttachObjectResponse 12294 if *v == nil { 12295 sv = &types.BatchAttachObjectResponse{} 12296 } else { 12297 sv = *v 12298 } 12299 12300 for key, value := range shape { 12301 switch key { 12302 case "attachedObjectIdentifier": 12303 if value != nil { 12304 jtv, ok := value.(string) 12305 if !ok { 12306 return fmt.Errorf("expected ObjectIdentifier to be of type string, got %T instead", value) 12307 } 12308 sv.AttachedObjectIdentifier = ptr.String(jtv) 12309 } 12310 12311 default: 12312 _, _ = key, value 12313 12314 } 12315 } 12316 *v = sv 12317 return nil 12318} 12319 12320func awsRestjson1_deserializeDocumentBatchAttachPolicyResponse(v **types.BatchAttachPolicyResponse, value interface{}) error { 12321 if v == nil { 12322 return fmt.Errorf("unexpected nil of type %T", v) 12323 } 12324 if value == nil { 12325 return nil 12326 } 12327 12328 shape, ok := value.(map[string]interface{}) 12329 if !ok { 12330 return fmt.Errorf("unexpected JSON type %v", value) 12331 } 12332 12333 var sv *types.BatchAttachPolicyResponse 12334 if *v == nil { 12335 sv = &types.BatchAttachPolicyResponse{} 12336 } else { 12337 sv = *v 12338 } 12339 12340 for key, value := range shape { 12341 switch key { 12342 default: 12343 _, _ = key, value 12344 12345 } 12346 } 12347 *v = sv 12348 return nil 12349} 12350 12351func awsRestjson1_deserializeDocumentBatchAttachToIndexResponse(v **types.BatchAttachToIndexResponse, value interface{}) error { 12352 if v == nil { 12353 return fmt.Errorf("unexpected nil of type %T", v) 12354 } 12355 if value == nil { 12356 return nil 12357 } 12358 12359 shape, ok := value.(map[string]interface{}) 12360 if !ok { 12361 return fmt.Errorf("unexpected JSON type %v", value) 12362 } 12363 12364 var sv *types.BatchAttachToIndexResponse 12365 if *v == nil { 12366 sv = &types.BatchAttachToIndexResponse{} 12367 } else { 12368 sv = *v 12369 } 12370 12371 for key, value := range shape { 12372 switch key { 12373 case "AttachedObjectIdentifier": 12374 if value != nil { 12375 jtv, ok := value.(string) 12376 if !ok { 12377 return fmt.Errorf("expected ObjectIdentifier to be of type string, got %T instead", value) 12378 } 12379 sv.AttachedObjectIdentifier = ptr.String(jtv) 12380 } 12381 12382 default: 12383 _, _ = key, value 12384 12385 } 12386 } 12387 *v = sv 12388 return nil 12389} 12390 12391func awsRestjson1_deserializeDocumentBatchAttachTypedLinkResponse(v **types.BatchAttachTypedLinkResponse, value interface{}) error { 12392 if v == nil { 12393 return fmt.Errorf("unexpected nil of type %T", v) 12394 } 12395 if value == nil { 12396 return nil 12397 } 12398 12399 shape, ok := value.(map[string]interface{}) 12400 if !ok { 12401 return fmt.Errorf("unexpected JSON type %v", value) 12402 } 12403 12404 var sv *types.BatchAttachTypedLinkResponse 12405 if *v == nil { 12406 sv = &types.BatchAttachTypedLinkResponse{} 12407 } else { 12408 sv = *v 12409 } 12410 12411 for key, value := range shape { 12412 switch key { 12413 case "TypedLinkSpecifier": 12414 if err := awsRestjson1_deserializeDocumentTypedLinkSpecifier(&sv.TypedLinkSpecifier, value); err != nil { 12415 return err 12416 } 12417 12418 default: 12419 _, _ = key, value 12420 12421 } 12422 } 12423 *v = sv 12424 return nil 12425} 12426 12427func awsRestjson1_deserializeDocumentBatchCreateIndexResponse(v **types.BatchCreateIndexResponse, value interface{}) error { 12428 if v == nil { 12429 return fmt.Errorf("unexpected nil of type %T", v) 12430 } 12431 if value == nil { 12432 return nil 12433 } 12434 12435 shape, ok := value.(map[string]interface{}) 12436 if !ok { 12437 return fmt.Errorf("unexpected JSON type %v", value) 12438 } 12439 12440 var sv *types.BatchCreateIndexResponse 12441 if *v == nil { 12442 sv = &types.BatchCreateIndexResponse{} 12443 } else { 12444 sv = *v 12445 } 12446 12447 for key, value := range shape { 12448 switch key { 12449 case "ObjectIdentifier": 12450 if value != nil { 12451 jtv, ok := value.(string) 12452 if !ok { 12453 return fmt.Errorf("expected ObjectIdentifier to be of type string, got %T instead", value) 12454 } 12455 sv.ObjectIdentifier = ptr.String(jtv) 12456 } 12457 12458 default: 12459 _, _ = key, value 12460 12461 } 12462 } 12463 *v = sv 12464 return nil 12465} 12466 12467func awsRestjson1_deserializeDocumentBatchCreateObjectResponse(v **types.BatchCreateObjectResponse, value interface{}) error { 12468 if v == nil { 12469 return fmt.Errorf("unexpected nil of type %T", v) 12470 } 12471 if value == nil { 12472 return nil 12473 } 12474 12475 shape, ok := value.(map[string]interface{}) 12476 if !ok { 12477 return fmt.Errorf("unexpected JSON type %v", value) 12478 } 12479 12480 var sv *types.BatchCreateObjectResponse 12481 if *v == nil { 12482 sv = &types.BatchCreateObjectResponse{} 12483 } else { 12484 sv = *v 12485 } 12486 12487 for key, value := range shape { 12488 switch key { 12489 case "ObjectIdentifier": 12490 if value != nil { 12491 jtv, ok := value.(string) 12492 if !ok { 12493 return fmt.Errorf("expected ObjectIdentifier to be of type string, got %T instead", value) 12494 } 12495 sv.ObjectIdentifier = ptr.String(jtv) 12496 } 12497 12498 default: 12499 _, _ = key, value 12500 12501 } 12502 } 12503 *v = sv 12504 return nil 12505} 12506 12507func awsRestjson1_deserializeDocumentBatchDeleteObjectResponse(v **types.BatchDeleteObjectResponse, value interface{}) error { 12508 if v == nil { 12509 return fmt.Errorf("unexpected nil of type %T", v) 12510 } 12511 if value == nil { 12512 return nil 12513 } 12514 12515 shape, ok := value.(map[string]interface{}) 12516 if !ok { 12517 return fmt.Errorf("unexpected JSON type %v", value) 12518 } 12519 12520 var sv *types.BatchDeleteObjectResponse 12521 if *v == nil { 12522 sv = &types.BatchDeleteObjectResponse{} 12523 } else { 12524 sv = *v 12525 } 12526 12527 for key, value := range shape { 12528 switch key { 12529 default: 12530 _, _ = key, value 12531 12532 } 12533 } 12534 *v = sv 12535 return nil 12536} 12537 12538func awsRestjson1_deserializeDocumentBatchDetachFromIndexResponse(v **types.BatchDetachFromIndexResponse, value interface{}) error { 12539 if v == nil { 12540 return fmt.Errorf("unexpected nil of type %T", v) 12541 } 12542 if value == nil { 12543 return nil 12544 } 12545 12546 shape, ok := value.(map[string]interface{}) 12547 if !ok { 12548 return fmt.Errorf("unexpected JSON type %v", value) 12549 } 12550 12551 var sv *types.BatchDetachFromIndexResponse 12552 if *v == nil { 12553 sv = &types.BatchDetachFromIndexResponse{} 12554 } else { 12555 sv = *v 12556 } 12557 12558 for key, value := range shape { 12559 switch key { 12560 case "DetachedObjectIdentifier": 12561 if value != nil { 12562 jtv, ok := value.(string) 12563 if !ok { 12564 return fmt.Errorf("expected ObjectIdentifier to be of type string, got %T instead", value) 12565 } 12566 sv.DetachedObjectIdentifier = ptr.String(jtv) 12567 } 12568 12569 default: 12570 _, _ = key, value 12571 12572 } 12573 } 12574 *v = sv 12575 return nil 12576} 12577 12578func awsRestjson1_deserializeDocumentBatchDetachObjectResponse(v **types.BatchDetachObjectResponse, value interface{}) error { 12579 if v == nil { 12580 return fmt.Errorf("unexpected nil of type %T", v) 12581 } 12582 if value == nil { 12583 return nil 12584 } 12585 12586 shape, ok := value.(map[string]interface{}) 12587 if !ok { 12588 return fmt.Errorf("unexpected JSON type %v", value) 12589 } 12590 12591 var sv *types.BatchDetachObjectResponse 12592 if *v == nil { 12593 sv = &types.BatchDetachObjectResponse{} 12594 } else { 12595 sv = *v 12596 } 12597 12598 for key, value := range shape { 12599 switch key { 12600 case "detachedObjectIdentifier": 12601 if value != nil { 12602 jtv, ok := value.(string) 12603 if !ok { 12604 return fmt.Errorf("expected ObjectIdentifier to be of type string, got %T instead", value) 12605 } 12606 sv.DetachedObjectIdentifier = ptr.String(jtv) 12607 } 12608 12609 default: 12610 _, _ = key, value 12611 12612 } 12613 } 12614 *v = sv 12615 return nil 12616} 12617 12618func awsRestjson1_deserializeDocumentBatchDetachPolicyResponse(v **types.BatchDetachPolicyResponse, value interface{}) error { 12619 if v == nil { 12620 return fmt.Errorf("unexpected nil of type %T", v) 12621 } 12622 if value == nil { 12623 return nil 12624 } 12625 12626 shape, ok := value.(map[string]interface{}) 12627 if !ok { 12628 return fmt.Errorf("unexpected JSON type %v", value) 12629 } 12630 12631 var sv *types.BatchDetachPolicyResponse 12632 if *v == nil { 12633 sv = &types.BatchDetachPolicyResponse{} 12634 } else { 12635 sv = *v 12636 } 12637 12638 for key, value := range shape { 12639 switch key { 12640 default: 12641 _, _ = key, value 12642 12643 } 12644 } 12645 *v = sv 12646 return nil 12647} 12648 12649func awsRestjson1_deserializeDocumentBatchDetachTypedLinkResponse(v **types.BatchDetachTypedLinkResponse, value interface{}) error { 12650 if v == nil { 12651 return fmt.Errorf("unexpected nil of type %T", v) 12652 } 12653 if value == nil { 12654 return nil 12655 } 12656 12657 shape, ok := value.(map[string]interface{}) 12658 if !ok { 12659 return fmt.Errorf("unexpected JSON type %v", value) 12660 } 12661 12662 var sv *types.BatchDetachTypedLinkResponse 12663 if *v == nil { 12664 sv = &types.BatchDetachTypedLinkResponse{} 12665 } else { 12666 sv = *v 12667 } 12668 12669 for key, value := range shape { 12670 switch key { 12671 default: 12672 _, _ = key, value 12673 12674 } 12675 } 12676 *v = sv 12677 return nil 12678} 12679 12680func awsRestjson1_deserializeDocumentBatchGetLinkAttributesResponse(v **types.BatchGetLinkAttributesResponse, value interface{}) error { 12681 if v == nil { 12682 return fmt.Errorf("unexpected nil of type %T", v) 12683 } 12684 if value == nil { 12685 return nil 12686 } 12687 12688 shape, ok := value.(map[string]interface{}) 12689 if !ok { 12690 return fmt.Errorf("unexpected JSON type %v", value) 12691 } 12692 12693 var sv *types.BatchGetLinkAttributesResponse 12694 if *v == nil { 12695 sv = &types.BatchGetLinkAttributesResponse{} 12696 } else { 12697 sv = *v 12698 } 12699 12700 for key, value := range shape { 12701 switch key { 12702 case "Attributes": 12703 if err := awsRestjson1_deserializeDocumentAttributeKeyAndValueList(&sv.Attributes, value); err != nil { 12704 return err 12705 } 12706 12707 default: 12708 _, _ = key, value 12709 12710 } 12711 } 12712 *v = sv 12713 return nil 12714} 12715 12716func awsRestjson1_deserializeDocumentBatchGetObjectAttributesResponse(v **types.BatchGetObjectAttributesResponse, value interface{}) error { 12717 if v == nil { 12718 return fmt.Errorf("unexpected nil of type %T", v) 12719 } 12720 if value == nil { 12721 return nil 12722 } 12723 12724 shape, ok := value.(map[string]interface{}) 12725 if !ok { 12726 return fmt.Errorf("unexpected JSON type %v", value) 12727 } 12728 12729 var sv *types.BatchGetObjectAttributesResponse 12730 if *v == nil { 12731 sv = &types.BatchGetObjectAttributesResponse{} 12732 } else { 12733 sv = *v 12734 } 12735 12736 for key, value := range shape { 12737 switch key { 12738 case "Attributes": 12739 if err := awsRestjson1_deserializeDocumentAttributeKeyAndValueList(&sv.Attributes, value); err != nil { 12740 return err 12741 } 12742 12743 default: 12744 _, _ = key, value 12745 12746 } 12747 } 12748 *v = sv 12749 return nil 12750} 12751 12752func awsRestjson1_deserializeDocumentBatchGetObjectInformationResponse(v **types.BatchGetObjectInformationResponse, value interface{}) error { 12753 if v == nil { 12754 return fmt.Errorf("unexpected nil of type %T", v) 12755 } 12756 if value == nil { 12757 return nil 12758 } 12759 12760 shape, ok := value.(map[string]interface{}) 12761 if !ok { 12762 return fmt.Errorf("unexpected JSON type %v", value) 12763 } 12764 12765 var sv *types.BatchGetObjectInformationResponse 12766 if *v == nil { 12767 sv = &types.BatchGetObjectInformationResponse{} 12768 } else { 12769 sv = *v 12770 } 12771 12772 for key, value := range shape { 12773 switch key { 12774 case "ObjectIdentifier": 12775 if value != nil { 12776 jtv, ok := value.(string) 12777 if !ok { 12778 return fmt.Errorf("expected ObjectIdentifier to be of type string, got %T instead", value) 12779 } 12780 sv.ObjectIdentifier = ptr.String(jtv) 12781 } 12782 12783 case "SchemaFacets": 12784 if err := awsRestjson1_deserializeDocumentSchemaFacetList(&sv.SchemaFacets, value); err != nil { 12785 return err 12786 } 12787 12788 default: 12789 _, _ = key, value 12790 12791 } 12792 } 12793 *v = sv 12794 return nil 12795} 12796 12797func awsRestjson1_deserializeDocumentBatchListAttachedIndicesResponse(v **types.BatchListAttachedIndicesResponse, value interface{}) error { 12798 if v == nil { 12799 return fmt.Errorf("unexpected nil of type %T", v) 12800 } 12801 if value == nil { 12802 return nil 12803 } 12804 12805 shape, ok := value.(map[string]interface{}) 12806 if !ok { 12807 return fmt.Errorf("unexpected JSON type %v", value) 12808 } 12809 12810 var sv *types.BatchListAttachedIndicesResponse 12811 if *v == nil { 12812 sv = &types.BatchListAttachedIndicesResponse{} 12813 } else { 12814 sv = *v 12815 } 12816 12817 for key, value := range shape { 12818 switch key { 12819 case "IndexAttachments": 12820 if err := awsRestjson1_deserializeDocumentIndexAttachmentList(&sv.IndexAttachments, value); err != nil { 12821 return err 12822 } 12823 12824 case "NextToken": 12825 if value != nil { 12826 jtv, ok := value.(string) 12827 if !ok { 12828 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 12829 } 12830 sv.NextToken = ptr.String(jtv) 12831 } 12832 12833 default: 12834 _, _ = key, value 12835 12836 } 12837 } 12838 *v = sv 12839 return nil 12840} 12841 12842func awsRestjson1_deserializeDocumentBatchListIncomingTypedLinksResponse(v **types.BatchListIncomingTypedLinksResponse, value interface{}) error { 12843 if v == nil { 12844 return fmt.Errorf("unexpected nil of type %T", v) 12845 } 12846 if value == nil { 12847 return nil 12848 } 12849 12850 shape, ok := value.(map[string]interface{}) 12851 if !ok { 12852 return fmt.Errorf("unexpected JSON type %v", value) 12853 } 12854 12855 var sv *types.BatchListIncomingTypedLinksResponse 12856 if *v == nil { 12857 sv = &types.BatchListIncomingTypedLinksResponse{} 12858 } else { 12859 sv = *v 12860 } 12861 12862 for key, value := range shape { 12863 switch key { 12864 case "LinkSpecifiers": 12865 if err := awsRestjson1_deserializeDocumentTypedLinkSpecifierList(&sv.LinkSpecifiers, value); err != nil { 12866 return err 12867 } 12868 12869 case "NextToken": 12870 if value != nil { 12871 jtv, ok := value.(string) 12872 if !ok { 12873 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 12874 } 12875 sv.NextToken = ptr.String(jtv) 12876 } 12877 12878 default: 12879 _, _ = key, value 12880 12881 } 12882 } 12883 *v = sv 12884 return nil 12885} 12886 12887func awsRestjson1_deserializeDocumentBatchListIndexResponse(v **types.BatchListIndexResponse, value interface{}) error { 12888 if v == nil { 12889 return fmt.Errorf("unexpected nil of type %T", v) 12890 } 12891 if value == nil { 12892 return nil 12893 } 12894 12895 shape, ok := value.(map[string]interface{}) 12896 if !ok { 12897 return fmt.Errorf("unexpected JSON type %v", value) 12898 } 12899 12900 var sv *types.BatchListIndexResponse 12901 if *v == nil { 12902 sv = &types.BatchListIndexResponse{} 12903 } else { 12904 sv = *v 12905 } 12906 12907 for key, value := range shape { 12908 switch key { 12909 case "IndexAttachments": 12910 if err := awsRestjson1_deserializeDocumentIndexAttachmentList(&sv.IndexAttachments, value); err != nil { 12911 return err 12912 } 12913 12914 case "NextToken": 12915 if value != nil { 12916 jtv, ok := value.(string) 12917 if !ok { 12918 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 12919 } 12920 sv.NextToken = ptr.String(jtv) 12921 } 12922 12923 default: 12924 _, _ = key, value 12925 12926 } 12927 } 12928 *v = sv 12929 return nil 12930} 12931 12932func awsRestjson1_deserializeDocumentBatchListObjectAttributesResponse(v **types.BatchListObjectAttributesResponse, value interface{}) error { 12933 if v == nil { 12934 return fmt.Errorf("unexpected nil of type %T", v) 12935 } 12936 if value == nil { 12937 return nil 12938 } 12939 12940 shape, ok := value.(map[string]interface{}) 12941 if !ok { 12942 return fmt.Errorf("unexpected JSON type %v", value) 12943 } 12944 12945 var sv *types.BatchListObjectAttributesResponse 12946 if *v == nil { 12947 sv = &types.BatchListObjectAttributesResponse{} 12948 } else { 12949 sv = *v 12950 } 12951 12952 for key, value := range shape { 12953 switch key { 12954 case "Attributes": 12955 if err := awsRestjson1_deserializeDocumentAttributeKeyAndValueList(&sv.Attributes, value); err != nil { 12956 return err 12957 } 12958 12959 case "NextToken": 12960 if value != nil { 12961 jtv, ok := value.(string) 12962 if !ok { 12963 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 12964 } 12965 sv.NextToken = ptr.String(jtv) 12966 } 12967 12968 default: 12969 _, _ = key, value 12970 12971 } 12972 } 12973 *v = sv 12974 return nil 12975} 12976 12977func awsRestjson1_deserializeDocumentBatchListObjectChildrenResponse(v **types.BatchListObjectChildrenResponse, value interface{}) error { 12978 if v == nil { 12979 return fmt.Errorf("unexpected nil of type %T", v) 12980 } 12981 if value == nil { 12982 return nil 12983 } 12984 12985 shape, ok := value.(map[string]interface{}) 12986 if !ok { 12987 return fmt.Errorf("unexpected JSON type %v", value) 12988 } 12989 12990 var sv *types.BatchListObjectChildrenResponse 12991 if *v == nil { 12992 sv = &types.BatchListObjectChildrenResponse{} 12993 } else { 12994 sv = *v 12995 } 12996 12997 for key, value := range shape { 12998 switch key { 12999 case "Children": 13000 if err := awsRestjson1_deserializeDocumentLinkNameToObjectIdentifierMap(&sv.Children, value); err != nil { 13001 return err 13002 } 13003 13004 case "NextToken": 13005 if value != nil { 13006 jtv, ok := value.(string) 13007 if !ok { 13008 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 13009 } 13010 sv.NextToken = ptr.String(jtv) 13011 } 13012 13013 default: 13014 _, _ = key, value 13015 13016 } 13017 } 13018 *v = sv 13019 return nil 13020} 13021 13022func awsRestjson1_deserializeDocumentBatchListObjectParentPathsResponse(v **types.BatchListObjectParentPathsResponse, value interface{}) error { 13023 if v == nil { 13024 return fmt.Errorf("unexpected nil of type %T", v) 13025 } 13026 if value == nil { 13027 return nil 13028 } 13029 13030 shape, ok := value.(map[string]interface{}) 13031 if !ok { 13032 return fmt.Errorf("unexpected JSON type %v", value) 13033 } 13034 13035 var sv *types.BatchListObjectParentPathsResponse 13036 if *v == nil { 13037 sv = &types.BatchListObjectParentPathsResponse{} 13038 } else { 13039 sv = *v 13040 } 13041 13042 for key, value := range shape { 13043 switch key { 13044 case "NextToken": 13045 if value != nil { 13046 jtv, ok := value.(string) 13047 if !ok { 13048 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 13049 } 13050 sv.NextToken = ptr.String(jtv) 13051 } 13052 13053 case "PathToObjectIdentifiersList": 13054 if err := awsRestjson1_deserializeDocumentPathToObjectIdentifiersList(&sv.PathToObjectIdentifiersList, value); err != nil { 13055 return err 13056 } 13057 13058 default: 13059 _, _ = key, value 13060 13061 } 13062 } 13063 *v = sv 13064 return nil 13065} 13066 13067func awsRestjson1_deserializeDocumentBatchListObjectParentsResponse(v **types.BatchListObjectParentsResponse, value interface{}) error { 13068 if v == nil { 13069 return fmt.Errorf("unexpected nil of type %T", v) 13070 } 13071 if value == nil { 13072 return nil 13073 } 13074 13075 shape, ok := value.(map[string]interface{}) 13076 if !ok { 13077 return fmt.Errorf("unexpected JSON type %v", value) 13078 } 13079 13080 var sv *types.BatchListObjectParentsResponse 13081 if *v == nil { 13082 sv = &types.BatchListObjectParentsResponse{} 13083 } else { 13084 sv = *v 13085 } 13086 13087 for key, value := range shape { 13088 switch key { 13089 case "NextToken": 13090 if value != nil { 13091 jtv, ok := value.(string) 13092 if !ok { 13093 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 13094 } 13095 sv.NextToken = ptr.String(jtv) 13096 } 13097 13098 case "ParentLinks": 13099 if err := awsRestjson1_deserializeDocumentObjectIdentifierAndLinkNameList(&sv.ParentLinks, value); err != nil { 13100 return err 13101 } 13102 13103 default: 13104 _, _ = key, value 13105 13106 } 13107 } 13108 *v = sv 13109 return nil 13110} 13111 13112func awsRestjson1_deserializeDocumentBatchListObjectPoliciesResponse(v **types.BatchListObjectPoliciesResponse, value interface{}) error { 13113 if v == nil { 13114 return fmt.Errorf("unexpected nil of type %T", v) 13115 } 13116 if value == nil { 13117 return nil 13118 } 13119 13120 shape, ok := value.(map[string]interface{}) 13121 if !ok { 13122 return fmt.Errorf("unexpected JSON type %v", value) 13123 } 13124 13125 var sv *types.BatchListObjectPoliciesResponse 13126 if *v == nil { 13127 sv = &types.BatchListObjectPoliciesResponse{} 13128 } else { 13129 sv = *v 13130 } 13131 13132 for key, value := range shape { 13133 switch key { 13134 case "AttachedPolicyIds": 13135 if err := awsRestjson1_deserializeDocumentObjectIdentifierList(&sv.AttachedPolicyIds, value); err != nil { 13136 return err 13137 } 13138 13139 case "NextToken": 13140 if value != nil { 13141 jtv, ok := value.(string) 13142 if !ok { 13143 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 13144 } 13145 sv.NextToken = ptr.String(jtv) 13146 } 13147 13148 default: 13149 _, _ = key, value 13150 13151 } 13152 } 13153 *v = sv 13154 return nil 13155} 13156 13157func awsRestjson1_deserializeDocumentBatchListOutgoingTypedLinksResponse(v **types.BatchListOutgoingTypedLinksResponse, value interface{}) error { 13158 if v == nil { 13159 return fmt.Errorf("unexpected nil of type %T", v) 13160 } 13161 if value == nil { 13162 return nil 13163 } 13164 13165 shape, ok := value.(map[string]interface{}) 13166 if !ok { 13167 return fmt.Errorf("unexpected JSON type %v", value) 13168 } 13169 13170 var sv *types.BatchListOutgoingTypedLinksResponse 13171 if *v == nil { 13172 sv = &types.BatchListOutgoingTypedLinksResponse{} 13173 } else { 13174 sv = *v 13175 } 13176 13177 for key, value := range shape { 13178 switch key { 13179 case "NextToken": 13180 if value != nil { 13181 jtv, ok := value.(string) 13182 if !ok { 13183 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 13184 } 13185 sv.NextToken = ptr.String(jtv) 13186 } 13187 13188 case "TypedLinkSpecifiers": 13189 if err := awsRestjson1_deserializeDocumentTypedLinkSpecifierList(&sv.TypedLinkSpecifiers, value); err != nil { 13190 return err 13191 } 13192 13193 default: 13194 _, _ = key, value 13195 13196 } 13197 } 13198 *v = sv 13199 return nil 13200} 13201 13202func awsRestjson1_deserializeDocumentBatchListPolicyAttachmentsResponse(v **types.BatchListPolicyAttachmentsResponse, value interface{}) error { 13203 if v == nil { 13204 return fmt.Errorf("unexpected nil of type %T", v) 13205 } 13206 if value == nil { 13207 return nil 13208 } 13209 13210 shape, ok := value.(map[string]interface{}) 13211 if !ok { 13212 return fmt.Errorf("unexpected JSON type %v", value) 13213 } 13214 13215 var sv *types.BatchListPolicyAttachmentsResponse 13216 if *v == nil { 13217 sv = &types.BatchListPolicyAttachmentsResponse{} 13218 } else { 13219 sv = *v 13220 } 13221 13222 for key, value := range shape { 13223 switch key { 13224 case "NextToken": 13225 if value != nil { 13226 jtv, ok := value.(string) 13227 if !ok { 13228 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 13229 } 13230 sv.NextToken = ptr.String(jtv) 13231 } 13232 13233 case "ObjectIdentifiers": 13234 if err := awsRestjson1_deserializeDocumentObjectIdentifierList(&sv.ObjectIdentifiers, value); err != nil { 13235 return err 13236 } 13237 13238 default: 13239 _, _ = key, value 13240 13241 } 13242 } 13243 *v = sv 13244 return nil 13245} 13246 13247func awsRestjson1_deserializeDocumentBatchLookupPolicyResponse(v **types.BatchLookupPolicyResponse, value interface{}) error { 13248 if v == nil { 13249 return fmt.Errorf("unexpected nil of type %T", v) 13250 } 13251 if value == nil { 13252 return nil 13253 } 13254 13255 shape, ok := value.(map[string]interface{}) 13256 if !ok { 13257 return fmt.Errorf("unexpected JSON type %v", value) 13258 } 13259 13260 var sv *types.BatchLookupPolicyResponse 13261 if *v == nil { 13262 sv = &types.BatchLookupPolicyResponse{} 13263 } else { 13264 sv = *v 13265 } 13266 13267 for key, value := range shape { 13268 switch key { 13269 case "NextToken": 13270 if value != nil { 13271 jtv, ok := value.(string) 13272 if !ok { 13273 return fmt.Errorf("expected NextToken to be of type string, got %T instead", value) 13274 } 13275 sv.NextToken = ptr.String(jtv) 13276 } 13277 13278 case "PolicyToPathList": 13279 if err := awsRestjson1_deserializeDocumentPolicyToPathList(&sv.PolicyToPathList, value); err != nil { 13280 return err 13281 } 13282 13283 default: 13284 _, _ = key, value 13285 13286 } 13287 } 13288 *v = sv 13289 return nil 13290} 13291 13292func awsRestjson1_deserializeDocumentBatchReadException(v **types.BatchReadException, value interface{}) error { 13293 if v == nil { 13294 return fmt.Errorf("unexpected nil of type %T", v) 13295 } 13296 if value == nil { 13297 return nil 13298 } 13299 13300 shape, ok := value.(map[string]interface{}) 13301 if !ok { 13302 return fmt.Errorf("unexpected JSON type %v", value) 13303 } 13304 13305 var sv *types.BatchReadException 13306 if *v == nil { 13307 sv = &types.BatchReadException{} 13308 } else { 13309 sv = *v 13310 } 13311 13312 for key, value := range shape { 13313 switch key { 13314 case "Message": 13315 if value != nil { 13316 jtv, ok := value.(string) 13317 if !ok { 13318 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 13319 } 13320 sv.Message = ptr.String(jtv) 13321 } 13322 13323 case "Type": 13324 if value != nil { 13325 jtv, ok := value.(string) 13326 if !ok { 13327 return fmt.Errorf("expected BatchReadExceptionType to be of type string, got %T instead", value) 13328 } 13329 sv.Type = types.BatchReadExceptionType(jtv) 13330 } 13331 13332 default: 13333 _, _ = key, value 13334 13335 } 13336 } 13337 *v = sv 13338 return nil 13339} 13340 13341func awsRestjson1_deserializeDocumentBatchReadOperationResponse(v **types.BatchReadOperationResponse, value interface{}) error { 13342 if v == nil { 13343 return fmt.Errorf("unexpected nil of type %T", v) 13344 } 13345 if value == nil { 13346 return nil 13347 } 13348 13349 shape, ok := value.(map[string]interface{}) 13350 if !ok { 13351 return fmt.Errorf("unexpected JSON type %v", value) 13352 } 13353 13354 var sv *types.BatchReadOperationResponse 13355 if *v == nil { 13356 sv = &types.BatchReadOperationResponse{} 13357 } else { 13358 sv = *v 13359 } 13360 13361 for key, value := range shape { 13362 switch key { 13363 case "ExceptionResponse": 13364 if err := awsRestjson1_deserializeDocumentBatchReadException(&sv.ExceptionResponse, value); err != nil { 13365 return err 13366 } 13367 13368 case "SuccessfulResponse": 13369 if err := awsRestjson1_deserializeDocumentBatchReadSuccessfulResponse(&sv.SuccessfulResponse, value); err != nil { 13370 return err 13371 } 13372 13373 default: 13374 _, _ = key, value 13375 13376 } 13377 } 13378 *v = sv 13379 return nil 13380} 13381 13382func awsRestjson1_deserializeDocumentBatchReadOperationResponseList(v *[]types.BatchReadOperationResponse, value interface{}) error { 13383 if v == nil { 13384 return fmt.Errorf("unexpected nil of type %T", v) 13385 } 13386 if value == nil { 13387 return nil 13388 } 13389 13390 shape, ok := value.([]interface{}) 13391 if !ok { 13392 return fmt.Errorf("unexpected JSON type %v", value) 13393 } 13394 13395 var cv []types.BatchReadOperationResponse 13396 if *v == nil { 13397 cv = []types.BatchReadOperationResponse{} 13398 } else { 13399 cv = *v 13400 } 13401 13402 for _, value := range shape { 13403 var col types.BatchReadOperationResponse 13404 destAddr := &col 13405 if err := awsRestjson1_deserializeDocumentBatchReadOperationResponse(&destAddr, value); err != nil { 13406 return err 13407 } 13408 col = *destAddr 13409 cv = append(cv, col) 13410 13411 } 13412 *v = cv 13413 return nil 13414} 13415 13416func awsRestjson1_deserializeDocumentBatchReadSuccessfulResponse(v **types.BatchReadSuccessfulResponse, value interface{}) error { 13417 if v == nil { 13418 return fmt.Errorf("unexpected nil of type %T", v) 13419 } 13420 if value == nil { 13421 return nil 13422 } 13423 13424 shape, ok := value.(map[string]interface{}) 13425 if !ok { 13426 return fmt.Errorf("unexpected JSON type %v", value) 13427 } 13428 13429 var sv *types.BatchReadSuccessfulResponse 13430 if *v == nil { 13431 sv = &types.BatchReadSuccessfulResponse{} 13432 } else { 13433 sv = *v 13434 } 13435 13436 for key, value := range shape { 13437 switch key { 13438 case "GetLinkAttributes": 13439 if err := awsRestjson1_deserializeDocumentBatchGetLinkAttributesResponse(&sv.GetLinkAttributes, value); err != nil { 13440 return err 13441 } 13442 13443 case "GetObjectAttributes": 13444 if err := awsRestjson1_deserializeDocumentBatchGetObjectAttributesResponse(&sv.GetObjectAttributes, value); err != nil { 13445 return err 13446 } 13447 13448 case "GetObjectInformation": 13449 if err := awsRestjson1_deserializeDocumentBatchGetObjectInformationResponse(&sv.GetObjectInformation, value); err != nil { 13450 return err 13451 } 13452 13453 case "ListAttachedIndices": 13454 if err := awsRestjson1_deserializeDocumentBatchListAttachedIndicesResponse(&sv.ListAttachedIndices, value); err != nil { 13455 return err 13456 } 13457 13458 case "ListIncomingTypedLinks": 13459 if err := awsRestjson1_deserializeDocumentBatchListIncomingTypedLinksResponse(&sv.ListIncomingTypedLinks, value); err != nil { 13460 return err 13461 } 13462 13463 case "ListIndex": 13464 if err := awsRestjson1_deserializeDocumentBatchListIndexResponse(&sv.ListIndex, value); err != nil { 13465 return err 13466 } 13467 13468 case "ListObjectAttributes": 13469 if err := awsRestjson1_deserializeDocumentBatchListObjectAttributesResponse(&sv.ListObjectAttributes, value); err != nil { 13470 return err 13471 } 13472 13473 case "ListObjectChildren": 13474 if err := awsRestjson1_deserializeDocumentBatchListObjectChildrenResponse(&sv.ListObjectChildren, value); err != nil { 13475 return err 13476 } 13477 13478 case "ListObjectParentPaths": 13479 if err := awsRestjson1_deserializeDocumentBatchListObjectParentPathsResponse(&sv.ListObjectParentPaths, value); err != nil { 13480 return err 13481 } 13482 13483 case "ListObjectParents": 13484 if err := awsRestjson1_deserializeDocumentBatchListObjectParentsResponse(&sv.ListObjectParents, value); err != nil { 13485 return err 13486 } 13487 13488 case "ListObjectPolicies": 13489 if err := awsRestjson1_deserializeDocumentBatchListObjectPoliciesResponse(&sv.ListObjectPolicies, value); err != nil { 13490 return err 13491 } 13492 13493 case "ListOutgoingTypedLinks": 13494 if err := awsRestjson1_deserializeDocumentBatchListOutgoingTypedLinksResponse(&sv.ListOutgoingTypedLinks, value); err != nil { 13495 return err 13496 } 13497 13498 case "ListPolicyAttachments": 13499 if err := awsRestjson1_deserializeDocumentBatchListPolicyAttachmentsResponse(&sv.ListPolicyAttachments, value); err != nil { 13500 return err 13501 } 13502 13503 case "LookupPolicy": 13504 if err := awsRestjson1_deserializeDocumentBatchLookupPolicyResponse(&sv.LookupPolicy, value); err != nil { 13505 return err 13506 } 13507 13508 default: 13509 _, _ = key, value 13510 13511 } 13512 } 13513 *v = sv 13514 return nil 13515} 13516 13517func awsRestjson1_deserializeDocumentBatchRemoveFacetFromObjectResponse(v **types.BatchRemoveFacetFromObjectResponse, value interface{}) error { 13518 if v == nil { 13519 return fmt.Errorf("unexpected nil of type %T", v) 13520 } 13521 if value == nil { 13522 return nil 13523 } 13524 13525 shape, ok := value.(map[string]interface{}) 13526 if !ok { 13527 return fmt.Errorf("unexpected JSON type %v", value) 13528 } 13529 13530 var sv *types.BatchRemoveFacetFromObjectResponse 13531 if *v == nil { 13532 sv = &types.BatchRemoveFacetFromObjectResponse{} 13533 } else { 13534 sv = *v 13535 } 13536 13537 for key, value := range shape { 13538 switch key { 13539 default: 13540 _, _ = key, value 13541 13542 } 13543 } 13544 *v = sv 13545 return nil 13546} 13547 13548func awsRestjson1_deserializeDocumentBatchUpdateLinkAttributesResponse(v **types.BatchUpdateLinkAttributesResponse, value interface{}) error { 13549 if v == nil { 13550 return fmt.Errorf("unexpected nil of type %T", v) 13551 } 13552 if value == nil { 13553 return nil 13554 } 13555 13556 shape, ok := value.(map[string]interface{}) 13557 if !ok { 13558 return fmt.Errorf("unexpected JSON type %v", value) 13559 } 13560 13561 var sv *types.BatchUpdateLinkAttributesResponse 13562 if *v == nil { 13563 sv = &types.BatchUpdateLinkAttributesResponse{} 13564 } else { 13565 sv = *v 13566 } 13567 13568 for key, value := range shape { 13569 switch key { 13570 default: 13571 _, _ = key, value 13572 13573 } 13574 } 13575 *v = sv 13576 return nil 13577} 13578 13579func awsRestjson1_deserializeDocumentBatchUpdateObjectAttributesResponse(v **types.BatchUpdateObjectAttributesResponse, value interface{}) error { 13580 if v == nil { 13581 return fmt.Errorf("unexpected nil of type %T", v) 13582 } 13583 if value == nil { 13584 return nil 13585 } 13586 13587 shape, ok := value.(map[string]interface{}) 13588 if !ok { 13589 return fmt.Errorf("unexpected JSON type %v", value) 13590 } 13591 13592 var sv *types.BatchUpdateObjectAttributesResponse 13593 if *v == nil { 13594 sv = &types.BatchUpdateObjectAttributesResponse{} 13595 } else { 13596 sv = *v 13597 } 13598 13599 for key, value := range shape { 13600 switch key { 13601 case "ObjectIdentifier": 13602 if value != nil { 13603 jtv, ok := value.(string) 13604 if !ok { 13605 return fmt.Errorf("expected ObjectIdentifier to be of type string, got %T instead", value) 13606 } 13607 sv.ObjectIdentifier = ptr.String(jtv) 13608 } 13609 13610 default: 13611 _, _ = key, value 13612 13613 } 13614 } 13615 *v = sv 13616 return nil 13617} 13618 13619func awsRestjson1_deserializeDocumentBatchWriteException(v **types.BatchWriteException, value interface{}) error { 13620 if v == nil { 13621 return fmt.Errorf("unexpected nil of type %T", v) 13622 } 13623 if value == nil { 13624 return nil 13625 } 13626 13627 shape, ok := value.(map[string]interface{}) 13628 if !ok { 13629 return fmt.Errorf("unexpected JSON type %v", value) 13630 } 13631 13632 var sv *types.BatchWriteException 13633 if *v == nil { 13634 sv = &types.BatchWriteException{} 13635 } else { 13636 sv = *v 13637 } 13638 13639 for key, value := range shape { 13640 switch key { 13641 case "Index": 13642 if value != nil { 13643 jtv, ok := value.(json.Number) 13644 if !ok { 13645 return fmt.Errorf("expected BatchOperationIndex to be json.Number, got %T instead", value) 13646 } 13647 i64, err := jtv.Int64() 13648 if err != nil { 13649 return err 13650 } 13651 sv.Index = int32(i64) 13652 } 13653 13654 case "Message": 13655 if value != nil { 13656 jtv, ok := value.(string) 13657 if !ok { 13658 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 13659 } 13660 sv.Message = ptr.String(jtv) 13661 } 13662 13663 case "Type": 13664 if value != nil { 13665 jtv, ok := value.(string) 13666 if !ok { 13667 return fmt.Errorf("expected BatchWriteExceptionType to be of type string, got %T instead", value) 13668 } 13669 sv.Type = types.BatchWriteExceptionType(jtv) 13670 } 13671 13672 default: 13673 _, _ = key, value 13674 13675 } 13676 } 13677 *v = sv 13678 return nil 13679} 13680 13681func awsRestjson1_deserializeDocumentBatchWriteOperationResponse(v **types.BatchWriteOperationResponse, value interface{}) error { 13682 if v == nil { 13683 return fmt.Errorf("unexpected nil of type %T", v) 13684 } 13685 if value == nil { 13686 return nil 13687 } 13688 13689 shape, ok := value.(map[string]interface{}) 13690 if !ok { 13691 return fmt.Errorf("unexpected JSON type %v", value) 13692 } 13693 13694 var sv *types.BatchWriteOperationResponse 13695 if *v == nil { 13696 sv = &types.BatchWriteOperationResponse{} 13697 } else { 13698 sv = *v 13699 } 13700 13701 for key, value := range shape { 13702 switch key { 13703 case "AddFacetToObject": 13704 if err := awsRestjson1_deserializeDocumentBatchAddFacetToObjectResponse(&sv.AddFacetToObject, value); err != nil { 13705 return err 13706 } 13707 13708 case "AttachObject": 13709 if err := awsRestjson1_deserializeDocumentBatchAttachObjectResponse(&sv.AttachObject, value); err != nil { 13710 return err 13711 } 13712 13713 case "AttachPolicy": 13714 if err := awsRestjson1_deserializeDocumentBatchAttachPolicyResponse(&sv.AttachPolicy, value); err != nil { 13715 return err 13716 } 13717 13718 case "AttachToIndex": 13719 if err := awsRestjson1_deserializeDocumentBatchAttachToIndexResponse(&sv.AttachToIndex, value); err != nil { 13720 return err 13721 } 13722 13723 case "AttachTypedLink": 13724 if err := awsRestjson1_deserializeDocumentBatchAttachTypedLinkResponse(&sv.AttachTypedLink, value); err != nil { 13725 return err 13726 } 13727 13728 case "CreateIndex": 13729 if err := awsRestjson1_deserializeDocumentBatchCreateIndexResponse(&sv.CreateIndex, value); err != nil { 13730 return err 13731 } 13732 13733 case "CreateObject": 13734 if err := awsRestjson1_deserializeDocumentBatchCreateObjectResponse(&sv.CreateObject, value); err != nil { 13735 return err 13736 } 13737 13738 case "DeleteObject": 13739 if err := awsRestjson1_deserializeDocumentBatchDeleteObjectResponse(&sv.DeleteObject, value); err != nil { 13740 return err 13741 } 13742 13743 case "DetachFromIndex": 13744 if err := awsRestjson1_deserializeDocumentBatchDetachFromIndexResponse(&sv.DetachFromIndex, value); err != nil { 13745 return err 13746 } 13747 13748 case "DetachObject": 13749 if err := awsRestjson1_deserializeDocumentBatchDetachObjectResponse(&sv.DetachObject, value); err != nil { 13750 return err 13751 } 13752 13753 case "DetachPolicy": 13754 if err := awsRestjson1_deserializeDocumentBatchDetachPolicyResponse(&sv.DetachPolicy, value); err != nil { 13755 return err 13756 } 13757 13758 case "DetachTypedLink": 13759 if err := awsRestjson1_deserializeDocumentBatchDetachTypedLinkResponse(&sv.DetachTypedLink, value); err != nil { 13760 return err 13761 } 13762 13763 case "RemoveFacetFromObject": 13764 if err := awsRestjson1_deserializeDocumentBatchRemoveFacetFromObjectResponse(&sv.RemoveFacetFromObject, value); err != nil { 13765 return err 13766 } 13767 13768 case "UpdateLinkAttributes": 13769 if err := awsRestjson1_deserializeDocumentBatchUpdateLinkAttributesResponse(&sv.UpdateLinkAttributes, value); err != nil { 13770 return err 13771 } 13772 13773 case "UpdateObjectAttributes": 13774 if err := awsRestjson1_deserializeDocumentBatchUpdateObjectAttributesResponse(&sv.UpdateObjectAttributes, value); err != nil { 13775 return err 13776 } 13777 13778 default: 13779 _, _ = key, value 13780 13781 } 13782 } 13783 *v = sv 13784 return nil 13785} 13786 13787func awsRestjson1_deserializeDocumentBatchWriteOperationResponseList(v *[]types.BatchWriteOperationResponse, value interface{}) error { 13788 if v == nil { 13789 return fmt.Errorf("unexpected nil of type %T", v) 13790 } 13791 if value == nil { 13792 return nil 13793 } 13794 13795 shape, ok := value.([]interface{}) 13796 if !ok { 13797 return fmt.Errorf("unexpected JSON type %v", value) 13798 } 13799 13800 var cv []types.BatchWriteOperationResponse 13801 if *v == nil { 13802 cv = []types.BatchWriteOperationResponse{} 13803 } else { 13804 cv = *v 13805 } 13806 13807 for _, value := range shape { 13808 var col types.BatchWriteOperationResponse 13809 destAddr := &col 13810 if err := awsRestjson1_deserializeDocumentBatchWriteOperationResponse(&destAddr, value); err != nil { 13811 return err 13812 } 13813 col = *destAddr 13814 cv = append(cv, col) 13815 13816 } 13817 *v = cv 13818 return nil 13819} 13820 13821func awsRestjson1_deserializeDocumentCannotListParentOfRootException(v **types.CannotListParentOfRootException, value interface{}) error { 13822 if v == nil { 13823 return fmt.Errorf("unexpected nil of type %T", v) 13824 } 13825 if value == nil { 13826 return nil 13827 } 13828 13829 shape, ok := value.(map[string]interface{}) 13830 if !ok { 13831 return fmt.Errorf("unexpected JSON type %v", value) 13832 } 13833 13834 var sv *types.CannotListParentOfRootException 13835 if *v == nil { 13836 sv = &types.CannotListParentOfRootException{} 13837 } else { 13838 sv = *v 13839 } 13840 13841 for key, value := range shape { 13842 switch key { 13843 case "Message": 13844 if value != nil { 13845 jtv, ok := value.(string) 13846 if !ok { 13847 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 13848 } 13849 sv.Message = ptr.String(jtv) 13850 } 13851 13852 default: 13853 _, _ = key, value 13854 13855 } 13856 } 13857 *v = sv 13858 return nil 13859} 13860 13861func awsRestjson1_deserializeDocumentDirectory(v **types.Directory, value interface{}) error { 13862 if v == nil { 13863 return fmt.Errorf("unexpected nil of type %T", v) 13864 } 13865 if value == nil { 13866 return nil 13867 } 13868 13869 shape, ok := value.(map[string]interface{}) 13870 if !ok { 13871 return fmt.Errorf("unexpected JSON type %v", value) 13872 } 13873 13874 var sv *types.Directory 13875 if *v == nil { 13876 sv = &types.Directory{} 13877 } else { 13878 sv = *v 13879 } 13880 13881 for key, value := range shape { 13882 switch key { 13883 case "CreationDateTime": 13884 if value != nil { 13885 switch jtv := value.(type) { 13886 case json.Number: 13887 f64, err := jtv.Float64() 13888 if err != nil { 13889 return err 13890 } 13891 sv.CreationDateTime = ptr.Time(smithytime.ParseEpochSeconds(f64)) 13892 13893 default: 13894 return fmt.Errorf("expected Date to be a JSON Number, got %T instead", value) 13895 13896 } 13897 } 13898 13899 case "DirectoryArn": 13900 if value != nil { 13901 jtv, ok := value.(string) 13902 if !ok { 13903 return fmt.Errorf("expected DirectoryArn to be of type string, got %T instead", value) 13904 } 13905 sv.DirectoryArn = ptr.String(jtv) 13906 } 13907 13908 case "Name": 13909 if value != nil { 13910 jtv, ok := value.(string) 13911 if !ok { 13912 return fmt.Errorf("expected DirectoryName to be of type string, got %T instead", value) 13913 } 13914 sv.Name = ptr.String(jtv) 13915 } 13916 13917 case "State": 13918 if value != nil { 13919 jtv, ok := value.(string) 13920 if !ok { 13921 return fmt.Errorf("expected DirectoryState to be of type string, got %T instead", value) 13922 } 13923 sv.State = types.DirectoryState(jtv) 13924 } 13925 13926 default: 13927 _, _ = key, value 13928 13929 } 13930 } 13931 *v = sv 13932 return nil 13933} 13934 13935func awsRestjson1_deserializeDocumentDirectoryAlreadyExistsException(v **types.DirectoryAlreadyExistsException, value interface{}) error { 13936 if v == nil { 13937 return fmt.Errorf("unexpected nil of type %T", v) 13938 } 13939 if value == nil { 13940 return nil 13941 } 13942 13943 shape, ok := value.(map[string]interface{}) 13944 if !ok { 13945 return fmt.Errorf("unexpected JSON type %v", value) 13946 } 13947 13948 var sv *types.DirectoryAlreadyExistsException 13949 if *v == nil { 13950 sv = &types.DirectoryAlreadyExistsException{} 13951 } else { 13952 sv = *v 13953 } 13954 13955 for key, value := range shape { 13956 switch key { 13957 case "Message": 13958 if value != nil { 13959 jtv, ok := value.(string) 13960 if !ok { 13961 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 13962 } 13963 sv.Message = ptr.String(jtv) 13964 } 13965 13966 default: 13967 _, _ = key, value 13968 13969 } 13970 } 13971 *v = sv 13972 return nil 13973} 13974 13975func awsRestjson1_deserializeDocumentDirectoryDeletedException(v **types.DirectoryDeletedException, value interface{}) error { 13976 if v == nil { 13977 return fmt.Errorf("unexpected nil of type %T", v) 13978 } 13979 if value == nil { 13980 return nil 13981 } 13982 13983 shape, ok := value.(map[string]interface{}) 13984 if !ok { 13985 return fmt.Errorf("unexpected JSON type %v", value) 13986 } 13987 13988 var sv *types.DirectoryDeletedException 13989 if *v == nil { 13990 sv = &types.DirectoryDeletedException{} 13991 } else { 13992 sv = *v 13993 } 13994 13995 for key, value := range shape { 13996 switch key { 13997 case "Message": 13998 if value != nil { 13999 jtv, ok := value.(string) 14000 if !ok { 14001 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 14002 } 14003 sv.Message = ptr.String(jtv) 14004 } 14005 14006 default: 14007 _, _ = key, value 14008 14009 } 14010 } 14011 *v = sv 14012 return nil 14013} 14014 14015func awsRestjson1_deserializeDocumentDirectoryList(v *[]types.Directory, value interface{}) error { 14016 if v == nil { 14017 return fmt.Errorf("unexpected nil of type %T", v) 14018 } 14019 if value == nil { 14020 return nil 14021 } 14022 14023 shape, ok := value.([]interface{}) 14024 if !ok { 14025 return fmt.Errorf("unexpected JSON type %v", value) 14026 } 14027 14028 var cv []types.Directory 14029 if *v == nil { 14030 cv = []types.Directory{} 14031 } else { 14032 cv = *v 14033 } 14034 14035 for _, value := range shape { 14036 var col types.Directory 14037 destAddr := &col 14038 if err := awsRestjson1_deserializeDocumentDirectory(&destAddr, value); err != nil { 14039 return err 14040 } 14041 col = *destAddr 14042 cv = append(cv, col) 14043 14044 } 14045 *v = cv 14046 return nil 14047} 14048 14049func awsRestjson1_deserializeDocumentDirectoryNotDisabledException(v **types.DirectoryNotDisabledException, value interface{}) error { 14050 if v == nil { 14051 return fmt.Errorf("unexpected nil of type %T", v) 14052 } 14053 if value == nil { 14054 return nil 14055 } 14056 14057 shape, ok := value.(map[string]interface{}) 14058 if !ok { 14059 return fmt.Errorf("unexpected JSON type %v", value) 14060 } 14061 14062 var sv *types.DirectoryNotDisabledException 14063 if *v == nil { 14064 sv = &types.DirectoryNotDisabledException{} 14065 } else { 14066 sv = *v 14067 } 14068 14069 for key, value := range shape { 14070 switch key { 14071 case "Message": 14072 if value != nil { 14073 jtv, ok := value.(string) 14074 if !ok { 14075 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 14076 } 14077 sv.Message = ptr.String(jtv) 14078 } 14079 14080 default: 14081 _, _ = key, value 14082 14083 } 14084 } 14085 *v = sv 14086 return nil 14087} 14088 14089func awsRestjson1_deserializeDocumentDirectoryNotEnabledException(v **types.DirectoryNotEnabledException, value interface{}) error { 14090 if v == nil { 14091 return fmt.Errorf("unexpected nil of type %T", v) 14092 } 14093 if value == nil { 14094 return nil 14095 } 14096 14097 shape, ok := value.(map[string]interface{}) 14098 if !ok { 14099 return fmt.Errorf("unexpected JSON type %v", value) 14100 } 14101 14102 var sv *types.DirectoryNotEnabledException 14103 if *v == nil { 14104 sv = &types.DirectoryNotEnabledException{} 14105 } else { 14106 sv = *v 14107 } 14108 14109 for key, value := range shape { 14110 switch key { 14111 case "Message": 14112 if value != nil { 14113 jtv, ok := value.(string) 14114 if !ok { 14115 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 14116 } 14117 sv.Message = ptr.String(jtv) 14118 } 14119 14120 default: 14121 _, _ = key, value 14122 14123 } 14124 } 14125 *v = sv 14126 return nil 14127} 14128 14129func awsRestjson1_deserializeDocumentFacet(v **types.Facet, value interface{}) error { 14130 if v == nil { 14131 return fmt.Errorf("unexpected nil of type %T", v) 14132 } 14133 if value == nil { 14134 return nil 14135 } 14136 14137 shape, ok := value.(map[string]interface{}) 14138 if !ok { 14139 return fmt.Errorf("unexpected JSON type %v", value) 14140 } 14141 14142 var sv *types.Facet 14143 if *v == nil { 14144 sv = &types.Facet{} 14145 } else { 14146 sv = *v 14147 } 14148 14149 for key, value := range shape { 14150 switch key { 14151 case "FacetStyle": 14152 if value != nil { 14153 jtv, ok := value.(string) 14154 if !ok { 14155 return fmt.Errorf("expected FacetStyle to be of type string, got %T instead", value) 14156 } 14157 sv.FacetStyle = types.FacetStyle(jtv) 14158 } 14159 14160 case "Name": 14161 if value != nil { 14162 jtv, ok := value.(string) 14163 if !ok { 14164 return fmt.Errorf("expected FacetName to be of type string, got %T instead", value) 14165 } 14166 sv.Name = ptr.String(jtv) 14167 } 14168 14169 case "ObjectType": 14170 if value != nil { 14171 jtv, ok := value.(string) 14172 if !ok { 14173 return fmt.Errorf("expected ObjectType to be of type string, got %T instead", value) 14174 } 14175 sv.ObjectType = types.ObjectType(jtv) 14176 } 14177 14178 default: 14179 _, _ = key, value 14180 14181 } 14182 } 14183 *v = sv 14184 return nil 14185} 14186 14187func awsRestjson1_deserializeDocumentFacetAlreadyExistsException(v **types.FacetAlreadyExistsException, value interface{}) error { 14188 if v == nil { 14189 return fmt.Errorf("unexpected nil of type %T", v) 14190 } 14191 if value == nil { 14192 return nil 14193 } 14194 14195 shape, ok := value.(map[string]interface{}) 14196 if !ok { 14197 return fmt.Errorf("unexpected JSON type %v", value) 14198 } 14199 14200 var sv *types.FacetAlreadyExistsException 14201 if *v == nil { 14202 sv = &types.FacetAlreadyExistsException{} 14203 } else { 14204 sv = *v 14205 } 14206 14207 for key, value := range shape { 14208 switch key { 14209 case "Message": 14210 if value != nil { 14211 jtv, ok := value.(string) 14212 if !ok { 14213 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 14214 } 14215 sv.Message = ptr.String(jtv) 14216 } 14217 14218 default: 14219 _, _ = key, value 14220 14221 } 14222 } 14223 *v = sv 14224 return nil 14225} 14226 14227func awsRestjson1_deserializeDocumentFacetAttribute(v **types.FacetAttribute, value interface{}) error { 14228 if v == nil { 14229 return fmt.Errorf("unexpected nil of type %T", v) 14230 } 14231 if value == nil { 14232 return nil 14233 } 14234 14235 shape, ok := value.(map[string]interface{}) 14236 if !ok { 14237 return fmt.Errorf("unexpected JSON type %v", value) 14238 } 14239 14240 var sv *types.FacetAttribute 14241 if *v == nil { 14242 sv = &types.FacetAttribute{} 14243 } else { 14244 sv = *v 14245 } 14246 14247 for key, value := range shape { 14248 switch key { 14249 case "AttributeDefinition": 14250 if err := awsRestjson1_deserializeDocumentFacetAttributeDefinition(&sv.AttributeDefinition, value); err != nil { 14251 return err 14252 } 14253 14254 case "AttributeReference": 14255 if err := awsRestjson1_deserializeDocumentFacetAttributeReference(&sv.AttributeReference, value); err != nil { 14256 return err 14257 } 14258 14259 case "Name": 14260 if value != nil { 14261 jtv, ok := value.(string) 14262 if !ok { 14263 return fmt.Errorf("expected AttributeName to be of type string, got %T instead", value) 14264 } 14265 sv.Name = ptr.String(jtv) 14266 } 14267 14268 case "RequiredBehavior": 14269 if value != nil { 14270 jtv, ok := value.(string) 14271 if !ok { 14272 return fmt.Errorf("expected RequiredAttributeBehavior to be of type string, got %T instead", value) 14273 } 14274 sv.RequiredBehavior = types.RequiredAttributeBehavior(jtv) 14275 } 14276 14277 default: 14278 _, _ = key, value 14279 14280 } 14281 } 14282 *v = sv 14283 return nil 14284} 14285 14286func awsRestjson1_deserializeDocumentFacetAttributeDefinition(v **types.FacetAttributeDefinition, value interface{}) error { 14287 if v == nil { 14288 return fmt.Errorf("unexpected nil of type %T", v) 14289 } 14290 if value == nil { 14291 return nil 14292 } 14293 14294 shape, ok := value.(map[string]interface{}) 14295 if !ok { 14296 return fmt.Errorf("unexpected JSON type %v", value) 14297 } 14298 14299 var sv *types.FacetAttributeDefinition 14300 if *v == nil { 14301 sv = &types.FacetAttributeDefinition{} 14302 } else { 14303 sv = *v 14304 } 14305 14306 for key, value := range shape { 14307 switch key { 14308 case "DefaultValue": 14309 if err := awsRestjson1_deserializeDocumentTypedAttributeValue(&sv.DefaultValue, value); err != nil { 14310 return err 14311 } 14312 14313 case "IsImmutable": 14314 if value != nil { 14315 jtv, ok := value.(bool) 14316 if !ok { 14317 return fmt.Errorf("expected Bool to be of type *bool, got %T instead", value) 14318 } 14319 sv.IsImmutable = jtv 14320 } 14321 14322 case "Rules": 14323 if err := awsRestjson1_deserializeDocumentRuleMap(&sv.Rules, value); err != nil { 14324 return err 14325 } 14326 14327 case "Type": 14328 if value != nil { 14329 jtv, ok := value.(string) 14330 if !ok { 14331 return fmt.Errorf("expected FacetAttributeType to be of type string, got %T instead", value) 14332 } 14333 sv.Type = types.FacetAttributeType(jtv) 14334 } 14335 14336 default: 14337 _, _ = key, value 14338 14339 } 14340 } 14341 *v = sv 14342 return nil 14343} 14344 14345func awsRestjson1_deserializeDocumentFacetAttributeList(v *[]types.FacetAttribute, value interface{}) error { 14346 if v == nil { 14347 return fmt.Errorf("unexpected nil of type %T", v) 14348 } 14349 if value == nil { 14350 return nil 14351 } 14352 14353 shape, ok := value.([]interface{}) 14354 if !ok { 14355 return fmt.Errorf("unexpected JSON type %v", value) 14356 } 14357 14358 var cv []types.FacetAttribute 14359 if *v == nil { 14360 cv = []types.FacetAttribute{} 14361 } else { 14362 cv = *v 14363 } 14364 14365 for _, value := range shape { 14366 var col types.FacetAttribute 14367 destAddr := &col 14368 if err := awsRestjson1_deserializeDocumentFacetAttribute(&destAddr, value); err != nil { 14369 return err 14370 } 14371 col = *destAddr 14372 cv = append(cv, col) 14373 14374 } 14375 *v = cv 14376 return nil 14377} 14378 14379func awsRestjson1_deserializeDocumentFacetAttributeReference(v **types.FacetAttributeReference, value interface{}) error { 14380 if v == nil { 14381 return fmt.Errorf("unexpected nil of type %T", v) 14382 } 14383 if value == nil { 14384 return nil 14385 } 14386 14387 shape, ok := value.(map[string]interface{}) 14388 if !ok { 14389 return fmt.Errorf("unexpected JSON type %v", value) 14390 } 14391 14392 var sv *types.FacetAttributeReference 14393 if *v == nil { 14394 sv = &types.FacetAttributeReference{} 14395 } else { 14396 sv = *v 14397 } 14398 14399 for key, value := range shape { 14400 switch key { 14401 case "TargetAttributeName": 14402 if value != nil { 14403 jtv, ok := value.(string) 14404 if !ok { 14405 return fmt.Errorf("expected AttributeName to be of type string, got %T instead", value) 14406 } 14407 sv.TargetAttributeName = ptr.String(jtv) 14408 } 14409 14410 case "TargetFacetName": 14411 if value != nil { 14412 jtv, ok := value.(string) 14413 if !ok { 14414 return fmt.Errorf("expected FacetName to be of type string, got %T instead", value) 14415 } 14416 sv.TargetFacetName = ptr.String(jtv) 14417 } 14418 14419 default: 14420 _, _ = key, value 14421 14422 } 14423 } 14424 *v = sv 14425 return nil 14426} 14427 14428func awsRestjson1_deserializeDocumentFacetInUseException(v **types.FacetInUseException, value interface{}) error { 14429 if v == nil { 14430 return fmt.Errorf("unexpected nil of type %T", v) 14431 } 14432 if value == nil { 14433 return nil 14434 } 14435 14436 shape, ok := value.(map[string]interface{}) 14437 if !ok { 14438 return fmt.Errorf("unexpected JSON type %v", value) 14439 } 14440 14441 var sv *types.FacetInUseException 14442 if *v == nil { 14443 sv = &types.FacetInUseException{} 14444 } else { 14445 sv = *v 14446 } 14447 14448 for key, value := range shape { 14449 switch key { 14450 case "Message": 14451 if value != nil { 14452 jtv, ok := value.(string) 14453 if !ok { 14454 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 14455 } 14456 sv.Message = ptr.String(jtv) 14457 } 14458 14459 default: 14460 _, _ = key, value 14461 14462 } 14463 } 14464 *v = sv 14465 return nil 14466} 14467 14468func awsRestjson1_deserializeDocumentFacetNameList(v *[]string, value interface{}) error { 14469 if v == nil { 14470 return fmt.Errorf("unexpected nil of type %T", v) 14471 } 14472 if value == nil { 14473 return nil 14474 } 14475 14476 shape, ok := value.([]interface{}) 14477 if !ok { 14478 return fmt.Errorf("unexpected JSON type %v", value) 14479 } 14480 14481 var cv []string 14482 if *v == nil { 14483 cv = []string{} 14484 } else { 14485 cv = *v 14486 } 14487 14488 for _, value := range shape { 14489 var col string 14490 if value != nil { 14491 jtv, ok := value.(string) 14492 if !ok { 14493 return fmt.Errorf("expected FacetName to be of type string, got %T instead", value) 14494 } 14495 col = jtv 14496 } 14497 cv = append(cv, col) 14498 14499 } 14500 *v = cv 14501 return nil 14502} 14503 14504func awsRestjson1_deserializeDocumentFacetNotFoundException(v **types.FacetNotFoundException, value interface{}) error { 14505 if v == nil { 14506 return fmt.Errorf("unexpected nil of type %T", v) 14507 } 14508 if value == nil { 14509 return nil 14510 } 14511 14512 shape, ok := value.(map[string]interface{}) 14513 if !ok { 14514 return fmt.Errorf("unexpected JSON type %v", value) 14515 } 14516 14517 var sv *types.FacetNotFoundException 14518 if *v == nil { 14519 sv = &types.FacetNotFoundException{} 14520 } else { 14521 sv = *v 14522 } 14523 14524 for key, value := range shape { 14525 switch key { 14526 case "Message": 14527 if value != nil { 14528 jtv, ok := value.(string) 14529 if !ok { 14530 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 14531 } 14532 sv.Message = ptr.String(jtv) 14533 } 14534 14535 default: 14536 _, _ = key, value 14537 14538 } 14539 } 14540 *v = sv 14541 return nil 14542} 14543 14544func awsRestjson1_deserializeDocumentFacetValidationException(v **types.FacetValidationException, value interface{}) error { 14545 if v == nil { 14546 return fmt.Errorf("unexpected nil of type %T", v) 14547 } 14548 if value == nil { 14549 return nil 14550 } 14551 14552 shape, ok := value.(map[string]interface{}) 14553 if !ok { 14554 return fmt.Errorf("unexpected JSON type %v", value) 14555 } 14556 14557 var sv *types.FacetValidationException 14558 if *v == nil { 14559 sv = &types.FacetValidationException{} 14560 } else { 14561 sv = *v 14562 } 14563 14564 for key, value := range shape { 14565 switch key { 14566 case "Message": 14567 if value != nil { 14568 jtv, ok := value.(string) 14569 if !ok { 14570 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 14571 } 14572 sv.Message = ptr.String(jtv) 14573 } 14574 14575 default: 14576 _, _ = key, value 14577 14578 } 14579 } 14580 *v = sv 14581 return nil 14582} 14583 14584func awsRestjson1_deserializeDocumentIncompatibleSchemaException(v **types.IncompatibleSchemaException, value interface{}) error { 14585 if v == nil { 14586 return fmt.Errorf("unexpected nil of type %T", v) 14587 } 14588 if value == nil { 14589 return nil 14590 } 14591 14592 shape, ok := value.(map[string]interface{}) 14593 if !ok { 14594 return fmt.Errorf("unexpected JSON type %v", value) 14595 } 14596 14597 var sv *types.IncompatibleSchemaException 14598 if *v == nil { 14599 sv = &types.IncompatibleSchemaException{} 14600 } else { 14601 sv = *v 14602 } 14603 14604 for key, value := range shape { 14605 switch key { 14606 case "Message": 14607 if value != nil { 14608 jtv, ok := value.(string) 14609 if !ok { 14610 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 14611 } 14612 sv.Message = ptr.String(jtv) 14613 } 14614 14615 default: 14616 _, _ = key, value 14617 14618 } 14619 } 14620 *v = sv 14621 return nil 14622} 14623 14624func awsRestjson1_deserializeDocumentIndexAttachment(v **types.IndexAttachment, value interface{}) error { 14625 if v == nil { 14626 return fmt.Errorf("unexpected nil of type %T", v) 14627 } 14628 if value == nil { 14629 return nil 14630 } 14631 14632 shape, ok := value.(map[string]interface{}) 14633 if !ok { 14634 return fmt.Errorf("unexpected JSON type %v", value) 14635 } 14636 14637 var sv *types.IndexAttachment 14638 if *v == nil { 14639 sv = &types.IndexAttachment{} 14640 } else { 14641 sv = *v 14642 } 14643 14644 for key, value := range shape { 14645 switch key { 14646 case "IndexedAttributes": 14647 if err := awsRestjson1_deserializeDocumentAttributeKeyAndValueList(&sv.IndexedAttributes, value); err != nil { 14648 return err 14649 } 14650 14651 case "ObjectIdentifier": 14652 if value != nil { 14653 jtv, ok := value.(string) 14654 if !ok { 14655 return fmt.Errorf("expected ObjectIdentifier to be of type string, got %T instead", value) 14656 } 14657 sv.ObjectIdentifier = ptr.String(jtv) 14658 } 14659 14660 default: 14661 _, _ = key, value 14662 14663 } 14664 } 14665 *v = sv 14666 return nil 14667} 14668 14669func awsRestjson1_deserializeDocumentIndexAttachmentList(v *[]types.IndexAttachment, value interface{}) error { 14670 if v == nil { 14671 return fmt.Errorf("unexpected nil of type %T", v) 14672 } 14673 if value == nil { 14674 return nil 14675 } 14676 14677 shape, ok := value.([]interface{}) 14678 if !ok { 14679 return fmt.Errorf("unexpected JSON type %v", value) 14680 } 14681 14682 var cv []types.IndexAttachment 14683 if *v == nil { 14684 cv = []types.IndexAttachment{} 14685 } else { 14686 cv = *v 14687 } 14688 14689 for _, value := range shape { 14690 var col types.IndexAttachment 14691 destAddr := &col 14692 if err := awsRestjson1_deserializeDocumentIndexAttachment(&destAddr, value); err != nil { 14693 return err 14694 } 14695 col = *destAddr 14696 cv = append(cv, col) 14697 14698 } 14699 *v = cv 14700 return nil 14701} 14702 14703func awsRestjson1_deserializeDocumentIndexedAttributeMissingException(v **types.IndexedAttributeMissingException, value interface{}) error { 14704 if v == nil { 14705 return fmt.Errorf("unexpected nil of type %T", v) 14706 } 14707 if value == nil { 14708 return nil 14709 } 14710 14711 shape, ok := value.(map[string]interface{}) 14712 if !ok { 14713 return fmt.Errorf("unexpected JSON type %v", value) 14714 } 14715 14716 var sv *types.IndexedAttributeMissingException 14717 if *v == nil { 14718 sv = &types.IndexedAttributeMissingException{} 14719 } else { 14720 sv = *v 14721 } 14722 14723 for key, value := range shape { 14724 switch key { 14725 case "Message": 14726 if value != nil { 14727 jtv, ok := value.(string) 14728 if !ok { 14729 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 14730 } 14731 sv.Message = ptr.String(jtv) 14732 } 14733 14734 default: 14735 _, _ = key, value 14736 14737 } 14738 } 14739 *v = sv 14740 return nil 14741} 14742 14743func awsRestjson1_deserializeDocumentInternalServiceException(v **types.InternalServiceException, value interface{}) error { 14744 if v == nil { 14745 return fmt.Errorf("unexpected nil of type %T", v) 14746 } 14747 if value == nil { 14748 return nil 14749 } 14750 14751 shape, ok := value.(map[string]interface{}) 14752 if !ok { 14753 return fmt.Errorf("unexpected JSON type %v", value) 14754 } 14755 14756 var sv *types.InternalServiceException 14757 if *v == nil { 14758 sv = &types.InternalServiceException{} 14759 } else { 14760 sv = *v 14761 } 14762 14763 for key, value := range shape { 14764 switch key { 14765 case "Message": 14766 if value != nil { 14767 jtv, ok := value.(string) 14768 if !ok { 14769 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 14770 } 14771 sv.Message = ptr.String(jtv) 14772 } 14773 14774 default: 14775 _, _ = key, value 14776 14777 } 14778 } 14779 *v = sv 14780 return nil 14781} 14782 14783func awsRestjson1_deserializeDocumentInvalidArnException(v **types.InvalidArnException, value interface{}) error { 14784 if v == nil { 14785 return fmt.Errorf("unexpected nil of type %T", v) 14786 } 14787 if value == nil { 14788 return nil 14789 } 14790 14791 shape, ok := value.(map[string]interface{}) 14792 if !ok { 14793 return fmt.Errorf("unexpected JSON type %v", value) 14794 } 14795 14796 var sv *types.InvalidArnException 14797 if *v == nil { 14798 sv = &types.InvalidArnException{} 14799 } else { 14800 sv = *v 14801 } 14802 14803 for key, value := range shape { 14804 switch key { 14805 case "Message": 14806 if value != nil { 14807 jtv, ok := value.(string) 14808 if !ok { 14809 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 14810 } 14811 sv.Message = ptr.String(jtv) 14812 } 14813 14814 default: 14815 _, _ = key, value 14816 14817 } 14818 } 14819 *v = sv 14820 return nil 14821} 14822 14823func awsRestjson1_deserializeDocumentInvalidAttachmentException(v **types.InvalidAttachmentException, value interface{}) error { 14824 if v == nil { 14825 return fmt.Errorf("unexpected nil of type %T", v) 14826 } 14827 if value == nil { 14828 return nil 14829 } 14830 14831 shape, ok := value.(map[string]interface{}) 14832 if !ok { 14833 return fmt.Errorf("unexpected JSON type %v", value) 14834 } 14835 14836 var sv *types.InvalidAttachmentException 14837 if *v == nil { 14838 sv = &types.InvalidAttachmentException{} 14839 } else { 14840 sv = *v 14841 } 14842 14843 for key, value := range shape { 14844 switch key { 14845 case "Message": 14846 if value != nil { 14847 jtv, ok := value.(string) 14848 if !ok { 14849 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 14850 } 14851 sv.Message = ptr.String(jtv) 14852 } 14853 14854 default: 14855 _, _ = key, value 14856 14857 } 14858 } 14859 *v = sv 14860 return nil 14861} 14862 14863func awsRestjson1_deserializeDocumentInvalidFacetUpdateException(v **types.InvalidFacetUpdateException, value interface{}) error { 14864 if v == nil { 14865 return fmt.Errorf("unexpected nil of type %T", v) 14866 } 14867 if value == nil { 14868 return nil 14869 } 14870 14871 shape, ok := value.(map[string]interface{}) 14872 if !ok { 14873 return fmt.Errorf("unexpected JSON type %v", value) 14874 } 14875 14876 var sv *types.InvalidFacetUpdateException 14877 if *v == nil { 14878 sv = &types.InvalidFacetUpdateException{} 14879 } else { 14880 sv = *v 14881 } 14882 14883 for key, value := range shape { 14884 switch key { 14885 case "Message": 14886 if value != nil { 14887 jtv, ok := value.(string) 14888 if !ok { 14889 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 14890 } 14891 sv.Message = ptr.String(jtv) 14892 } 14893 14894 default: 14895 _, _ = key, value 14896 14897 } 14898 } 14899 *v = sv 14900 return nil 14901} 14902 14903func awsRestjson1_deserializeDocumentInvalidNextTokenException(v **types.InvalidNextTokenException, value interface{}) error { 14904 if v == nil { 14905 return fmt.Errorf("unexpected nil of type %T", v) 14906 } 14907 if value == nil { 14908 return nil 14909 } 14910 14911 shape, ok := value.(map[string]interface{}) 14912 if !ok { 14913 return fmt.Errorf("unexpected JSON type %v", value) 14914 } 14915 14916 var sv *types.InvalidNextTokenException 14917 if *v == nil { 14918 sv = &types.InvalidNextTokenException{} 14919 } else { 14920 sv = *v 14921 } 14922 14923 for key, value := range shape { 14924 switch key { 14925 case "Message": 14926 if value != nil { 14927 jtv, ok := value.(string) 14928 if !ok { 14929 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 14930 } 14931 sv.Message = ptr.String(jtv) 14932 } 14933 14934 default: 14935 _, _ = key, value 14936 14937 } 14938 } 14939 *v = sv 14940 return nil 14941} 14942 14943func awsRestjson1_deserializeDocumentInvalidRuleException(v **types.InvalidRuleException, value interface{}) error { 14944 if v == nil { 14945 return fmt.Errorf("unexpected nil of type %T", v) 14946 } 14947 if value == nil { 14948 return nil 14949 } 14950 14951 shape, ok := value.(map[string]interface{}) 14952 if !ok { 14953 return fmt.Errorf("unexpected JSON type %v", value) 14954 } 14955 14956 var sv *types.InvalidRuleException 14957 if *v == nil { 14958 sv = &types.InvalidRuleException{} 14959 } else { 14960 sv = *v 14961 } 14962 14963 for key, value := range shape { 14964 switch key { 14965 case "Message": 14966 if value != nil { 14967 jtv, ok := value.(string) 14968 if !ok { 14969 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 14970 } 14971 sv.Message = ptr.String(jtv) 14972 } 14973 14974 default: 14975 _, _ = key, value 14976 14977 } 14978 } 14979 *v = sv 14980 return nil 14981} 14982 14983func awsRestjson1_deserializeDocumentInvalidSchemaDocException(v **types.InvalidSchemaDocException, value interface{}) error { 14984 if v == nil { 14985 return fmt.Errorf("unexpected nil of type %T", v) 14986 } 14987 if value == nil { 14988 return nil 14989 } 14990 14991 shape, ok := value.(map[string]interface{}) 14992 if !ok { 14993 return fmt.Errorf("unexpected JSON type %v", value) 14994 } 14995 14996 var sv *types.InvalidSchemaDocException 14997 if *v == nil { 14998 sv = &types.InvalidSchemaDocException{} 14999 } else { 15000 sv = *v 15001 } 15002 15003 for key, value := range shape { 15004 switch key { 15005 case "Message": 15006 if value != nil { 15007 jtv, ok := value.(string) 15008 if !ok { 15009 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 15010 } 15011 sv.Message = ptr.String(jtv) 15012 } 15013 15014 default: 15015 _, _ = key, value 15016 15017 } 15018 } 15019 *v = sv 15020 return nil 15021} 15022 15023func awsRestjson1_deserializeDocumentInvalidTaggingRequestException(v **types.InvalidTaggingRequestException, value interface{}) error { 15024 if v == nil { 15025 return fmt.Errorf("unexpected nil of type %T", v) 15026 } 15027 if value == nil { 15028 return nil 15029 } 15030 15031 shape, ok := value.(map[string]interface{}) 15032 if !ok { 15033 return fmt.Errorf("unexpected JSON type %v", value) 15034 } 15035 15036 var sv *types.InvalidTaggingRequestException 15037 if *v == nil { 15038 sv = &types.InvalidTaggingRequestException{} 15039 } else { 15040 sv = *v 15041 } 15042 15043 for key, value := range shape { 15044 switch key { 15045 case "Message": 15046 if value != nil { 15047 jtv, ok := value.(string) 15048 if !ok { 15049 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 15050 } 15051 sv.Message = ptr.String(jtv) 15052 } 15053 15054 default: 15055 _, _ = key, value 15056 15057 } 15058 } 15059 *v = sv 15060 return nil 15061} 15062 15063func awsRestjson1_deserializeDocumentLimitExceededException(v **types.LimitExceededException, value interface{}) error { 15064 if v == nil { 15065 return fmt.Errorf("unexpected nil of type %T", v) 15066 } 15067 if value == nil { 15068 return nil 15069 } 15070 15071 shape, ok := value.(map[string]interface{}) 15072 if !ok { 15073 return fmt.Errorf("unexpected JSON type %v", value) 15074 } 15075 15076 var sv *types.LimitExceededException 15077 if *v == nil { 15078 sv = &types.LimitExceededException{} 15079 } else { 15080 sv = *v 15081 } 15082 15083 for key, value := range shape { 15084 switch key { 15085 case "Message": 15086 if value != nil { 15087 jtv, ok := value.(string) 15088 if !ok { 15089 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 15090 } 15091 sv.Message = ptr.String(jtv) 15092 } 15093 15094 default: 15095 _, _ = key, value 15096 15097 } 15098 } 15099 *v = sv 15100 return nil 15101} 15102 15103func awsRestjson1_deserializeDocumentLinkNameAlreadyInUseException(v **types.LinkNameAlreadyInUseException, value interface{}) error { 15104 if v == nil { 15105 return fmt.Errorf("unexpected nil of type %T", v) 15106 } 15107 if value == nil { 15108 return nil 15109 } 15110 15111 shape, ok := value.(map[string]interface{}) 15112 if !ok { 15113 return fmt.Errorf("unexpected JSON type %v", value) 15114 } 15115 15116 var sv *types.LinkNameAlreadyInUseException 15117 if *v == nil { 15118 sv = &types.LinkNameAlreadyInUseException{} 15119 } else { 15120 sv = *v 15121 } 15122 15123 for key, value := range shape { 15124 switch key { 15125 case "Message": 15126 if value != nil { 15127 jtv, ok := value.(string) 15128 if !ok { 15129 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 15130 } 15131 sv.Message = ptr.String(jtv) 15132 } 15133 15134 default: 15135 _, _ = key, value 15136 15137 } 15138 } 15139 *v = sv 15140 return nil 15141} 15142 15143func awsRestjson1_deserializeDocumentLinkNameToObjectIdentifierMap(v *map[string]string, value interface{}) error { 15144 if v == nil { 15145 return fmt.Errorf("unexpected nil of type %T", v) 15146 } 15147 if value == nil { 15148 return nil 15149 } 15150 15151 shape, ok := value.(map[string]interface{}) 15152 if !ok { 15153 return fmt.Errorf("unexpected JSON type %v", value) 15154 } 15155 15156 var mv map[string]string 15157 if *v == nil { 15158 mv = map[string]string{} 15159 } else { 15160 mv = *v 15161 } 15162 15163 for key, value := range shape { 15164 var parsedVal string 15165 if value != nil { 15166 jtv, ok := value.(string) 15167 if !ok { 15168 return fmt.Errorf("expected ObjectIdentifier to be of type string, got %T instead", value) 15169 } 15170 parsedVal = jtv 15171 } 15172 mv[key] = parsedVal 15173 15174 } 15175 *v = mv 15176 return nil 15177} 15178 15179func awsRestjson1_deserializeDocumentNotIndexException(v **types.NotIndexException, value interface{}) error { 15180 if v == nil { 15181 return fmt.Errorf("unexpected nil of type %T", v) 15182 } 15183 if value == nil { 15184 return nil 15185 } 15186 15187 shape, ok := value.(map[string]interface{}) 15188 if !ok { 15189 return fmt.Errorf("unexpected JSON type %v", value) 15190 } 15191 15192 var sv *types.NotIndexException 15193 if *v == nil { 15194 sv = &types.NotIndexException{} 15195 } else { 15196 sv = *v 15197 } 15198 15199 for key, value := range shape { 15200 switch key { 15201 case "Message": 15202 if value != nil { 15203 jtv, ok := value.(string) 15204 if !ok { 15205 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 15206 } 15207 sv.Message = ptr.String(jtv) 15208 } 15209 15210 default: 15211 _, _ = key, value 15212 15213 } 15214 } 15215 *v = sv 15216 return nil 15217} 15218 15219func awsRestjson1_deserializeDocumentNotNodeException(v **types.NotNodeException, value interface{}) error { 15220 if v == nil { 15221 return fmt.Errorf("unexpected nil of type %T", v) 15222 } 15223 if value == nil { 15224 return nil 15225 } 15226 15227 shape, ok := value.(map[string]interface{}) 15228 if !ok { 15229 return fmt.Errorf("unexpected JSON type %v", value) 15230 } 15231 15232 var sv *types.NotNodeException 15233 if *v == nil { 15234 sv = &types.NotNodeException{} 15235 } else { 15236 sv = *v 15237 } 15238 15239 for key, value := range shape { 15240 switch key { 15241 case "Message": 15242 if value != nil { 15243 jtv, ok := value.(string) 15244 if !ok { 15245 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 15246 } 15247 sv.Message = ptr.String(jtv) 15248 } 15249 15250 default: 15251 _, _ = key, value 15252 15253 } 15254 } 15255 *v = sv 15256 return nil 15257} 15258 15259func awsRestjson1_deserializeDocumentNotPolicyException(v **types.NotPolicyException, value interface{}) error { 15260 if v == nil { 15261 return fmt.Errorf("unexpected nil of type %T", v) 15262 } 15263 if value == nil { 15264 return nil 15265 } 15266 15267 shape, ok := value.(map[string]interface{}) 15268 if !ok { 15269 return fmt.Errorf("unexpected JSON type %v", value) 15270 } 15271 15272 var sv *types.NotPolicyException 15273 if *v == nil { 15274 sv = &types.NotPolicyException{} 15275 } else { 15276 sv = *v 15277 } 15278 15279 for key, value := range shape { 15280 switch key { 15281 case "Message": 15282 if value != nil { 15283 jtv, ok := value.(string) 15284 if !ok { 15285 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 15286 } 15287 sv.Message = ptr.String(jtv) 15288 } 15289 15290 default: 15291 _, _ = key, value 15292 15293 } 15294 } 15295 *v = sv 15296 return nil 15297} 15298 15299func awsRestjson1_deserializeDocumentObjectAlreadyDetachedException(v **types.ObjectAlreadyDetachedException, value interface{}) error { 15300 if v == nil { 15301 return fmt.Errorf("unexpected nil of type %T", v) 15302 } 15303 if value == nil { 15304 return nil 15305 } 15306 15307 shape, ok := value.(map[string]interface{}) 15308 if !ok { 15309 return fmt.Errorf("unexpected JSON type %v", value) 15310 } 15311 15312 var sv *types.ObjectAlreadyDetachedException 15313 if *v == nil { 15314 sv = &types.ObjectAlreadyDetachedException{} 15315 } else { 15316 sv = *v 15317 } 15318 15319 for key, value := range shape { 15320 switch key { 15321 case "Message": 15322 if value != nil { 15323 jtv, ok := value.(string) 15324 if !ok { 15325 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 15326 } 15327 sv.Message = ptr.String(jtv) 15328 } 15329 15330 default: 15331 _, _ = key, value 15332 15333 } 15334 } 15335 *v = sv 15336 return nil 15337} 15338 15339func awsRestjson1_deserializeDocumentObjectIdentifierAndLinkNameList(v *[]types.ObjectIdentifierAndLinkNameTuple, value interface{}) error { 15340 if v == nil { 15341 return fmt.Errorf("unexpected nil of type %T", v) 15342 } 15343 if value == nil { 15344 return nil 15345 } 15346 15347 shape, ok := value.([]interface{}) 15348 if !ok { 15349 return fmt.Errorf("unexpected JSON type %v", value) 15350 } 15351 15352 var cv []types.ObjectIdentifierAndLinkNameTuple 15353 if *v == nil { 15354 cv = []types.ObjectIdentifierAndLinkNameTuple{} 15355 } else { 15356 cv = *v 15357 } 15358 15359 for _, value := range shape { 15360 var col types.ObjectIdentifierAndLinkNameTuple 15361 destAddr := &col 15362 if err := awsRestjson1_deserializeDocumentObjectIdentifierAndLinkNameTuple(&destAddr, value); err != nil { 15363 return err 15364 } 15365 col = *destAddr 15366 cv = append(cv, col) 15367 15368 } 15369 *v = cv 15370 return nil 15371} 15372 15373func awsRestjson1_deserializeDocumentObjectIdentifierAndLinkNameTuple(v **types.ObjectIdentifierAndLinkNameTuple, value interface{}) error { 15374 if v == nil { 15375 return fmt.Errorf("unexpected nil of type %T", v) 15376 } 15377 if value == nil { 15378 return nil 15379 } 15380 15381 shape, ok := value.(map[string]interface{}) 15382 if !ok { 15383 return fmt.Errorf("unexpected JSON type %v", value) 15384 } 15385 15386 var sv *types.ObjectIdentifierAndLinkNameTuple 15387 if *v == nil { 15388 sv = &types.ObjectIdentifierAndLinkNameTuple{} 15389 } else { 15390 sv = *v 15391 } 15392 15393 for key, value := range shape { 15394 switch key { 15395 case "LinkName": 15396 if value != nil { 15397 jtv, ok := value.(string) 15398 if !ok { 15399 return fmt.Errorf("expected LinkName to be of type string, got %T instead", value) 15400 } 15401 sv.LinkName = ptr.String(jtv) 15402 } 15403 15404 case "ObjectIdentifier": 15405 if value != nil { 15406 jtv, ok := value.(string) 15407 if !ok { 15408 return fmt.Errorf("expected ObjectIdentifier to be of type string, got %T instead", value) 15409 } 15410 sv.ObjectIdentifier = ptr.String(jtv) 15411 } 15412 15413 default: 15414 _, _ = key, value 15415 15416 } 15417 } 15418 *v = sv 15419 return nil 15420} 15421 15422func awsRestjson1_deserializeDocumentObjectIdentifierList(v *[]string, value interface{}) error { 15423 if v == nil { 15424 return fmt.Errorf("unexpected nil of type %T", v) 15425 } 15426 if value == nil { 15427 return nil 15428 } 15429 15430 shape, ok := value.([]interface{}) 15431 if !ok { 15432 return fmt.Errorf("unexpected JSON type %v", value) 15433 } 15434 15435 var cv []string 15436 if *v == nil { 15437 cv = []string{} 15438 } else { 15439 cv = *v 15440 } 15441 15442 for _, value := range shape { 15443 var col string 15444 if value != nil { 15445 jtv, ok := value.(string) 15446 if !ok { 15447 return fmt.Errorf("expected ObjectIdentifier to be of type string, got %T instead", value) 15448 } 15449 col = jtv 15450 } 15451 cv = append(cv, col) 15452 15453 } 15454 *v = cv 15455 return nil 15456} 15457 15458func awsRestjson1_deserializeDocumentObjectIdentifierToLinkNameMap(v *map[string]string, value interface{}) error { 15459 if v == nil { 15460 return fmt.Errorf("unexpected nil of type %T", v) 15461 } 15462 if value == nil { 15463 return nil 15464 } 15465 15466 shape, ok := value.(map[string]interface{}) 15467 if !ok { 15468 return fmt.Errorf("unexpected JSON type %v", value) 15469 } 15470 15471 var mv map[string]string 15472 if *v == nil { 15473 mv = map[string]string{} 15474 } else { 15475 mv = *v 15476 } 15477 15478 for key, value := range shape { 15479 var parsedVal string 15480 if value != nil { 15481 jtv, ok := value.(string) 15482 if !ok { 15483 return fmt.Errorf("expected LinkName to be of type string, got %T instead", value) 15484 } 15485 parsedVal = jtv 15486 } 15487 mv[key] = parsedVal 15488 15489 } 15490 *v = mv 15491 return nil 15492} 15493 15494func awsRestjson1_deserializeDocumentObjectNotDetachedException(v **types.ObjectNotDetachedException, value interface{}) error { 15495 if v == nil { 15496 return fmt.Errorf("unexpected nil of type %T", v) 15497 } 15498 if value == nil { 15499 return nil 15500 } 15501 15502 shape, ok := value.(map[string]interface{}) 15503 if !ok { 15504 return fmt.Errorf("unexpected JSON type %v", value) 15505 } 15506 15507 var sv *types.ObjectNotDetachedException 15508 if *v == nil { 15509 sv = &types.ObjectNotDetachedException{} 15510 } else { 15511 sv = *v 15512 } 15513 15514 for key, value := range shape { 15515 switch key { 15516 case "Message": 15517 if value != nil { 15518 jtv, ok := value.(string) 15519 if !ok { 15520 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 15521 } 15522 sv.Message = ptr.String(jtv) 15523 } 15524 15525 default: 15526 _, _ = key, value 15527 15528 } 15529 } 15530 *v = sv 15531 return nil 15532} 15533 15534func awsRestjson1_deserializeDocumentObjectReference(v **types.ObjectReference, value interface{}) error { 15535 if v == nil { 15536 return fmt.Errorf("unexpected nil of type %T", v) 15537 } 15538 if value == nil { 15539 return nil 15540 } 15541 15542 shape, ok := value.(map[string]interface{}) 15543 if !ok { 15544 return fmt.Errorf("unexpected JSON type %v", value) 15545 } 15546 15547 var sv *types.ObjectReference 15548 if *v == nil { 15549 sv = &types.ObjectReference{} 15550 } else { 15551 sv = *v 15552 } 15553 15554 for key, value := range shape { 15555 switch key { 15556 case "Selector": 15557 if value != nil { 15558 jtv, ok := value.(string) 15559 if !ok { 15560 return fmt.Errorf("expected SelectorObjectReference to be of type string, got %T instead", value) 15561 } 15562 sv.Selector = ptr.String(jtv) 15563 } 15564 15565 default: 15566 _, _ = key, value 15567 15568 } 15569 } 15570 *v = sv 15571 return nil 15572} 15573 15574func awsRestjson1_deserializeDocumentPathToObjectIdentifiers(v **types.PathToObjectIdentifiers, value interface{}) error { 15575 if v == nil { 15576 return fmt.Errorf("unexpected nil of type %T", v) 15577 } 15578 if value == nil { 15579 return nil 15580 } 15581 15582 shape, ok := value.(map[string]interface{}) 15583 if !ok { 15584 return fmt.Errorf("unexpected JSON type %v", value) 15585 } 15586 15587 var sv *types.PathToObjectIdentifiers 15588 if *v == nil { 15589 sv = &types.PathToObjectIdentifiers{} 15590 } else { 15591 sv = *v 15592 } 15593 15594 for key, value := range shape { 15595 switch key { 15596 case "ObjectIdentifiers": 15597 if err := awsRestjson1_deserializeDocumentObjectIdentifierList(&sv.ObjectIdentifiers, value); err != nil { 15598 return err 15599 } 15600 15601 case "Path": 15602 if value != nil { 15603 jtv, ok := value.(string) 15604 if !ok { 15605 return fmt.Errorf("expected PathString to be of type string, got %T instead", value) 15606 } 15607 sv.Path = ptr.String(jtv) 15608 } 15609 15610 default: 15611 _, _ = key, value 15612 15613 } 15614 } 15615 *v = sv 15616 return nil 15617} 15618 15619func awsRestjson1_deserializeDocumentPathToObjectIdentifiersList(v *[]types.PathToObjectIdentifiers, value interface{}) error { 15620 if v == nil { 15621 return fmt.Errorf("unexpected nil of type %T", v) 15622 } 15623 if value == nil { 15624 return nil 15625 } 15626 15627 shape, ok := value.([]interface{}) 15628 if !ok { 15629 return fmt.Errorf("unexpected JSON type %v", value) 15630 } 15631 15632 var cv []types.PathToObjectIdentifiers 15633 if *v == nil { 15634 cv = []types.PathToObjectIdentifiers{} 15635 } else { 15636 cv = *v 15637 } 15638 15639 for _, value := range shape { 15640 var col types.PathToObjectIdentifiers 15641 destAddr := &col 15642 if err := awsRestjson1_deserializeDocumentPathToObjectIdentifiers(&destAddr, value); err != nil { 15643 return err 15644 } 15645 col = *destAddr 15646 cv = append(cv, col) 15647 15648 } 15649 *v = cv 15650 return nil 15651} 15652 15653func awsRestjson1_deserializeDocumentPolicyAttachment(v **types.PolicyAttachment, value interface{}) error { 15654 if v == nil { 15655 return fmt.Errorf("unexpected nil of type %T", v) 15656 } 15657 if value == nil { 15658 return nil 15659 } 15660 15661 shape, ok := value.(map[string]interface{}) 15662 if !ok { 15663 return fmt.Errorf("unexpected JSON type %v", value) 15664 } 15665 15666 var sv *types.PolicyAttachment 15667 if *v == nil { 15668 sv = &types.PolicyAttachment{} 15669 } else { 15670 sv = *v 15671 } 15672 15673 for key, value := range shape { 15674 switch key { 15675 case "ObjectIdentifier": 15676 if value != nil { 15677 jtv, ok := value.(string) 15678 if !ok { 15679 return fmt.Errorf("expected ObjectIdentifier to be of type string, got %T instead", value) 15680 } 15681 sv.ObjectIdentifier = ptr.String(jtv) 15682 } 15683 15684 case "PolicyId": 15685 if value != nil { 15686 jtv, ok := value.(string) 15687 if !ok { 15688 return fmt.Errorf("expected ObjectIdentifier to be of type string, got %T instead", value) 15689 } 15690 sv.PolicyId = ptr.String(jtv) 15691 } 15692 15693 case "PolicyType": 15694 if value != nil { 15695 jtv, ok := value.(string) 15696 if !ok { 15697 return fmt.Errorf("expected PolicyType to be of type string, got %T instead", value) 15698 } 15699 sv.PolicyType = ptr.String(jtv) 15700 } 15701 15702 default: 15703 _, _ = key, value 15704 15705 } 15706 } 15707 *v = sv 15708 return nil 15709} 15710 15711func awsRestjson1_deserializeDocumentPolicyAttachmentList(v *[]types.PolicyAttachment, value interface{}) error { 15712 if v == nil { 15713 return fmt.Errorf("unexpected nil of type %T", v) 15714 } 15715 if value == nil { 15716 return nil 15717 } 15718 15719 shape, ok := value.([]interface{}) 15720 if !ok { 15721 return fmt.Errorf("unexpected JSON type %v", value) 15722 } 15723 15724 var cv []types.PolicyAttachment 15725 if *v == nil { 15726 cv = []types.PolicyAttachment{} 15727 } else { 15728 cv = *v 15729 } 15730 15731 for _, value := range shape { 15732 var col types.PolicyAttachment 15733 destAddr := &col 15734 if err := awsRestjson1_deserializeDocumentPolicyAttachment(&destAddr, value); err != nil { 15735 return err 15736 } 15737 col = *destAddr 15738 cv = append(cv, col) 15739 15740 } 15741 *v = cv 15742 return nil 15743} 15744 15745func awsRestjson1_deserializeDocumentPolicyToPath(v **types.PolicyToPath, value interface{}) error { 15746 if v == nil { 15747 return fmt.Errorf("unexpected nil of type %T", v) 15748 } 15749 if value == nil { 15750 return nil 15751 } 15752 15753 shape, ok := value.(map[string]interface{}) 15754 if !ok { 15755 return fmt.Errorf("unexpected JSON type %v", value) 15756 } 15757 15758 var sv *types.PolicyToPath 15759 if *v == nil { 15760 sv = &types.PolicyToPath{} 15761 } else { 15762 sv = *v 15763 } 15764 15765 for key, value := range shape { 15766 switch key { 15767 case "Path": 15768 if value != nil { 15769 jtv, ok := value.(string) 15770 if !ok { 15771 return fmt.Errorf("expected PathString to be of type string, got %T instead", value) 15772 } 15773 sv.Path = ptr.String(jtv) 15774 } 15775 15776 case "Policies": 15777 if err := awsRestjson1_deserializeDocumentPolicyAttachmentList(&sv.Policies, value); err != nil { 15778 return err 15779 } 15780 15781 default: 15782 _, _ = key, value 15783 15784 } 15785 } 15786 *v = sv 15787 return nil 15788} 15789 15790func awsRestjson1_deserializeDocumentPolicyToPathList(v *[]types.PolicyToPath, value interface{}) error { 15791 if v == nil { 15792 return fmt.Errorf("unexpected nil of type %T", v) 15793 } 15794 if value == nil { 15795 return nil 15796 } 15797 15798 shape, ok := value.([]interface{}) 15799 if !ok { 15800 return fmt.Errorf("unexpected JSON type %v", value) 15801 } 15802 15803 var cv []types.PolicyToPath 15804 if *v == nil { 15805 cv = []types.PolicyToPath{} 15806 } else { 15807 cv = *v 15808 } 15809 15810 for _, value := range shape { 15811 var col types.PolicyToPath 15812 destAddr := &col 15813 if err := awsRestjson1_deserializeDocumentPolicyToPath(&destAddr, value); err != nil { 15814 return err 15815 } 15816 col = *destAddr 15817 cv = append(cv, col) 15818 15819 } 15820 *v = cv 15821 return nil 15822} 15823 15824func awsRestjson1_deserializeDocumentResourceNotFoundException(v **types.ResourceNotFoundException, value interface{}) error { 15825 if v == nil { 15826 return fmt.Errorf("unexpected nil of type %T", v) 15827 } 15828 if value == nil { 15829 return nil 15830 } 15831 15832 shape, ok := value.(map[string]interface{}) 15833 if !ok { 15834 return fmt.Errorf("unexpected JSON type %v", value) 15835 } 15836 15837 var sv *types.ResourceNotFoundException 15838 if *v == nil { 15839 sv = &types.ResourceNotFoundException{} 15840 } else { 15841 sv = *v 15842 } 15843 15844 for key, value := range shape { 15845 switch key { 15846 case "Message": 15847 if value != nil { 15848 jtv, ok := value.(string) 15849 if !ok { 15850 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 15851 } 15852 sv.Message = ptr.String(jtv) 15853 } 15854 15855 default: 15856 _, _ = key, value 15857 15858 } 15859 } 15860 *v = sv 15861 return nil 15862} 15863 15864func awsRestjson1_deserializeDocumentRetryableConflictException(v **types.RetryableConflictException, value interface{}) error { 15865 if v == nil { 15866 return fmt.Errorf("unexpected nil of type %T", v) 15867 } 15868 if value == nil { 15869 return nil 15870 } 15871 15872 shape, ok := value.(map[string]interface{}) 15873 if !ok { 15874 return fmt.Errorf("unexpected JSON type %v", value) 15875 } 15876 15877 var sv *types.RetryableConflictException 15878 if *v == nil { 15879 sv = &types.RetryableConflictException{} 15880 } else { 15881 sv = *v 15882 } 15883 15884 for key, value := range shape { 15885 switch key { 15886 case "Message": 15887 if value != nil { 15888 jtv, ok := value.(string) 15889 if !ok { 15890 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 15891 } 15892 sv.Message = ptr.String(jtv) 15893 } 15894 15895 default: 15896 _, _ = key, value 15897 15898 } 15899 } 15900 *v = sv 15901 return nil 15902} 15903 15904func awsRestjson1_deserializeDocumentRule(v **types.Rule, value interface{}) error { 15905 if v == nil { 15906 return fmt.Errorf("unexpected nil of type %T", v) 15907 } 15908 if value == nil { 15909 return nil 15910 } 15911 15912 shape, ok := value.(map[string]interface{}) 15913 if !ok { 15914 return fmt.Errorf("unexpected JSON type %v", value) 15915 } 15916 15917 var sv *types.Rule 15918 if *v == nil { 15919 sv = &types.Rule{} 15920 } else { 15921 sv = *v 15922 } 15923 15924 for key, value := range shape { 15925 switch key { 15926 case "Parameters": 15927 if err := awsRestjson1_deserializeDocumentRuleParameterMap(&sv.Parameters, value); err != nil { 15928 return err 15929 } 15930 15931 case "Type": 15932 if value != nil { 15933 jtv, ok := value.(string) 15934 if !ok { 15935 return fmt.Errorf("expected RuleType to be of type string, got %T instead", value) 15936 } 15937 sv.Type = types.RuleType(jtv) 15938 } 15939 15940 default: 15941 _, _ = key, value 15942 15943 } 15944 } 15945 *v = sv 15946 return nil 15947} 15948 15949func awsRestjson1_deserializeDocumentRuleMap(v *map[string]types.Rule, value interface{}) error { 15950 if v == nil { 15951 return fmt.Errorf("unexpected nil of type %T", v) 15952 } 15953 if value == nil { 15954 return nil 15955 } 15956 15957 shape, ok := value.(map[string]interface{}) 15958 if !ok { 15959 return fmt.Errorf("unexpected JSON type %v", value) 15960 } 15961 15962 var mv map[string]types.Rule 15963 if *v == nil { 15964 mv = map[string]types.Rule{} 15965 } else { 15966 mv = *v 15967 } 15968 15969 for key, value := range shape { 15970 var parsedVal types.Rule 15971 mapVar := parsedVal 15972 destAddr := &mapVar 15973 if err := awsRestjson1_deserializeDocumentRule(&destAddr, value); err != nil { 15974 return err 15975 } 15976 parsedVal = *destAddr 15977 mv[key] = parsedVal 15978 15979 } 15980 *v = mv 15981 return nil 15982} 15983 15984func awsRestjson1_deserializeDocumentRuleParameterMap(v *map[string]string, value interface{}) error { 15985 if v == nil { 15986 return fmt.Errorf("unexpected nil of type %T", v) 15987 } 15988 if value == nil { 15989 return nil 15990 } 15991 15992 shape, ok := value.(map[string]interface{}) 15993 if !ok { 15994 return fmt.Errorf("unexpected JSON type %v", value) 15995 } 15996 15997 var mv map[string]string 15998 if *v == nil { 15999 mv = map[string]string{} 16000 } else { 16001 mv = *v 16002 } 16003 16004 for key, value := range shape { 16005 var parsedVal string 16006 if value != nil { 16007 jtv, ok := value.(string) 16008 if !ok { 16009 return fmt.Errorf("expected RuleParameterValue to be of type string, got %T instead", value) 16010 } 16011 parsedVal = jtv 16012 } 16013 mv[key] = parsedVal 16014 16015 } 16016 *v = mv 16017 return nil 16018} 16019 16020func awsRestjson1_deserializeDocumentSchemaAlreadyExistsException(v **types.SchemaAlreadyExistsException, value interface{}) error { 16021 if v == nil { 16022 return fmt.Errorf("unexpected nil of type %T", v) 16023 } 16024 if value == nil { 16025 return nil 16026 } 16027 16028 shape, ok := value.(map[string]interface{}) 16029 if !ok { 16030 return fmt.Errorf("unexpected JSON type %v", value) 16031 } 16032 16033 var sv *types.SchemaAlreadyExistsException 16034 if *v == nil { 16035 sv = &types.SchemaAlreadyExistsException{} 16036 } else { 16037 sv = *v 16038 } 16039 16040 for key, value := range shape { 16041 switch key { 16042 case "Message": 16043 if value != nil { 16044 jtv, ok := value.(string) 16045 if !ok { 16046 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 16047 } 16048 sv.Message = ptr.String(jtv) 16049 } 16050 16051 default: 16052 _, _ = key, value 16053 16054 } 16055 } 16056 *v = sv 16057 return nil 16058} 16059 16060func awsRestjson1_deserializeDocumentSchemaAlreadyPublishedException(v **types.SchemaAlreadyPublishedException, value interface{}) error { 16061 if v == nil { 16062 return fmt.Errorf("unexpected nil of type %T", v) 16063 } 16064 if value == nil { 16065 return nil 16066 } 16067 16068 shape, ok := value.(map[string]interface{}) 16069 if !ok { 16070 return fmt.Errorf("unexpected JSON type %v", value) 16071 } 16072 16073 var sv *types.SchemaAlreadyPublishedException 16074 if *v == nil { 16075 sv = &types.SchemaAlreadyPublishedException{} 16076 } else { 16077 sv = *v 16078 } 16079 16080 for key, value := range shape { 16081 switch key { 16082 case "Message": 16083 if value != nil { 16084 jtv, ok := value.(string) 16085 if !ok { 16086 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 16087 } 16088 sv.Message = ptr.String(jtv) 16089 } 16090 16091 default: 16092 _, _ = key, value 16093 16094 } 16095 } 16096 *v = sv 16097 return nil 16098} 16099 16100func awsRestjson1_deserializeDocumentSchemaFacet(v **types.SchemaFacet, value interface{}) error { 16101 if v == nil { 16102 return fmt.Errorf("unexpected nil of type %T", v) 16103 } 16104 if value == nil { 16105 return nil 16106 } 16107 16108 shape, ok := value.(map[string]interface{}) 16109 if !ok { 16110 return fmt.Errorf("unexpected JSON type %v", value) 16111 } 16112 16113 var sv *types.SchemaFacet 16114 if *v == nil { 16115 sv = &types.SchemaFacet{} 16116 } else { 16117 sv = *v 16118 } 16119 16120 for key, value := range shape { 16121 switch key { 16122 case "FacetName": 16123 if value != nil { 16124 jtv, ok := value.(string) 16125 if !ok { 16126 return fmt.Errorf("expected FacetName to be of type string, got %T instead", value) 16127 } 16128 sv.FacetName = ptr.String(jtv) 16129 } 16130 16131 case "SchemaArn": 16132 if value != nil { 16133 jtv, ok := value.(string) 16134 if !ok { 16135 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 16136 } 16137 sv.SchemaArn = ptr.String(jtv) 16138 } 16139 16140 default: 16141 _, _ = key, value 16142 16143 } 16144 } 16145 *v = sv 16146 return nil 16147} 16148 16149func awsRestjson1_deserializeDocumentSchemaFacetList(v *[]types.SchemaFacet, value interface{}) error { 16150 if v == nil { 16151 return fmt.Errorf("unexpected nil of type %T", v) 16152 } 16153 if value == nil { 16154 return nil 16155 } 16156 16157 shape, ok := value.([]interface{}) 16158 if !ok { 16159 return fmt.Errorf("unexpected JSON type %v", value) 16160 } 16161 16162 var cv []types.SchemaFacet 16163 if *v == nil { 16164 cv = []types.SchemaFacet{} 16165 } else { 16166 cv = *v 16167 } 16168 16169 for _, value := range shape { 16170 var col types.SchemaFacet 16171 destAddr := &col 16172 if err := awsRestjson1_deserializeDocumentSchemaFacet(&destAddr, value); err != nil { 16173 return err 16174 } 16175 col = *destAddr 16176 cv = append(cv, col) 16177 16178 } 16179 *v = cv 16180 return nil 16181} 16182 16183func awsRestjson1_deserializeDocumentStillContainsLinksException(v **types.StillContainsLinksException, value interface{}) error { 16184 if v == nil { 16185 return fmt.Errorf("unexpected nil of type %T", v) 16186 } 16187 if value == nil { 16188 return nil 16189 } 16190 16191 shape, ok := value.(map[string]interface{}) 16192 if !ok { 16193 return fmt.Errorf("unexpected JSON type %v", value) 16194 } 16195 16196 var sv *types.StillContainsLinksException 16197 if *v == nil { 16198 sv = &types.StillContainsLinksException{} 16199 } else { 16200 sv = *v 16201 } 16202 16203 for key, value := range shape { 16204 switch key { 16205 case "Message": 16206 if value != nil { 16207 jtv, ok := value.(string) 16208 if !ok { 16209 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 16210 } 16211 sv.Message = ptr.String(jtv) 16212 } 16213 16214 default: 16215 _, _ = key, value 16216 16217 } 16218 } 16219 *v = sv 16220 return nil 16221} 16222 16223func awsRestjson1_deserializeDocumentTag(v **types.Tag, value interface{}) error { 16224 if v == nil { 16225 return fmt.Errorf("unexpected nil of type %T", v) 16226 } 16227 if value == nil { 16228 return nil 16229 } 16230 16231 shape, ok := value.(map[string]interface{}) 16232 if !ok { 16233 return fmt.Errorf("unexpected JSON type %v", value) 16234 } 16235 16236 var sv *types.Tag 16237 if *v == nil { 16238 sv = &types.Tag{} 16239 } else { 16240 sv = *v 16241 } 16242 16243 for key, value := range shape { 16244 switch key { 16245 case "Key": 16246 if value != nil { 16247 jtv, ok := value.(string) 16248 if !ok { 16249 return fmt.Errorf("expected TagKey to be of type string, got %T instead", value) 16250 } 16251 sv.Key = ptr.String(jtv) 16252 } 16253 16254 case "Value": 16255 if value != nil { 16256 jtv, ok := value.(string) 16257 if !ok { 16258 return fmt.Errorf("expected TagValue to be of type string, got %T instead", value) 16259 } 16260 sv.Value = ptr.String(jtv) 16261 } 16262 16263 default: 16264 _, _ = key, value 16265 16266 } 16267 } 16268 *v = sv 16269 return nil 16270} 16271 16272func awsRestjson1_deserializeDocumentTagList(v *[]types.Tag, value interface{}) error { 16273 if v == nil { 16274 return fmt.Errorf("unexpected nil of type %T", v) 16275 } 16276 if value == nil { 16277 return nil 16278 } 16279 16280 shape, ok := value.([]interface{}) 16281 if !ok { 16282 return fmt.Errorf("unexpected JSON type %v", value) 16283 } 16284 16285 var cv []types.Tag 16286 if *v == nil { 16287 cv = []types.Tag{} 16288 } else { 16289 cv = *v 16290 } 16291 16292 for _, value := range shape { 16293 var col types.Tag 16294 destAddr := &col 16295 if err := awsRestjson1_deserializeDocumentTag(&destAddr, value); err != nil { 16296 return err 16297 } 16298 col = *destAddr 16299 cv = append(cv, col) 16300 16301 } 16302 *v = cv 16303 return nil 16304} 16305 16306func awsRestjson1_deserializeDocumentTypedAttributeValue(v *types.TypedAttributeValue, value interface{}) error { 16307 if v == nil { 16308 return fmt.Errorf("unexpected nil of type %T", v) 16309 } 16310 if value == nil { 16311 return nil 16312 } 16313 16314 shape, ok := value.(map[string]interface{}) 16315 if !ok { 16316 return fmt.Errorf("unexpected JSON type %v", value) 16317 } 16318 16319 var uv types.TypedAttributeValue 16320loop: 16321 for key, value := range shape { 16322 if value == nil { 16323 continue 16324 } 16325 switch key { 16326 case "BinaryValue": 16327 var mv []byte 16328 if value != nil { 16329 jtv, ok := value.(string) 16330 if !ok { 16331 return fmt.Errorf("expected BinaryAttributeValue to be []byte, got %T instead", value) 16332 } 16333 dv, err := base64.StdEncoding.DecodeString(jtv) 16334 if err != nil { 16335 return fmt.Errorf("failed to base64 decode BinaryAttributeValue, %w", err) 16336 } 16337 mv = dv 16338 } 16339 uv = &types.TypedAttributeValueMemberBinaryValue{Value: mv} 16340 break loop 16341 16342 case "BooleanValue": 16343 var mv bool 16344 if value != nil { 16345 jtv, ok := value.(bool) 16346 if !ok { 16347 return fmt.Errorf("expected BooleanAttributeValue to be of type *bool, got %T instead", value) 16348 } 16349 mv = jtv 16350 } 16351 uv = &types.TypedAttributeValueMemberBooleanValue{Value: mv} 16352 break loop 16353 16354 case "DatetimeValue": 16355 var mv time.Time 16356 if value != nil { 16357 switch jtv := value.(type) { 16358 case json.Number: 16359 f64, err := jtv.Float64() 16360 if err != nil { 16361 return err 16362 } 16363 mv = smithytime.ParseEpochSeconds(f64) 16364 16365 default: 16366 return fmt.Errorf("expected DatetimeAttributeValue to be a JSON Number, got %T instead", value) 16367 16368 } 16369 } 16370 uv = &types.TypedAttributeValueMemberDatetimeValue{Value: mv} 16371 break loop 16372 16373 case "NumberValue": 16374 var mv string 16375 if value != nil { 16376 jtv, ok := value.(string) 16377 if !ok { 16378 return fmt.Errorf("expected NumberAttributeValue to be of type string, got %T instead", value) 16379 } 16380 mv = jtv 16381 } 16382 uv = &types.TypedAttributeValueMemberNumberValue{Value: mv} 16383 break loop 16384 16385 case "StringValue": 16386 var mv string 16387 if value != nil { 16388 jtv, ok := value.(string) 16389 if !ok { 16390 return fmt.Errorf("expected StringAttributeValue to be of type string, got %T instead", value) 16391 } 16392 mv = jtv 16393 } 16394 uv = &types.TypedAttributeValueMemberStringValue{Value: mv} 16395 break loop 16396 16397 default: 16398 uv = &types.UnknownUnionMember{Tag: key} 16399 break loop 16400 16401 } 16402 } 16403 *v = uv 16404 return nil 16405} 16406 16407func awsRestjson1_deserializeDocumentTypedLinkAttributeDefinition(v **types.TypedLinkAttributeDefinition, value interface{}) error { 16408 if v == nil { 16409 return fmt.Errorf("unexpected nil of type %T", v) 16410 } 16411 if value == nil { 16412 return nil 16413 } 16414 16415 shape, ok := value.(map[string]interface{}) 16416 if !ok { 16417 return fmt.Errorf("unexpected JSON type %v", value) 16418 } 16419 16420 var sv *types.TypedLinkAttributeDefinition 16421 if *v == nil { 16422 sv = &types.TypedLinkAttributeDefinition{} 16423 } else { 16424 sv = *v 16425 } 16426 16427 for key, value := range shape { 16428 switch key { 16429 case "DefaultValue": 16430 if err := awsRestjson1_deserializeDocumentTypedAttributeValue(&sv.DefaultValue, value); err != nil { 16431 return err 16432 } 16433 16434 case "IsImmutable": 16435 if value != nil { 16436 jtv, ok := value.(bool) 16437 if !ok { 16438 return fmt.Errorf("expected Bool to be of type *bool, got %T instead", value) 16439 } 16440 sv.IsImmutable = jtv 16441 } 16442 16443 case "Name": 16444 if value != nil { 16445 jtv, ok := value.(string) 16446 if !ok { 16447 return fmt.Errorf("expected AttributeName to be of type string, got %T instead", value) 16448 } 16449 sv.Name = ptr.String(jtv) 16450 } 16451 16452 case "RequiredBehavior": 16453 if value != nil { 16454 jtv, ok := value.(string) 16455 if !ok { 16456 return fmt.Errorf("expected RequiredAttributeBehavior to be of type string, got %T instead", value) 16457 } 16458 sv.RequiredBehavior = types.RequiredAttributeBehavior(jtv) 16459 } 16460 16461 case "Rules": 16462 if err := awsRestjson1_deserializeDocumentRuleMap(&sv.Rules, value); err != nil { 16463 return err 16464 } 16465 16466 case "Type": 16467 if value != nil { 16468 jtv, ok := value.(string) 16469 if !ok { 16470 return fmt.Errorf("expected FacetAttributeType to be of type string, got %T instead", value) 16471 } 16472 sv.Type = types.FacetAttributeType(jtv) 16473 } 16474 16475 default: 16476 _, _ = key, value 16477 16478 } 16479 } 16480 *v = sv 16481 return nil 16482} 16483 16484func awsRestjson1_deserializeDocumentTypedLinkAttributeDefinitionList(v *[]types.TypedLinkAttributeDefinition, value interface{}) error { 16485 if v == nil { 16486 return fmt.Errorf("unexpected nil of type %T", v) 16487 } 16488 if value == nil { 16489 return nil 16490 } 16491 16492 shape, ok := value.([]interface{}) 16493 if !ok { 16494 return fmt.Errorf("unexpected JSON type %v", value) 16495 } 16496 16497 var cv []types.TypedLinkAttributeDefinition 16498 if *v == nil { 16499 cv = []types.TypedLinkAttributeDefinition{} 16500 } else { 16501 cv = *v 16502 } 16503 16504 for _, value := range shape { 16505 var col types.TypedLinkAttributeDefinition 16506 destAddr := &col 16507 if err := awsRestjson1_deserializeDocumentTypedLinkAttributeDefinition(&destAddr, value); err != nil { 16508 return err 16509 } 16510 col = *destAddr 16511 cv = append(cv, col) 16512 16513 } 16514 *v = cv 16515 return nil 16516} 16517 16518func awsRestjson1_deserializeDocumentTypedLinkNameList(v *[]string, value interface{}) error { 16519 if v == nil { 16520 return fmt.Errorf("unexpected nil of type %T", v) 16521 } 16522 if value == nil { 16523 return nil 16524 } 16525 16526 shape, ok := value.([]interface{}) 16527 if !ok { 16528 return fmt.Errorf("unexpected JSON type %v", value) 16529 } 16530 16531 var cv []string 16532 if *v == nil { 16533 cv = []string{} 16534 } else { 16535 cv = *v 16536 } 16537 16538 for _, value := range shape { 16539 var col string 16540 if value != nil { 16541 jtv, ok := value.(string) 16542 if !ok { 16543 return fmt.Errorf("expected TypedLinkName to be of type string, got %T instead", value) 16544 } 16545 col = jtv 16546 } 16547 cv = append(cv, col) 16548 16549 } 16550 *v = cv 16551 return nil 16552} 16553 16554func awsRestjson1_deserializeDocumentTypedLinkSchemaAndFacetName(v **types.TypedLinkSchemaAndFacetName, value interface{}) error { 16555 if v == nil { 16556 return fmt.Errorf("unexpected nil of type %T", v) 16557 } 16558 if value == nil { 16559 return nil 16560 } 16561 16562 shape, ok := value.(map[string]interface{}) 16563 if !ok { 16564 return fmt.Errorf("unexpected JSON type %v", value) 16565 } 16566 16567 var sv *types.TypedLinkSchemaAndFacetName 16568 if *v == nil { 16569 sv = &types.TypedLinkSchemaAndFacetName{} 16570 } else { 16571 sv = *v 16572 } 16573 16574 for key, value := range shape { 16575 switch key { 16576 case "SchemaArn": 16577 if value != nil { 16578 jtv, ok := value.(string) 16579 if !ok { 16580 return fmt.Errorf("expected Arn to be of type string, got %T instead", value) 16581 } 16582 sv.SchemaArn = ptr.String(jtv) 16583 } 16584 16585 case "TypedLinkName": 16586 if value != nil { 16587 jtv, ok := value.(string) 16588 if !ok { 16589 return fmt.Errorf("expected TypedLinkName to be of type string, got %T instead", value) 16590 } 16591 sv.TypedLinkName = ptr.String(jtv) 16592 } 16593 16594 default: 16595 _, _ = key, value 16596 16597 } 16598 } 16599 *v = sv 16600 return nil 16601} 16602 16603func awsRestjson1_deserializeDocumentTypedLinkSpecifier(v **types.TypedLinkSpecifier, value interface{}) error { 16604 if v == nil { 16605 return fmt.Errorf("unexpected nil of type %T", v) 16606 } 16607 if value == nil { 16608 return nil 16609 } 16610 16611 shape, ok := value.(map[string]interface{}) 16612 if !ok { 16613 return fmt.Errorf("unexpected JSON type %v", value) 16614 } 16615 16616 var sv *types.TypedLinkSpecifier 16617 if *v == nil { 16618 sv = &types.TypedLinkSpecifier{} 16619 } else { 16620 sv = *v 16621 } 16622 16623 for key, value := range shape { 16624 switch key { 16625 case "IdentityAttributeValues": 16626 if err := awsRestjson1_deserializeDocumentAttributeNameAndValueList(&sv.IdentityAttributeValues, value); err != nil { 16627 return err 16628 } 16629 16630 case "SourceObjectReference": 16631 if err := awsRestjson1_deserializeDocumentObjectReference(&sv.SourceObjectReference, value); err != nil { 16632 return err 16633 } 16634 16635 case "TargetObjectReference": 16636 if err := awsRestjson1_deserializeDocumentObjectReference(&sv.TargetObjectReference, value); err != nil { 16637 return err 16638 } 16639 16640 case "TypedLinkFacet": 16641 if err := awsRestjson1_deserializeDocumentTypedLinkSchemaAndFacetName(&sv.TypedLinkFacet, value); err != nil { 16642 return err 16643 } 16644 16645 default: 16646 _, _ = key, value 16647 16648 } 16649 } 16650 *v = sv 16651 return nil 16652} 16653 16654func awsRestjson1_deserializeDocumentTypedLinkSpecifierList(v *[]types.TypedLinkSpecifier, value interface{}) error { 16655 if v == nil { 16656 return fmt.Errorf("unexpected nil of type %T", v) 16657 } 16658 if value == nil { 16659 return nil 16660 } 16661 16662 shape, ok := value.([]interface{}) 16663 if !ok { 16664 return fmt.Errorf("unexpected JSON type %v", value) 16665 } 16666 16667 var cv []types.TypedLinkSpecifier 16668 if *v == nil { 16669 cv = []types.TypedLinkSpecifier{} 16670 } else { 16671 cv = *v 16672 } 16673 16674 for _, value := range shape { 16675 var col types.TypedLinkSpecifier 16676 destAddr := &col 16677 if err := awsRestjson1_deserializeDocumentTypedLinkSpecifier(&destAddr, value); err != nil { 16678 return err 16679 } 16680 col = *destAddr 16681 cv = append(cv, col) 16682 16683 } 16684 *v = cv 16685 return nil 16686} 16687 16688func awsRestjson1_deserializeDocumentUnsupportedIndexTypeException(v **types.UnsupportedIndexTypeException, value interface{}) error { 16689 if v == nil { 16690 return fmt.Errorf("unexpected nil of type %T", v) 16691 } 16692 if value == nil { 16693 return nil 16694 } 16695 16696 shape, ok := value.(map[string]interface{}) 16697 if !ok { 16698 return fmt.Errorf("unexpected JSON type %v", value) 16699 } 16700 16701 var sv *types.UnsupportedIndexTypeException 16702 if *v == nil { 16703 sv = &types.UnsupportedIndexTypeException{} 16704 } else { 16705 sv = *v 16706 } 16707 16708 for key, value := range shape { 16709 switch key { 16710 case "Message": 16711 if value != nil { 16712 jtv, ok := value.(string) 16713 if !ok { 16714 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 16715 } 16716 sv.Message = ptr.String(jtv) 16717 } 16718 16719 default: 16720 _, _ = key, value 16721 16722 } 16723 } 16724 *v = sv 16725 return nil 16726} 16727 16728func awsRestjson1_deserializeDocumentValidationException(v **types.ValidationException, value interface{}) error { 16729 if v == nil { 16730 return fmt.Errorf("unexpected nil of type %T", v) 16731 } 16732 if value == nil { 16733 return nil 16734 } 16735 16736 shape, ok := value.(map[string]interface{}) 16737 if !ok { 16738 return fmt.Errorf("unexpected JSON type %v", value) 16739 } 16740 16741 var sv *types.ValidationException 16742 if *v == nil { 16743 sv = &types.ValidationException{} 16744 } else { 16745 sv = *v 16746 } 16747 16748 for key, value := range shape { 16749 switch key { 16750 case "Message": 16751 if value != nil { 16752 jtv, ok := value.(string) 16753 if !ok { 16754 return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value) 16755 } 16756 sv.Message = ptr.String(jtv) 16757 } 16758 16759 default: 16760 _, _ = key, value 16761 16762 } 16763 } 16764 *v = sv 16765 return nil 16766} 16767