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